feat: schedule dataset collection

backend/internal/crontab/dataset_test.go

@@ -0,0 +1,150 @@
+package crontab
+
+import (
+	"context"
+	"io"
+	"log"
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+	"senlinai-agent/backend/internal/models"
+)
+
+func TestDatasetSchedulerCollectsImmediatelyAndRepeats(t *testing.T) {
+	collector := &recordingDatasetCollector{calls: make(chan time.Time, 3)}
+	scheduler := &DatasetScheduler{
+		collector: collector,
+		interval:  10 * time.Millisecond,
+		logger:    log.New(io.Discard, "", 0),
+	}
+	ctx, cancel := context.WithCancel(context.Background())
+	done := make(chan struct{})
+	go func() {
+		defer close(done)
+		scheduler.Run(ctx)
+	}()
+
+	first := receiveCollectionCall(t, collector.calls)
+	second := receiveCollectionCall(t, collector.calls)
+	require.GreaterOrEqual(t, second.Sub(first), 8*time.Millisecond)
+
+	cancel()
+	require.Eventually(t, func() bool {
+		select {
+		case <-done:
+			return true
+		default:
+			return false
+		}
+	}, time.Second, 5*time.Millisecond)
+}
+
+func TestDatasetSchedulerStopsWhenContextIsAlreadyCanceled(t *testing.T) {
+	collector := &recordingDatasetCollector{calls: make(chan time.Time, 1)}
+	scheduler := &DatasetScheduler{
+		collector: collector,
+		interval:  10 * time.Millisecond,
+		logger:    log.New(io.Discard, "", 0),
+	}
+	ctx, cancel := context.WithCancel(context.Background())
+	cancel()
+
+	scheduler.Run(ctx)
+
+	require.Zero(t, collector.callCount())
+}
+
+func TestDatasetSchedulerSkipsTicksWhileCollectionIsRunning(t *testing.T) {
+	collector := &blockingDatasetCollector{
+		started: make(chan struct{}, 2),
+		release: make(chan struct{}),
+	}
+	scheduler := &DatasetScheduler{
+		collector: collector,
+		interval:  5 * time.Millisecond,
+		logger:    log.New(io.Discard, "", 0),
+	}
+	ctx, cancel := context.WithCancel(context.Background())
+	done := make(chan struct{})
+	go func() {
+		defer close(done)
+		scheduler.Run(ctx)
+	}()
+
+	select {
+	case <-collector.started:
+	case <-time.After(time.Second):
+		t.Fatal("timed out waiting for first collection")
+	}
+	time.Sleep(20 * time.Millisecond)
+	require.Equal(t, 1, collector.callCount())
+
+	close(collector.release)
+	require.Eventually(t, func() bool {
+		return collector.callCount() >= 2
+	}, time.Second, 5*time.Millisecond)
+	cancel()
+	<-done
+}
+
+type recordingDatasetCollector struct {
+	mu    sync.Mutex
+	count int
+	calls chan time.Time
+}
+
+func (c *recordingDatasetCollector) SyncAllSources(context.Context) ([]models.SaDatasetCron, error) {
+	now := time.Now()
+	c.mu.Lock()
+	c.count++
+	c.mu.Unlock()
+	c.calls <- now
+	return []models.SaDatasetCron{{Status: "completed"}}, nil
+}
+
+func (c *recordingDatasetCollector) callCount() int {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	return c.count
+}
+
+func receiveCollectionCall(t *testing.T, calls <-chan time.Time) time.Time {
+	t.Helper()
+	select {
+	case calledAt := <-calls:
+		return calledAt
+	case <-time.After(time.Second):
+		t.Fatal("timed out waiting for dataset collection")
+		return time.Time{}
+	}
+}
+
+type blockingDatasetCollector struct {
+	mu      sync.Mutex
+	count   int
+	started chan struct{}
+	release chan struct{}
+}
+
+func (c *blockingDatasetCollector) SyncAllSources(ctx context.Context) ([]models.SaDatasetCron, error) {
+	c.mu.Lock()
+	c.count++
+	c.mu.Unlock()
+	select {
+	case c.started <- struct{}{}:
+	default:
+	}
+	select {
+	case <-c.release:
+	case <-ctx.Done():
+	}
+	return nil, nil
+}
+
+func (c *blockingDatasetCollector) callCount() int {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	return c.count
+}