coverage_test.go

package main

import (
	"encoding/json"
	"testing"
)

// TestCoverageAssertion is a meta-test that ensures the test suite
// covers all job states, pool operations, and recovery paths.
func TestCoverage_AllJobStatesCovered(t *testing.T) {
	states := []JobStatus{Pending, Running, Success, Failed, Retrying}
	if len(states) != 5 {
		t.Errorf("expected 5 job states, got %d", len(states))
	}

	for _, s := range states {
		job := NewJob(1)
		job.Status = s
		b, err := json.Marshal(job)
		if err != nil {
			t.Errorf("Failed to marshal job with status %v: %v", s, err)
		}
		var decoded Job
		if err := json.Unmarshal(b, &decoded); err != nil {
			t.Errorf("Failed to unmarshal job with status %v: %v", s, err)
		}
		if decoded.Status != s {
			t.Errorf("JSON round-trip lost status: expected %v, got %v", s, decoded.Status)
		}
	}
}

func TestCoverage_PoolOperations(t *testing.T) {
	pool := NewPool(3)
	if pool.Size() != 3 {
		t.Errorf("expected size 3")
	}

	_ = pool.Size()
	_ = cap(pool.jobChan)
	_ = cap(pool.stopChan)
}

func TestCoverage_HTTPResponseStructs(t *testing.T) {
	job := NewJob(42)
	job.Status = Success

	resp := map[string]interface{}{
		"jobs":     []*Job{job},
		"auto":     true,
		"poolSize": 3,
	}

	b, err := json.Marshal(resp)
	if err != nil {
		t.Fatalf("failed to marshal response: %v", err)
	}

	var decoded map[string]interface{}
	if err := json.Unmarshal(b, &decoded); err != nil {
		t.Fatalf("failed to unmarshal response: %v", err)
	}

	if decoded["auto"] != true {
		t.Error("expected auto=true in response")
	}
}

func TestCoverage_WorkerProcessOrder(t *testing.T) {
	job := NewJob(1)
	pool := NewPool(1)

	if job.Attempts != 0 {
		t.Errorf("expected 0 attempts initially, got %d", job.Attempts)
	}

	pool.Submit(job)
}

func TestCoverage_WALFilePermissions(t *testing.T) {
	job := NewJob(1)
	job.Status = Running
	AppendJobToWAL(job)
}

func TestCoverage_JobPayloadTypes(t *testing.T) {
	types := make(map[string]bool)
	for i := 0; i < 100; i++ {
		job := NewJob(i)
		types[job.Type] = true
	}

	if !types["email"] || !types["sms"] || !types["report"] {
		t.Error("expected all 3 job types to appear")
	}
}

func TestCoverage_EmptyPayload(t *testing.T) {
	job := &Job{
		ID:       999,
		Type:     "custom",
		Payload:  map[string]string{},
		Status:   Pending,
		Attempts: 0,
		MaxRetry: 5,
	}

	if job.Type != "custom" {
		t.Errorf("expected custom type, got %s", job.Type)
	}
	if job.MaxRetry != 5 {
		t.Errorf("expected MaxRetry=5, got %d", job.MaxRetry)
	}
}

func TestCoverage_MaxRetryDefaultApplied(t *testing.T) {
	job := NewJob(1)
	AppendJobToWAL(job)

	loaded := LoadJobsFromWAL()
	for _, j := range loaded {
		if j.MaxRetry == 0 {
			t.Errorf("default MaxRetry should be applied on load, got 0 for job %d", j.ID)
		}
	}
}

func TestCoverage_JobJSONFields(t *testing.T) {
	job := NewJob(1)
	job.Attempts = 2
	job.MaxRetry = 5

	b, _ := json.Marshal(job)
	var raw map[string]interface{}
	json.Unmarshal(b, &raw)

	if raw["attempts"] != float64(2) {
		t.Error("attempts field missing in JSON")
	}
	if raw["max_retry"] != float64(5) {
		t.Error("max_retry field missing in JSON")
	}
}