270 lines
8.7 KiB
Go
270 lines
8.7 KiB
Go
package reconcile
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"path/filepath"
|
|
"testing"
|
|
"time"
|
|
|
|
"yovision/sense/internal/device"
|
|
"yovision/sense/internal/onvif"
|
|
"yovision/sense/internal/store"
|
|
)
|
|
|
|
type recordingMedia struct {
|
|
calls int
|
|
changed int
|
|
deleted int
|
|
paths map[string]string
|
|
}
|
|
|
|
func (m *recordingMedia) EnsurePath(_ context.Context, name, source string) (bool, error) {
|
|
m.calls++
|
|
if m.paths == nil {
|
|
m.paths = make(map[string]string)
|
|
}
|
|
if m.paths[name] == source {
|
|
return false, nil
|
|
}
|
|
m.paths[name] = source
|
|
m.changed++
|
|
return true, nil
|
|
}
|
|
|
|
func (m *recordingMedia) DeletePath(_ context.Context, name string) error {
|
|
m.calls++
|
|
if m.paths != nil {
|
|
delete(m.paths, name)
|
|
}
|
|
m.deleted++
|
|
return nil
|
|
}
|
|
|
|
func TestReconcileConvergesOnceAndPersistsGeneration(t *testing.T) {
|
|
t.Parallel()
|
|
repository := openRepository(t, filepath.Join(t.TempDir(), "sense.db"))
|
|
createReconcileDevice(t, repository)
|
|
discovery := onvif.NewFake(map[string]onvif.FakeScenario{
|
|
"onvif://camera-1": {Result: onvif.ProbeResult{
|
|
Profiles: []onvif.Profile{{Token: "main", Name: "Main", VideoEncoder: true}},
|
|
StreamURI: "rtsp://media.invalid/camera-1",
|
|
}},
|
|
})
|
|
media := &recordingMedia{}
|
|
reconciler := New(repository, discovery, media)
|
|
reconciler.now = func() time.Time { return time.Date(2026, 8, 4, 0, 0, 0, 0, time.UTC) }
|
|
if err := reconciler.RunOnce(context.Background()); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := reconciler.RunOnce(context.Background()); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if media.calls != 1 || media.changed != 1 {
|
|
t.Fatalf("converged generation should not repeat: calls=%d changed=%d", media.calls, media.changed)
|
|
}
|
|
}
|
|
|
|
func TestBackoffSurvivesStoreRestart(t *testing.T) {
|
|
t.Parallel()
|
|
databasePath := filepath.Join(t.TempDir(), "sense.db")
|
|
repository := openRepository(t, databasePath)
|
|
createReconcileDevice(t, repository)
|
|
failingDiscovery := onvif.NewFake(map[string]onvif.FakeScenario{
|
|
"onvif://camera-1": {ProbeError: onvif.ErrorAuthentication},
|
|
})
|
|
media := &recordingMedia{}
|
|
initialTime := time.Date(2026, 8, 4, 0, 0, 0, 0, time.UTC)
|
|
first := New(repository, failingDiscovery, media)
|
|
first.now = func() time.Time { return initialTime }
|
|
err := first.RunOnce(context.Background())
|
|
if err == nil || onvif.CodeOf(err) != onvif.ErrorAuthentication {
|
|
t.Fatalf("expected authentication failure, got %v", err)
|
|
}
|
|
if err := repository.Close(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
reopened, err := store.OpenSQLite(context.Background(), "file:"+filepath.ToSlash(databasePath))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Cleanup(func() { _ = reopened.Close() })
|
|
successDiscovery := onvif.NewFake(map[string]onvif.FakeScenario{
|
|
"onvif://camera-1": {Result: onvif.ProbeResult{
|
|
Profiles: []onvif.Profile{{Token: "main", VideoEncoder: true}},
|
|
StreamURI: "rtsp://media.invalid/camera-1",
|
|
}},
|
|
})
|
|
afterRestart := New(reopened, successDiscovery, media)
|
|
afterRestart.now = func() time.Time { return initialTime.Add(500 * time.Millisecond) }
|
|
if err := afterRestart.RunOnce(context.Background()); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if media.calls != 0 {
|
|
t.Fatal("backoff window must survive restart")
|
|
}
|
|
afterRestart.now = func() time.Time { return initialTime.Add(time.Second) }
|
|
if err := afterRestart.RunOnce(context.Background()); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if media.calls != 1 {
|
|
t.Fatal("device must retry when persisted backoff expires")
|
|
}
|
|
}
|
|
|
|
func TestCancellationDoesNotPersistFailure(t *testing.T) {
|
|
t.Parallel()
|
|
repository := openRepository(t, filepath.Join(t.TempDir(), "sense.db"))
|
|
createReconcileDevice(t, repository)
|
|
discovery := onvif.NewFake(map[string]onvif.FakeScenario{
|
|
"onvif://camera-1": {
|
|
DelayMillis: 100,
|
|
Result: onvif.ProbeResult{
|
|
Profiles: []onvif.Profile{{Token: "main", VideoEncoder: true}},
|
|
StreamURI: "rtsp://media.invalid/camera-1",
|
|
},
|
|
},
|
|
})
|
|
reconciler := New(repository, discovery, &recordingMedia{})
|
|
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Millisecond)
|
|
defer cancel()
|
|
err := reconciler.RunOnce(ctx)
|
|
if !errors.Is(err, context.DeadlineExceeded) {
|
|
t.Fatalf("expected cancellation, got %v", err)
|
|
}
|
|
candidates, err := repository.ListDueReconcile(context.Background(), time.Now().Add(time.Hour), 10)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(candidates) != 1 || candidates[0].FailureCount != 0 {
|
|
t.Fatalf("cancellation must not consume retry budget: %+v", candidates)
|
|
}
|
|
}
|
|
|
|
func TestDisabledDeviceDeletesOnlyItsExactPath(t *testing.T) {
|
|
repository := openRepository(t, filepath.Join(t.TempDir(), "sense.db"))
|
|
createReconcileDevice(t, repository)
|
|
media := &recordingMedia{paths: map[string]string{"camera-1": "source", "other": "keep"}}
|
|
if err := repository.SetDesiredState(context.Background(), "camera-1", device.DesiredDisabled); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
reconciler := New(repository, onvif.NewFake(nil), media)
|
|
if err := reconciler.RunOnce(context.Background()); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if media.deleted != 1 || media.paths["other"] != "keep" {
|
|
t.Fatalf("disabled convergence touched the wrong paths: %+v", media.paths)
|
|
}
|
|
value, err := repository.GetDevice(context.Background(), "camera-1")
|
|
if err != nil || value.ActualState != device.ActualOffline {
|
|
t.Fatalf("disabled device did not converge offline: %+v %v", value, err)
|
|
}
|
|
}
|
|
|
|
type lostLeaseRepository struct {
|
|
completed bool
|
|
failed bool
|
|
}
|
|
|
|
func (r *lostLeaseRepository) ClaimDueReconcile(
|
|
context.Context,
|
|
store.ReconcileClaim,
|
|
) ([]store.ReconcileCandidate, error) {
|
|
return []store.ReconcileCandidate{{Device: device.Device{
|
|
ID: "camera-lost", DesiredState: device.DesiredEnabled,
|
|
EndpointRef: "onvif://camera-lost", PathName: "camera-lost", Generation: 1,
|
|
}}}, nil
|
|
}
|
|
|
|
func (r *lostLeaseRepository) RenewReconcileLease(
|
|
context.Context, string, string, string, time.Time, time.Duration,
|
|
) (bool, error) {
|
|
return false, nil
|
|
}
|
|
|
|
func (r *lostLeaseRepository) CompleteReconcile(
|
|
context.Context, string, int64, string, string, time.Time,
|
|
) error {
|
|
r.completed = true
|
|
return nil
|
|
}
|
|
|
|
func (r *lostLeaseRepository) FailReconcile(
|
|
context.Context, string, int, time.Time, string, string, string, time.Time,
|
|
) error {
|
|
r.failed = true
|
|
return nil
|
|
}
|
|
|
|
func (r *lostLeaseRepository) ConvergenceSnapshot(context.Context) (store.ConvergenceSnapshot, error) {
|
|
return store.ConvergenceSnapshot{}, nil
|
|
}
|
|
|
|
func TestLostLeaseSkipsAllExternalAndStoreMutations(t *testing.T) {
|
|
t.Parallel()
|
|
repository := &lostLeaseRepository{}
|
|
media := &recordingMedia{}
|
|
reconciler := New(repository, onvif.NewFake(nil), media)
|
|
if err := reconciler.RunOnce(context.Background()); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if media.calls != 0 || repository.completed || repository.failed {
|
|
t.Fatalf("lost lease performed a side effect: media=%d completed=%v failed=%v",
|
|
media.calls, repository.completed, repository.failed)
|
|
}
|
|
}
|
|
|
|
func TestPerItemTimeoutPersistsRetryWhenParentIsAlive(t *testing.T) {
|
|
t.Parallel()
|
|
repository := openRepository(t, filepath.Join(t.TempDir(), "sense.db"))
|
|
createReconcileDevice(t, repository)
|
|
discovery := onvif.NewFake(map[string]onvif.FakeScenario{
|
|
"onvif://camera-1": {
|
|
DelayMillis: 100,
|
|
Result: onvif.ProbeResult{StreamURI: "rtsp://media.invalid/camera-1"},
|
|
},
|
|
})
|
|
reconciler := NewWithOptions(repository, discovery, &recordingMedia{}, Options{
|
|
InstanceID: "ins_test", LeaseDuration: time.Second, OperationTimeout: 5 * time.Millisecond,
|
|
})
|
|
now := time.Date(2026, 8, 7, 0, 0, 0, 0, time.UTC)
|
|
reconciler.now = func() time.Time { return now }
|
|
if err := reconciler.RunOnce(context.Background()); err == nil {
|
|
t.Fatal("expected bounded operation timeout")
|
|
}
|
|
candidates, err := repository.ListDueReconcile(context.Background(), now.Add(time.Hour), 1)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(candidates) != 1 || candidates[0].FailureCount != 1 {
|
|
t.Fatalf("operation timeout did not persist retry state: %+v", candidates)
|
|
}
|
|
}
|
|
|
|
func openRepository(t *testing.T, path string) *store.SQLite {
|
|
t.Helper()
|
|
repository, err := store.OpenSQLite(context.Background(), "file:"+filepath.ToSlash(path))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Cleanup(func() { _ = repository.Close() })
|
|
return repository
|
|
}
|
|
|
|
func createReconcileDevice(t *testing.T, repository *store.SQLite) {
|
|
t.Helper()
|
|
ctx := context.Background()
|
|
if err := repository.EnsureSite(ctx, device.Site{TenantID: "tenant", ID: "site", Name: "Site"}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := repository.CreateDevice(ctx, device.Device{
|
|
ID: "camera-1", TenantID: "tenant", SiteID: "site", SerialNumber: "camera-1", Name: "Camera 1",
|
|
Modality: device.ModalityVideo, Capabilities: []device.Capability{device.CapabilityVideoCapture},
|
|
DesiredState: device.DesiredEnabled, ActualState: device.ActualPending,
|
|
EndpointRef: "onvif://camera-1", CredentialRef: "secret://camera-1", PathName: "camera-1",
|
|
}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|