god-eye/internal/scheduler/scheduler_test.go

package scheduler

import (
	"context"
	"sync/atomic"
	"testing"
	"time"

	"god-eye/internal/diff"
	"god-eye/internal/store"
)

type spyAlerter struct{ called atomic.Int32 }

func (s *spyAlerter) Name() string                        { return "spy" }
func (s *spyAlerter) Notify(_ context.Context, _ *diff.Report) error {
	s.called.Add(1)
	return nil
}

func TestScheduler_RunsAndDiffsBetweenScans(t *testing.T) {
	var callCount atomic.Int32
	scan := ScanRun(func(_ context.Context) ([]*store.Host, error) {
		n := callCount.Add(1)
		if n == 1 {
			return []*store.Host{{Subdomain: "a.example.com"}}, nil
		}
		// Second scan adds a new host — meaningful diff.
		return []*store.Host{
			{Subdomain: "a.example.com"},
			{Subdomain: "b.example.com"},
		}, nil
	})

	s := New("example.com", 100*time.Millisecond, scan)
	alerter := &spyAlerter{}
	s.AddAlerter(alerter)

	ctx, cancel := context.WithTimeout(context.Background(), 300*time.Millisecond)
	defer cancel()
	_ = s.Start(ctx)

	if callCount.Load() < 2 {
		t.Errorf("scan should have run at least twice, got %d", callCount.Load())
	}
	if alerter.called.Load() == 0 {
		t.Error("alerter should have been called on the second run")
	}
}

func TestScheduler_NoAlertOnIdenticalScans(t *testing.T) {
	scan := ScanRun(func(_ context.Context) ([]*store.Host, error) {
		return []*store.Host{{Subdomain: "a.example.com"}}, nil
	})
	s := New("example.com", 50*time.Millisecond, scan)
	alerter := &spyAlerter{}
	s.AddAlerter(alerter)

	ctx, cancel := context.WithTimeout(context.Background(), 200*time.Millisecond)
	defer cancel()
	_ = s.Start(ctx)

	if alerter.called.Load() != 0 {
		t.Errorf("alerter should not have been called on unchanged scans, got %d", alerter.called.Load())
	}
}

func TestScheduler_RejectsBadParams(t *testing.T) {
	s := &Scheduler{Target: "x", Interval: 0}
	if err := s.Start(context.Background()); err == nil {
		t.Error("expected error for zero interval")
	}

	s2 := &Scheduler{Target: "x", Interval: time.Second, Run: nil}
	if err := s2.Start(context.Background()); err == nil {
		t.Error("expected error for nil Run")
	}
}