sdr-wideband-suite/internal/runtime/runtime_test.go

package runtime

import (
	"testing"

	"sdr-wideband-suite/internal/config"
)

func TestApplyConfigUpdate(t *testing.T) {
	cfg := config.Default()
	mgr := New(cfg)

	center := 7.2e6
	sampleRate := 1_024_000
	fftSize := 4096
	threshold := -35.0
	bw := 1536
	cfarMode := "OS"
	cfarWrap := true
	cfarGuard := 2
	cfarTrain := 12
	cfarRank := 18
	cfarScale := 5.5

	mode := "wideband-balanced"
	profile := "wideband-balanced"
	intent := "wideband-surveillance"
	monitorSpan := 500000.0
	signalPriorities := []string{"digital", "weak"}
	autoRecord := []string{"WFM"}
	autoDecode := []string{"FT8"}
	survFPS := 12
	displayBins := 1024
	displayFPS := 8
	maxRefJobs := 24
	minSpan := 4000.0
	maxSpan := 200000.0
	autoSpan := false
	detailFFT := 1024
	maxDecode := 12
	decisionHold := 1500
	updated, err := mgr.ApplyConfig(ConfigUpdate{
		CenterHz:   &center,
		SampleRate: &sampleRate,
		FFTSize:    &fftSize,
		TunerBwKHz: &bw,
		Pipeline: &PipelineUpdate{
			Mode:              &mode,
			Profile:           &profile,
			Intent:            &intent,
			MonitorSpanHz:     &monitorSpan,
			SignalPriorities:  &signalPriorities,
			AutoRecordClasses: &autoRecord,
			AutoDecodeClasses: &autoDecode,
		},
		Surveillance: &SurveillanceUpdate{FrameRate: &survFPS, DisplayBins: &displayBins, DisplayFPS: &displayFPS},
		Refinement:   &RefinementUpdate{MinSpanHz: &minSpan, MaxSpanHz: &maxSpan, AutoSpan: &autoSpan, DetailFFTSize: &detailFFT},
		Resources:    &ResourcesUpdate{MaxRefinementJobs: &maxRefJobs, MaxDecodeJobs: &maxDecode, DecisionHoldMs: &decisionHold},
		Detector: &DetectorUpdate{
			ThresholdDb:    &threshold,
			CFARMode:       &cfarMode,
			CFARWrapAround: &cfarWrap,
			CFARGuardCells: &cfarGuard,
			CFARTrainCells: &cfarTrain,
			CFARRank:       &cfarRank,
			CFARScaleDb:    &cfarScale,
		},
	})
	if err != nil {
		t.Fatalf("apply: %v", err)
	}
	if updated.CenterHz != center {
		t.Fatalf("center hz: %v", updated.CenterHz)
	}
	if updated.SampleRate != sampleRate {
		t.Fatalf("sample rate: %v", updated.SampleRate)
	}
	if updated.FFTSize != fftSize {
		t.Fatalf("fft size: %v", updated.FFTSize)
	}
	if updated.Surveillance.AnalysisFFTSize != fftSize {
		t.Fatalf("analysis fft size: %v", updated.Surveillance.AnalysisFFTSize)
	}
	if updated.Detector.ThresholdDb != threshold {
		t.Fatalf("threshold: %v", updated.Detector.ThresholdDb)
	}
	if updated.Detector.CFARMode != cfarMode {
		t.Fatalf("cfar mode: %v", updated.Detector.CFARMode)
	}
	if updated.Detector.CFARWrapAround != cfarWrap {
		t.Fatalf("cfar wrap: %v", updated.Detector.CFARWrapAround)
	}
	if updated.Detector.CFARGuardCells != cfarGuard {
		t.Fatalf("cfar guard: %v", updated.Detector.CFARGuardCells)
	}
	if updated.Detector.CFARTrainCells != cfarTrain {
		t.Fatalf("cfar train: %v", updated.Detector.CFARTrainCells)
	}
	if updated.Detector.CFARRank != cfarRank {
		t.Fatalf("cfar rank: %v", updated.Detector.CFARRank)
	}
	if updated.Detector.CFARScaleDb != cfarScale {
		t.Fatalf("cfar scale: %v", updated.Detector.CFARScaleDb)
	}
	if updated.TunerBwKHz != bw {
		t.Fatalf("tuner bw: %v", updated.TunerBwKHz)
	}
	if updated.Pipeline.Mode != mode {
		t.Fatalf("pipeline mode: %v", updated.Pipeline.Mode)
	}
	if updated.Pipeline.Profile != profile {
		t.Fatalf("pipeline profile: %v", updated.Pipeline.Profile)
	}
	if updated.Pipeline.Goals.Intent != intent {
		t.Fatalf("pipeline intent: %v", updated.Pipeline.Goals.Intent)
	}
	if updated.Pipeline.Goals.MonitorSpanHz != monitorSpan {
		t.Fatalf("monitor span: %v", updated.Pipeline.Goals.MonitorSpanHz)
	}
	if len(updated.Pipeline.Goals.SignalPriorities) != len(signalPriorities) {
		t.Fatalf("signal priorities not applied")
	}
	if len(updated.Pipeline.Goals.AutoRecordClasses) != len(autoRecord) {
		t.Fatalf("auto record classes not applied")
	}
	if len(updated.Pipeline.Goals.AutoDecodeClasses) != len(autoDecode) {
		t.Fatalf("auto decode classes not applied")
	}
	if updated.Surveillance.FrameRate != survFPS || updated.FrameRate != survFPS {
		t.Fatalf("surveillance frame rate: %v / %v", updated.Surveillance.FrameRate, updated.FrameRate)
	}
	if updated.Resources.MaxRefinementJobs != maxRefJobs {
		t.Fatalf("max refinement jobs: %v", updated.Resources.MaxRefinementJobs)
	}
	if updated.Resources.MaxDecodeJobs != maxDecode {
		t.Fatalf("max decode jobs: %v", updated.Resources.MaxDecodeJobs)
	}
	if updated.Resources.DecisionHoldMs != decisionHold {
		t.Fatalf("decision hold: %v", updated.Resources.DecisionHoldMs)
	}
	if updated.Surveillance.DisplayBins != displayBins || updated.Surveillance.DisplayFPS != displayFPS {
		t.Fatalf("display settings not applied: bins=%d fps=%d", updated.Surveillance.DisplayBins, updated.Surveillance.DisplayFPS)
	}
	if updated.Refinement.MinSpanHz != minSpan || updated.Refinement.MaxSpanHz != maxSpan {
		t.Fatalf("refinement span not applied: %v / %v", updated.Refinement.MinSpanHz, updated.Refinement.MaxSpanHz)
	}
	if updated.Refinement.DetailFFTSize != detailFFT {
		t.Fatalf("refinement detail fft not applied: %v", updated.Refinement.DetailFFTSize)
	}
	if updated.Refinement.AutoSpan == nil || *updated.Refinement.AutoSpan != autoSpan {
		t.Fatalf("refinement auto span not applied")
	}
}

func TestApplyConfigRejectsInvalid(t *testing.T) {
	cfg := config.Default()

	{
		mgr := New(cfg)
		bad := 0
		if _, err := mgr.ApplyConfig(ConfigUpdate{SampleRate: &bad}); err == nil {
			t.Fatalf("expected error")
		}
		snap := mgr.Snapshot()
		if snap.SampleRate != cfg.SampleRate {
			t.Fatalf("sample rate changed on error")
		}
	}

	{
		mgr := New(cfg)
		badAlpha := -0.5
		if _, err := mgr.ApplyConfig(ConfigUpdate{Detector: &DetectorUpdate{EmaAlpha: &badAlpha}}); err == nil {
			t.Fatalf("expected ema_alpha error")
		}
		if mgr.Snapshot().Detector.EmaAlpha != cfg.Detector.EmaAlpha {
			t.Fatalf("ema_alpha changed on error")
		}
	}

	{
		mgr := New(cfg)
		badAlpha := 1.5
		if _, err := mgr.ApplyConfig(ConfigUpdate{Detector: &DetectorUpdate{EmaAlpha: &badAlpha}}); err == nil {
			t.Fatalf("expected ema_alpha upper bound error")
		}
		if mgr.Snapshot().Detector.EmaAlpha != cfg.Detector.EmaAlpha {
			t.Fatalf("ema_alpha changed on error")
		}
	}

	{
		mgr := New(cfg)
		badHyst := -1.0
		if _, err := mgr.ApplyConfig(ConfigUpdate{Detector: &DetectorUpdate{HysteresisDb: &badHyst}}); err == nil {
			t.Fatalf("expected hysteresis_db error")
		}
		if mgr.Snapshot().Detector.HysteresisDb != cfg.Detector.HysteresisDb {
			t.Fatalf("hysteresis_db changed on error")
		}
	}

	{
		mgr := New(cfg)
		badStable := 0
		if _, err := mgr.ApplyConfig(ConfigUpdate{Detector: &DetectorUpdate{MinStableFrames: &badStable}}); err == nil {
			t.Fatalf("expected min_stable_frames error")
		}
		if mgr.Snapshot().Detector.MinStableFrames != cfg.Detector.MinStableFrames {
			t.Fatalf("min_stable_frames changed on error")
		}
	}

	{
		mgr := New(cfg)
		badGap := -10
		if _, err := mgr.ApplyConfig(ConfigUpdate{Detector: &DetectorUpdate{GapToleranceMs: &badGap}}); err == nil {
			t.Fatalf("expected gap_tolerance_ms error")
		}
		if mgr.Snapshot().Detector.GapToleranceMs != cfg.Detector.GapToleranceMs {
			t.Fatalf("gap_tolerance_ms changed on error")
		}
	}

	{
		mgr := New(cfg)
		badDetail := 123
		if _, err := mgr.ApplyConfig(ConfigUpdate{Refinement: &RefinementUpdate{DetailFFTSize: &badDetail}}); err == nil {
			t.Fatalf("expected refinement.detail_fft_size error")
		}
		if mgr.Snapshot().Refinement.DetailFFTSize != cfg.Refinement.DetailFFTSize {
			t.Fatalf("detail fft changed on error")
		}
	}
}

func TestApplySettings(t *testing.T) {
	cfg := config.Default()
	mgr := New(cfg)
	agc := true
	dc := true
	iq := true
	updated, err := mgr.ApplySettings(SettingsUpdate{
		AGC:       &agc,
		DCBlock:   &dc,
		IQBalance: &iq,
	})
	if err != nil {
		t.Fatalf("apply settings: %v", err)
	}
	if !updated.AGC || !updated.DCBlock || !updated.IQBalance {
		t.Fatalf("settings not applied: %+v", updated)
	}
}