151 lines
3.3 KiB
Go
151 lines
3.3 KiB
Go
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
|
|
}
|