shishengliang/lingniu-vehicle-ingest
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
2ef027c7c240b95171b5be468d4c7e1fd1a5573f
lingniu-vehicle-ingest/go/vehicle-gateway/internal/stats/daily_metric_test.go
lingniu 2ef027c7c2 fix(stats): recover stale odometer mileage
2026-07-20 01:12:09 +08:00

2584 lines
93 KiB
Go
Raw Blame History

package stats
import (
"context"
"database/sql"
"database/sql/driver"
"errors"
"fmt"
"math"
"strings"
"sync"
"testing"
"time"
"github.com/DATA-DOG/go-sqlmock"
"lingniu-vehicle-ingest/go/vehicle-gateway/internal/envelope"
)
func managedTestSource(env envelope.FrameEnvelope) envelope.FrameEnvelope {
if strings.TrimSpace(env.SourceKind) == "" {
env.SourceKind = "PLATFORM"
}
return env
}
func TestSamplesFromEnvelopeDerivesDailyMileageSample(t *testing.T) {
loc := time.FixedZone("Asia/Shanghai", 8*3600)
env := envelope.FrameEnvelope{
Protocol: envelope.ProtocolJT808,
VIN: "LNBVIN00000000001",
EventTimeMS: time.Date(2026, 7, 1, 8, 30, 0, 0, loc).UnixMilli(),
Fields: map[string]any{
"jt808.location.total_mileage_km": 10241.2,
},
}
samples, err := SamplesFromEnvelope(env, loc)
if err != nil {
t.Fatalf("SamplesFromEnvelope() error = %v", err)
}
if len(samples) != 1 {
t.Fatalf("sample count = %d", len(samples))
}
if samples[0].VIN != "LNBVIN00000000001" {
t.Fatalf("vin = %q", samples[0].VIN)
}
if samples[0].TotalMileageKM != 10241.2 {
t.Fatalf("total mileage = %v", samples[0].TotalMileageKM)
}
if samples[0].StatDate != "2026-07-01" {
t.Fatalf("stat date = %q", samples[0].StatDate)
}
}
func TestSamplesFromEnvelopeMapsProtocolMileageFields(t *testing.T) {
loc := time.FixedZone("Asia/Shanghai", 8*3600)
tests := []struct {
name string
protocol envelope.Protocol
fields map[string]any
wantKM float64
}{
{
name: "gb32960",
protocol: envelope.ProtocolGB32960,
fields: map[string]any{"gb32960.vehicle.total_mileage_km": "38587"},
wantKM: 38587,
},
{
name: "jt808",
protocol: envelope.ProtocolJT808,
fields: map[string]any{"jt808.location.total_mileage_km": "12432.4"},
wantKM: 12432.4,
},
{
name: "yutong mqtt meters",
protocol: envelope.ProtocolYutongMQTT,
fields: map[string]any{"yutong_mqtt.data.total_mileage": "120756000"},
wantKM: 120756,
},
{
name: "yutong mqtt km",
protocol: envelope.ProtocolYutongMQTT,
fields: map[string]any{"yutong_mqtt.data.total_mileage_km": "120756"},
wantKM: 120756,
},
{
name: "yutong mqtt root meters",
protocol: envelope.ProtocolYutongMQTT,
fields: map[string]any{"yutong_mqtt.root.data.total_mileage": float64(22858000)},
wantKM: 22858,
},
{
name: "yutong mqtt root km",
protocol: envelope.ProtocolYutongMQTT,
fields: map[string]any{"yutong_mqtt.root.data.total_mileage_km": float64(22858)},
wantKM: 22858,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
samples, err := SamplesFromEnvelope(envelope.FrameEnvelope{
Protocol: tt.protocol,
VIN: "LNBVIN00000000001",
EventTimeMS: time.Date(2026, 7, 1, 8, 30, 0, 0, loc).UnixMilli(),
Fields: tt.fields,
}, loc)
if err != nil {
t.Fatalf("SamplesFromEnvelope() error = %v", err)
}
if len(samples) != 1 {
t.Fatalf("sample count = %d", len(samples))
}
if samples[0].TotalMileageKM != tt.wantKM {
t.Fatalf("total mileage = %v, want %v", samples[0].TotalMileageKM, tt.wantKM)
}
})
}
}
func TestSamplesFromEnvelopeFallsBackToReceivedTimeWhenEventTimeIsFuture(t *testing.T) {
loc := time.FixedZone("Asia/Shanghai", 8*3600)
received := time.Date(2026, 7, 8, 23, 59, 0, 0, loc)
futureEvent := received.Add(48 * time.Hour)
samples, err := SamplesFromEnvelope(envelope.FrameEnvelope{
Protocol: envelope.ProtocolJT808,
VIN: "LA9GG64L7PBAF4001",
EventTimeMS: futureEvent.UnixMilli(),
ReceivedAtMS: received.UnixMilli(),
Fields: map[string]any{
"jt808.location.total_mileage_km": 4136.8,
},
}, loc)
if err != nil {
t.Fatalf("SamplesFromEnvelope() error = %v", err)
}
if len(samples) != 1 {
t.Fatalf("sample count = %d", len(samples))
}
if samples[0].StatDate != "2026-07-08" {
t.Fatalf("stat date = %q, want received date", samples[0].StatDate)
}
if !samples[0].EventTime.Equal(received) {
t.Fatalf("event time = %s, want received time %s", samples[0].EventTime, received)
}
_, result, err := samplesFromEnvelopeWithResult(envelope.FrameEnvelope{
Protocol: envelope.ProtocolJT808,
VIN: "LA9GG64L7PBAF4001",
EventTimeMS: futureEvent.UnixMilli(),
ReceivedAtMS: received.UnixMilli(),
Fields: map[string]any{
"jt808.location.total_mileage_km": 4136.8,
},
}, loc)
if err != nil {
t.Fatalf("samplesFromEnvelopeWithResult() error = %v", err)
}
if result.SamplesAdjustedFutureEventTime != 1 {
t.Fatalf("future event adjustment count = %d, want 1", result.SamplesAdjustedFutureEventTime)
}
}
func TestSamplesFromEnvelopeKeepsSmallFutureClockSkew(t *testing.T) {
loc := time.FixedZone("Asia/Shanghai", 8*3600)
received := time.Date(2026, 7, 8, 23, 59, 0, 0, loc)
eventTime := received.Add(2 * time.Minute)
samples, err := SamplesFromEnvelope(envelope.FrameEnvelope{
Protocol: envelope.ProtocolJT808,
VIN: "LA9GG64L7PBAF4001",
EventTimeMS: eventTime.UnixMilli(),
ReceivedAtMS: received.UnixMilli(),
Fields: map[string]any{
"jt808.location.total_mileage_km": 4136.8,
},
}, loc)
if err != nil {
t.Fatalf("SamplesFromEnvelope() error = %v", err)
}
if len(samples) != 1 {
t.Fatalf("sample count = %d", len(samples))
}
if samples[0].StatDate != "2026-07-09" {
t.Fatalf("stat date = %q, want event date within skew", samples[0].StatDate)
}
if !samples[0].EventTime.Equal(eventTime) {
t.Fatalf("event time = %s, want event time %s", samples[0].EventTime, eventTime)
}
}
func TestWriterSourceSeenAtUsesReceivedTimeOverDeviceEventTime(t *testing.T) {
loc := time.FixedZone("Asia/Shanghai", 8*3600)
writer := NewWriter(&recordingExec{}, loc)
received := time.Date(2026, 7, 8, 13, 20, 0, 0, loc)
staleDeviceEvent := received.Add(-72 * time.Hour)
got := writer.sourceSeenAt(envelope.FrameEnvelope{
EventTimeMS: staleDeviceEvent.UnixMilli(),
ReceivedAtMS: received.UnixMilli(),
})
if !got.Equal(received) {
t.Fatalf("sourceSeenAt = %s, want received time %s", got, received)
}
}
func TestSamplesFromEnvelopeSkipsMissingVIN(t *testing.T) {
loc := time.FixedZone("Asia/Shanghai", 8*3600)
samples, err := SamplesFromEnvelope(envelope.FrameEnvelope{
Protocol: envelope.ProtocolJT808,
Phone: "13307811254",
EventTimeMS: time.Date(2026, 7, 2, 0, 3, 0, 0, loc).UnixMilli(),
Fields: map[string]any{
"jt808.location.total_mileage_km": 10985.7,
},
}, loc)
if err != nil {
t.Fatalf("SamplesFromEnvelope() error = %v", err)
}
if len(samples) != 0 {
t.Fatalf("expected no samples without VIN, got %#v", samples)
}
}
func TestSamplesFromEnvelopeSkipsMissingVINOrMileage(t *testing.T) {
samples, err := SamplesFromEnvelope(envelope.FrameEnvelope{
Protocol: envelope.ProtocolJT808,
Fields: map[string]any{"jt808.location.total_mileage_km": 1.2},
}, nil)
if err != nil {
t.Fatalf("SamplesFromEnvelope() error = %v", err)
}
if len(samples) != 0 {
t.Fatalf("expected no samples without VIN, got %#v", samples)
}
samples, err = SamplesFromEnvelope(envelope.FrameEnvelope{
Protocol: envelope.ProtocolGB32960,
VIN: "LNBVIN00000000002",
Fields: map[string]any{},
}, nil)
if err != nil {
t.Fatalf("SamplesFromEnvelope() error = %v", err)
}
if len(samples) != 0 {
t.Fatalf("expected no samples without mileage, got %#v", samples)
}
}
func TestSamplesFromEnvelopeSkipsNonPositiveMileage(t *testing.T) {
for _, value := range []any{0, 0.0, -1.0, "0"} {
samples, err := SamplesFromEnvelope(envelope.FrameEnvelope{
Protocol: envelope.ProtocolJT808,
VIN: "LNBVIN00000000001",
EventTimeMS: time.Date(2026, 7, 1, 9, 0, 0, 0, time.FixedZone("Asia/Shanghai", 8*3600)).UnixMilli(),
Fields: map[string]any{
"jt808.location.total_mileage_km": value,
},
}, nil)
if err != nil {
t.Fatalf("SamplesFromEnvelope(%#v) error = %v", value, err)
}
if len(samples) != 0 {
t.Fatalf("expected no samples for non-positive mileage %#v, got %#v", value, samples)
}
}
}
func TestWriterAppendWritesSourceCandidateAndProjection(t *testing.T) {
exec := &recordingExec{}
writer := NewWriter(exec, time.FixedZone("Asia/Shanghai", 8*3600))
event := envelope.FrameEnvelope{
Protocol: envelope.ProtocolJT808,
VIN: "LA9GG64L7PBAF4001",
Phone: "13307765812",
SourceEndpoint: "115.231.168.135:20215",
SourceCode: "g7s",
PlatformName: "G7s",
SourceKind: "PLATFORM",
EventTimeMS: time.Date(2026, 7, 8, 13, 20, 0, 0, time.FixedZone("Asia/Shanghai", 8*3600)).UnixMilli(),
Fields: map[string]any{
"jt808.location.total_mileage_km": 4123.9,
},
}
if err := writer.Append(context.Background(), event); err != nil {
t.Fatalf("Append() error = %v", err)
}
if len(exec.calls) != 7 {
t.Fatalf("exec calls = %d, want source + candidate + normalize insert/delete + project + reconcile + cleanup", len(exec.calls))
}
if !strings.Contains(exec.calls[0].query, "INSERT INTO vehicle_data_source") {
t.Fatalf("first call should upsert source: %s", exec.calls[0].query)
}
if exec.calls[0].args[3] != "G7s" || exec.calls[0].args[4] != "g7s" || exec.calls[0].args[5] != "PLATFORM" {
t.Fatalf("source metadata args = %#v", exec.calls[0].args)
}
if !strings.Contains(exec.calls[1].query, "INSERT INTO vehicle_daily_mileage_source") {
t.Fatalf("second call should upsert candidate: %s", exec.calls[1].query)
}
if exec.calls[1].args[8] != "G7s" {
t.Fatalf("source mileage platform arg = %#v", exec.calls[1].args)
}
if !strings.Contains(exec.calls[2].query, "INSERT INTO vehicle_daily_mileage_source") ||
!strings.Contains(exec.calls[2].query, "SELECT") ||
!strings.Contains(exec.calls[2].query, "@PLATFORM:") {
t.Fatalf("third call should normalize legacy platform source rows: %s", exec.calls[2].query)
}
if !strings.Contains(exec.calls[3].query, "DELETE s") ||
!strings.Contains(exec.calls[3].query, "@PLATFORM:") {
t.Fatalf("fourth call should delete normalized legacy platform rows: %s", exec.calls[3].query)
}
if !strings.Contains(exec.calls[4].query, "INSERT INTO vehicle_daily_mileage") {
t.Fatalf("fifth call should project final: %s", exec.calls[4].query)
}
}
func TestWriterAppendWithResultReportsWrittenSample(t *testing.T) {
exec := &recordingExec{}
writer := NewWriter(exec, time.FixedZone("Asia/Shanghai", 8*3600))
event := envelope.FrameEnvelope{
Protocol: envelope.ProtocolJT808,
VIN: "LA9GG64L7PBAF4001",
Phone: "13307765812",
SourceEndpoint: "115.231.168.135:20215",
EventTimeMS: time.Date(2026, 7, 8, 13, 20, 0, 0, time.FixedZone("Asia/Shanghai", 8*3600)).UnixMilli(),
Fields: map[string]any{
"jt808.location.total_mileage_km": 4123.9,
},
}
result, err := writer.AppendWithResult(context.Background(), event)
if err != nil {
t.Fatalf("AppendWithResult() error = %v", err)
}
if result.SamplesFound != 1 || result.SamplesWritten != 1 {
t.Fatalf("result = %+v, want one found and written sample", result)
}
if result.ProjectionsAttempted != 1 || result.ProjectionsWritten != 1 || result.ProjectionsSkippedThrottled != 0 {
t.Fatalf("projection result = %+v, want one final projection", result)
}
if result.SourceTouchesSkippedUnmanaged != 1 || result.SourceTouchesAttempted != 0 || result.SourceTouchesWritten != 0 || result.SourceTouchesSkippedMissing != 0 {
t.Fatalf("source touch result = %+v, want unmanaged source skipped", result)
}
if result.SamplesSkippedMissingVIN != 0 ||
result.SamplesSkippedMissingMileage != 0 ||
result.SamplesSkippedNonPositiveMileage != 0 ||
result.SamplesSkippedSameMileage != 0 ||
result.SamplesSkippedMissingSource != 0 {
t.Fatalf("unexpected skipped result counters: %+v", result)
}
}
func TestWriterAppendSkipsMileageWithoutSourceIdentity(t *testing.T) {
exec := &recordingExec{}
writer := NewWriter(exec, time.FixedZone("Asia/Shanghai", 8*3600))
event := envelope.FrameEnvelope{
Protocol: envelope.ProtocolJT808,
VIN: "LA9GG64L7PBAF4001",
Phone: "13307765812",
EventTimeMS: time.Date(2026, 7, 8, 13, 20, 0, 0, time.FixedZone("Asia/Shanghai", 8*3600)).UnixMilli(),
Fields: map[string]any{
"jt808.location.total_mileage_km": 4123.9,
},
}
if err := writer.Append(context.Background(), event); err != nil {
t.Fatalf("Append() error = %v", err)
}
if len(exec.calls) != 0 {
t.Fatalf("exec calls = %d, want 0 without source identity", len(exec.calls))
}
}
func TestWriterAppendWithResultReportsMissingSource(t *testing.T) {
exec := &recordingExec{}
writer := NewWriter(exec, time.FixedZone("Asia/Shanghai", 8*3600))
event := envelope.FrameEnvelope{
Protocol: envelope.ProtocolJT808,
VIN: "LA9GG64L7PBAF4001",
Phone: "13307765812",
EventTimeMS: time.Date(2026, 7, 8, 13, 20, 0, 0, time.FixedZone("Asia/Shanghai", 8*3600)).UnixMilli(),
Fields: map[string]any{
"jt808.location.total_mileage_km": 4123.9,
},
}
result, err := writer.AppendWithResult(context.Background(), event)
if err != nil {
t.Fatalf("AppendWithResult() error = %v", err)
}
if result.SamplesFound != 1 || result.SamplesSkippedMissingSource != 1 || result.SamplesWritten != 0 {
t.Fatalf("result = %+v, want found sample skipped by missing source", result)
}
if result.SourceTouchesSkippedMissing != 1 || result.SourceTouchesAttempted != 0 || result.SourceTouchesWritten != 0 {
t.Fatalf("source touch result = %+v, want missing source endpoint", result)
}
if result.ProjectionsAttempted != 0 || result.ProjectionsWritten != 0 || result.ProjectionsSkippedThrottled != 0 {
t.Fatalf("projection result = %+v, want no projection without source", result)
}
if len(exec.calls) != 0 {
t.Fatalf("exec calls = %d, want 0 without source identity", len(exec.calls))
}
}
func TestWriterAppendTracksSourceWithoutMileageSample(t *testing.T) {
exec := &recordingExec{}
writer := NewWriter(exec, time.FixedZone("Asia/Shanghai", 8*3600))
event := managedTestSource(envelope.FrameEnvelope{
Protocol: envelope.ProtocolJT808,
Phone: "13307795518",
SourceEndpoint: "222.66.200.68:43614",
EventTimeMS: time.Date(2026, 7, 8, 16, 30, 0, 0, time.FixedZone("Asia/Shanghai", 8*3600)).UnixMilli(),
Fields: map[string]any{
"jt808.location.speed_kmh": 38.5,
},
})
if err := writer.Append(context.Background(), event); err != nil {
t.Fatalf("Append() error = %v", err)
}
if len(exec.calls) != 1 {
t.Fatalf("exec calls = %d, want source only", len(exec.calls))
}
if !strings.Contains(exec.calls[0].query, "INSERT INTO vehicle_data_source") {
t.Fatalf("source upsert query missing: %s", exec.calls[0].query)
}
if got := exec.calls[0].args[1]; got != "222.66.200.68" {
t.Fatalf("source ip arg = %#v", got)
}
}
func TestWriterAppendWithResultReportsMissingMileage(t *testing.T) {
exec := &recordingExec{}
writer := NewWriter(exec, time.FixedZone("Asia/Shanghai", 8*3600))
event := managedTestSource(envelope.FrameEnvelope{
Protocol: envelope.ProtocolJT808,
VIN: "LA9GG64L7PBAF4001",
Phone: "13307765812",
SourceEndpoint: "115.231.168.135:20215",
EventTimeMS: time.Date(2026, 7, 8, 13, 20, 0, 0, time.FixedZone("Asia/Shanghai", 8*3600)).UnixMilli(),
Fields: map[string]any{
"jt808.location.speed_kmh": 38.5,
},
})
result, err := writer.AppendWithResult(context.Background(), event)
if err != nil {
t.Fatalf("AppendWithResult() error = %v", err)
}
if result.SamplesFound != 0 || result.SamplesSkippedMissingMileage != 1 || result.SamplesWritten != 0 {
t.Fatalf("result = %+v, want missing mileage", result)
}
if result.SourceTouchesAttempted != 1 || result.SourceTouchesWritten != 1 || result.SourceTouchesSkippedThrottled != 0 {
t.Fatalf("source touch result = %+v, want source touch before missing mileage skip", result)
}
if result.ProjectionsAttempted != 0 || result.ProjectionsWritten != 0 || result.ProjectionsSkippedThrottled != 0 {
t.Fatalf("projection result = %+v, want no projection for missing mileage", result)
}
}
func TestWriterAppendWithResultClassifiesGB32960VendorFrameAsNonMileage(t *testing.T) {
exec := &recordingExec{}
writer := NewWriter(exec, time.FixedZone("Asia/Shanghai", 8*3600))
event := managedTestSource(envelope.FrameEnvelope{
Protocol: envelope.ProtocolGB32960,
VIN: "LB9A32A24R0LS1426",
SourceEndpoint: "115.29.187.205:32960",
EventTimeMS: time.Date(2026, 7, 8, 13, 20, 0, 0, time.FixedZone("Asia/Shanghai", 8*3600)).UnixMilli(),
Fields: map[string]any{
"gb32960.gd_fc_stack.stack_water_outlet_temp_c": 63,
"gb32960.gd_fc_stack.hydrogen_inlet_pressure_kpa": 130,
},
})
result, err := writer.AppendWithResult(context.Background(), event)
if err != nil {
t.Fatalf("AppendWithResult() error = %v", err)
}
if result.SamplesFound != 0 || result.SamplesSkippedNonMileageFrame != 1 || result.SamplesSkippedMissingMileage != 0 || result.SamplesWritten != 0 {
t.Fatalf("result = %+v, want non-mileage frame", result)
}
if result.SourceTouchesAttempted != 1 || result.SourceTouchesWritten != 1 {
t.Fatalf("source touch result = %+v, want source touch before non-mileage skip", result)
}
}
func TestWriterAppendWithResultKeepsGB32960VehicleFrameMissingMileageActionable(t *testing.T) {
exec := &recordingExec{}
writer := NewWriter(exec, time.FixedZone("Asia/Shanghai", 8*3600))
event := envelope.FrameEnvelope{
Protocol: envelope.ProtocolGB32960,
VIN: "LB9A32A24R0LS1426",
SourceEndpoint: "115.29.187.205:32960",
EventTimeMS: time.Date(2026, 7, 8, 13, 20, 0, 0, time.FixedZone("Asia/Shanghai", 8*3600)).UnixMilli(),
Fields: map[string]any{
"gb32960.vehicle.speed_kmh": 38.5,
"gb32960.vehicle.soc_percent": 81.2,
},
}
result, err := writer.AppendWithResult(context.Background(), event)
if err != nil {
t.Fatalf("AppendWithResult() error = %v", err)
}
if result.SamplesFound != 0 || result.SamplesSkippedMissingMileage != 1 || result.SamplesSkippedNonMileageFrame != 0 || result.SamplesWritten != 0 {
t.Fatalf("result = %+v, want actionable missing mileage", result)
}
}
func TestWriterAppendWithResultClassifiesYutongSparseFrameAsMissingMileage(t *testing.T) {
exec := &recordingExec{}
writer := NewWriter(exec, time.FixedZone("Asia/Shanghai", 8*3600))
event := envelope.FrameEnvelope{
Protocol: envelope.ProtocolYutongMQTT,
VIN: "LMRKH9AC2R1004087",
SourceEndpoint: "mqtt://yutong/ytforward/shln/3",
EventTimeMS: time.Date(2026, 7, 8, 13, 20, 0, 0, time.FixedZone("Asia/Shanghai", 8*3600)).UnixMilli(),
Fields: map[string]any{
"yutong_mqtt.data.latitude": 30.590921,
"yutong_mqtt.data.longitude": 121.075044,
},
}
result, err := writer.AppendWithResult(context.Background(), event)
if err != nil {
t.Fatalf("AppendWithResult() error = %v", err)
}
if result.SamplesFound != 0 || result.SamplesSkippedMissingMileage != 1 || result.SamplesSkippedNonMileageFrame != 0 || result.SamplesWritten != 0 {
t.Fatalf("result = %+v, want missing mileage", result)
}
}
func TestWriterAppendWithResultClassifiesYutongMetadataOnlyFrameAsNonMileage(t *testing.T) {
exec := &recordingExec{}
writer := NewWriter(exec, time.FixedZone("Asia/Shanghai", 8*3600))
event := envelope.FrameEnvelope{
Protocol: envelope.ProtocolYutongMQTT,
VIN: "LMRKH9AC2R1004087",
SourceEndpoint: "mqtt://yutong/ytforward/shln/3",
EventTimeMS: time.Date(2026, 7, 8, 13, 20, 0, 0, time.FixedZone("Asia/Shanghai", 8*3600)).UnixMilli(),
Fields: map[string]any{
"yutong_mqtt.metadata.topic": "/ytforward/shln/3",
"yutong_mqtt.root.device": "LMRKH9AC2R1004087",
},
}
result, err := writer.AppendWithResult(context.Background(), event)
if err != nil {
t.Fatalf("AppendWithResult() error = %v", err)
}
if result.SamplesFound != 0 || result.SamplesSkippedNonMileageFrame != 1 || result.SamplesSkippedMissingMileage != 0 || result.SamplesWritten != 0 {
t.Fatalf("result = %+v, want non-mileage frame", result)
}
}
func TestWriterAppendWithResultReportsMissingTime(t *testing.T) {
exec := &recordingExec{}
writer := NewWriter(exec, time.FixedZone("Asia/Shanghai", 8*3600))
event := managedTestSource(envelope.FrameEnvelope{
Protocol: envelope.ProtocolJT808,
VIN: "LA9GG64L7PBAF4001",
Phone: "13307765812",
SourceEndpoint: "115.231.168.135:20215",
Fields: map[string]any{
"jt808.location.total_mileage_km": 4123.9,
},
})
result, err := writer.AppendWithResult(context.Background(), event)
if err != nil {
t.Fatalf("AppendWithResult() error = %v", err)
}
if result.SamplesFound != 0 || result.SamplesSkippedMissingTime != 1 || result.SamplesWritten != 0 {
t.Fatalf("result = %+v, want missing time skip", result)
}
if result.SourceTouchesAttempted != 1 || result.SourceTouchesWritten != 1 || result.SourceTouchesSkippedThrottled != 0 {
t.Fatalf("source touch result = %+v, want source touch before missing time skip", result)
}
if result.ProjectionsAttempted != 0 || result.ProjectionsWritten != 0 || result.ProjectionsSkippedThrottled != 0 {
t.Fatalf("projection result = %+v, want no projection for missing time", result)
}
}
func TestWriterAppendWithResultReportsMissingFieldsAndDoesNotTouchSource(t *testing.T) {
exec := &recordingExec{}
writer := NewWriter(exec, time.FixedZone("Asia/Shanghai", 8*3600))
event := envelope.FrameEnvelope{
Protocol: envelope.ProtocolJT808,
VIN: "LA9GG64L7PBAF4001",
Phone: "13307765812",
SourceEndpoint: "115.231.168.135:20215",
EventTimeMS: time.Date(2026, 7, 8, 13, 20, 0, 0, time.FixedZone("Asia/Shanghai", 8*3600)).UnixMilli(),
Parsed: map[string]any{
"location": map[string]any{"total_mileage_km": 4123.9},
},
}
result, err := writer.AppendWithResult(context.Background(), event)
if err != nil {
t.Fatalf("AppendWithResult() error = %v", err)
}
if result.SamplesSkippedMissingFields != 1 || result.SamplesSkippedMissingMileage != 0 || result.SamplesWritten != 0 {
t.Fatalf("result = %+v, want missing fields only", result)
}
if result.SourceTouchesAttempted != 0 || result.SourceTouchesWritten != 0 || result.SourceTouchesSkippedMissing != 0 {
t.Fatalf("source touch result = %+v, want no source touch without fields", result)
}
if len(exec.calls) != 0 {
t.Fatalf("exec calls = %d, want 0 for missing fields", len(exec.calls))
}
}
func TestSamplesFromEnvelopeUsesFieldsOnly(t *testing.T) {
loc := time.FixedZone("Asia/Shanghai", 8*3600)
_, result, err := samplesFromEnvelopeWithResult(envelope.FrameEnvelope{
Protocol: envelope.ProtocolJT808,
VIN: "LA9GG64L7PBAF4001",
EventTimeMS: time.Date(2026, 7, 8, 13, 20, 0, 0, loc).UnixMilli(),
Parsed: map[string]any{
"location": map[string]any{"total_mileage_km": 4123.9},
},
}, loc)
if err != nil {
t.Fatalf("samplesFromEnvelopeWithResult() error = %v", err)
}
if result.SamplesSkippedMissingFields != 1 || result.SamplesFound != 0 {
t.Fatalf("result = %+v, want missing fields and no extracted samples", result)
}
}
func TestWriterAppendDedupesRealtimeMileagePerSource(t *testing.T) {
exec := &recordingExec{}
writer := NewWriter(exec, time.FixedZone("Asia/Shanghai", 8*3600))
base := managedTestSource(envelope.FrameEnvelope{
Protocol: envelope.ProtocolJT808,
VIN: "LA9GG64L7PBAF4001",
Phone: "13307765812",
EventTimeMS: time.Date(2026, 7, 8, 13, 20, 0, 0, time.FixedZone("Asia/Shanghai", 8*3600)).UnixMilli(),
Fields: map[string]any{
"jt808.location.total_mileage_km": 4123.9,
},
})
sourceA := base
sourceA.SourceEndpoint = "115.231.168.135:20215"
if err := writer.Append(context.Background(), sourceA); err != nil {
t.Fatalf("Append(sourceA) error = %v", err)
}
sourceB := base
sourceB.SourceEndpoint = "115.159.85.149:28316"
sourceB.ReceivedAtMS = sourceB.EventTimeMS + 1000
if err := writer.Append(context.Background(), sourceB); err != nil {
t.Fatalf("Append(sourceB) error = %v", err)
}
sourceADuplicate := sourceA
sourceADuplicate.ReceivedAtMS = sourceA.EventTimeMS + 2000
if err := writer.Append(context.Background(), sourceADuplicate); err != nil {
t.Fatalf("Append(sourceADuplicate) error = %v", err)
}
if got := countExecQueries(exec.calls, "INSERT INTO vehicle_daily_mileage_source"); got != 2 {
t.Fatalf("candidate upserts = %d, want 2", got)
}
if got := countExecQueries(exec.calls, "INSERT INTO vehicle_data_source"); got != 2 {
t.Fatalf("source upserts = %d, want 2", got)
}
}
func TestWriterAppendCollapsesDirectSourceAcrossChangingIPs(t *testing.T) {
exec := &recordingExec{}
writer := NewWriter(exec, time.FixedZone("Asia/Shanghai", 8*3600))
base := envelope.FrameEnvelope{
Protocol: envelope.ProtocolJT808,
VIN: "LA9GG64L7PBAF4001",
Phone: "13307765812",
SourceKind: "DIRECT",
EventTimeMS: time.Date(2026, 7, 8, 13, 20, 0, 0, time.FixedZone("Asia/Shanghai", 8*3600)).UnixMilli(),
Fields: map[string]any{
"jt808.location.total_mileage_km": 4123.9,
},
}
first := base
first.SourceEndpoint = "115.231.168.135:20215"
if err := writer.Append(context.Background(), first); err != nil {
t.Fatalf("Append(first) error = %v", err)
}
second := base
second.SourceEndpoint = "39.144.3.22:60177"
second.ReceivedAtMS = second.EventTimeMS + 1000
if err := writer.Append(context.Background(), second); err != nil {
t.Fatalf("Append(second) error = %v", err)
}
var sourceKeys []string
for _, call := range exec.calls {
if strings.Contains(call.query, "INSERT INTO vehicle_daily_mileage_source") && len(call.args) > 3 {
sourceKeys = append(sourceKeys, call.args[3].(string))
}
}
if len(sourceKeys) != 1 {
t.Fatalf("source mileage upserts = %d, want one because identical mileage from same direct device should be deduplicated: %#v", len(sourceKeys), sourceKeys)
}
if sourceKeys[0] != "JT808:13307765812@DIRECT" {
t.Fatalf("source key = %q", sourceKeys[0])
}
}
func TestWriterAppendCollapsesPlatformSourceAcrossChangingIPs(t *testing.T) {
exec := &recordingExec{}
writer := NewWriter(exec, time.FixedZone("Asia/Shanghai", 8*3600))
base := envelope.FrameEnvelope{
Protocol: envelope.ProtocolJT808,
VIN: "LNXNEGRR0SR321372",
Phone: "41456413943",
SourceCode: "guangan_beidou",
PlatformName: "广安北斗",
SourceKind: "PLATFORM",
EventTimeMS: time.Date(2026, 7, 12, 8, 40, 0, 0, time.FixedZone("Asia/Shanghai", 8*3600)).UnixMilli(),
Fields: map[string]any{
"jt808.location.total_mileage_km": 46484.2,
},
}
first := base
first.SourceEndpoint = "117.132.194.167:9806"
if err := writer.Append(context.Background(), first); err != nil {
t.Fatalf("Append(first) error = %v", err)
}
second := base
second.SourceEndpoint = "117.132.198.90:12084"
second.EventTimeMS = second.EventTimeMS + 1000
second.Fields = map[string]any{"jt808.location.total_mileage_km": 46484.3}
if err := writer.Append(context.Background(), second); err != nil {
t.Fatalf("Append(second) error = %v", err)
}
var sourceKeys []string
for _, call := range exec.calls {
if strings.Contains(call.query, "INSERT INTO vehicle_daily_mileage_source") && len(call.args) > 3 {
sourceKeys = append(sourceKeys, call.args[3].(string))
}
}
if len(sourceKeys) != 2 {
t.Fatalf("source mileage upserts = %d, want both changing mileage samples written: %#v", len(sourceKeys), sourceKeys)
}
for _, sourceKey := range sourceKeys {
if sourceKey != "JT808:41456413943@PLATFORM:guangan_beidou" {
t.Fatalf("source key = %q", sourceKey)
}
}
if got := countExecQueries(exec.calls, "INSERT INTO vehicle_data_source"); got != 2 {
t.Fatalf("source touch upserts = %d, want both platform IPs still observed", got)
}
}
func TestWriterAppendThrottlesDailyProjectionPerVehicleProtocolDate(t *testing.T) {
exec := &recordingExec{}
loc := time.FixedZone("Asia/Shanghai", 8*3600)
writer := NewWriter(exec, loc)
base := managedTestSource(envelope.FrameEnvelope{
Protocol: envelope.ProtocolJT808,
VIN: "LA9GG64L7PBAF4001",
Phone: "13307765812",
SourceEndpoint: "115.231.168.135:20215",
Fields: map[string]any{
"jt808.location.total_mileage_km": 4123.9,
},
})
first := base
first.EventTimeMS = time.Date(2026, 7, 8, 13, 20, 0, 0, loc).UnixMilli()
if err := writer.Append(context.Background(), first); err != nil {
t.Fatalf("first Append() error = %v", err)
}
second := base
second.EventTimeMS = time.Date(2026, 7, 8, 13, 20, 5, 0, loc).UnixMilli()
second.Fields = map[string]any{"jt808.location.total_mileage_km": 4124.2}
if err := writer.Append(context.Background(), second); err != nil {
t.Fatalf("second Append() error = %v", err)
}
third := base
third.EventTimeMS = time.Date(2026, 7, 8, 13, 20, 16, 0, loc).UnixMilli()
third.Fields = map[string]any{"jt808.location.total_mileage_km": 4125.0}
if err := writer.Append(context.Background(), third); err != nil {
t.Fatalf("third Append() error = %v", err)
}
if got := countExecQueries(exec.calls, "INSERT INTO vehicle_daily_mileage_source"); got != 3 {
t.Fatalf("source candidate upserts = %d, want 3", got)
}
if got := countExecQueries(exec.calls, "INSERT INTO vehicle_daily_mileage\n"); got != 2 {
t.Fatalf("daily projections = %d, want 2", got)
}
}
func TestWriterFlushesFinalProjectionWhenVehicleStopsInsideThrottleWindow(t *testing.T) {
exec := &recordingExec{}
loc := time.FixedZone("Asia/Shanghai", 8*3600)
writer := NewWriter(exec, loc)
base := managedTestSource(envelope.FrameEnvelope{
Protocol: envelope.ProtocolJT808,
VIN: "LMRKH9AC7R1004120",
Phone: "64341233712",
SourceEndpoint: "115.159.85.149:7339",
Fields: map[string]any{
"jt808.location.total_mileage_km": 4732.6,
},
})
first := base
first.EventTimeMS = time.Date(2026, 7, 19, 15, 4, 45, 0, loc).UnixMilli()
if err := writer.Append(context.Background(), first); err != nil {
t.Fatalf("first Append() error = %v", err)
}
final := base
final.EventTimeMS = time.Date(2026, 7, 19, 15, 4, 52, 0, loc).UnixMilli()
final.Fields = map[string]any{"jt808.location.total_mileage_km": 4740.7}
if err := writer.Append(context.Background(), final); err != nil {
t.Fatalf("final Append() error = %v", err)
}
if got := writer.CacheStats().PendingProjectionEntries; got != 1 {
t.Fatalf("pending projections = %d, want final throttled sample queued", got)
}
beforeDue, err := writer.FlushPendingProjections(context.Background(), time.Now().Add(-time.Hour))
if err != nil {
t.Fatalf("early FlushPendingProjections() error = %v", err)
}
if beforeDue.Attempted != 0 || beforeDue.Written != 0 {
t.Fatalf("early flush result = %+v, want no eligible projection", beforeDue)
}
flushed, err := writer.FlushPendingProjections(context.Background(), time.Time{})
if err != nil {
t.Fatalf("FlushPendingProjections() error = %v", err)
}
if flushed.Attempted != 1 || flushed.Written != 1 {
t.Fatalf("flush result = %+v, want final projection written", flushed)
}
if got := countExecQueries(exec.calls, "INSERT INTO vehicle_daily_mileage\n"); got != 2 {
t.Fatalf("daily projections = %d, want initial plus eventual final projection", got)
}
if got := writer.CacheStats().PendingProjectionEntries; got != 0 {
t.Fatalf("pending projections after flush = %d, want 0", got)
}
key := projectionCacheKey(MetricSample{
VIN: "LMRKH9AC7R1004120",
Protocol: envelope.ProtocolJT808,
StatDate: "2026-07-19",
})
wantProjectedAt := time.UnixMilli(final.EventTimeMS).In(loc)
if got := writer.lastProjection[key].projectedAt; !got.Equal(wantProjectedAt) {
t.Fatalf("last projected event = %s, want %s", got, wantProjectedAt)
}
}
func TestWriterPendingProjectionFailureDoesNotBlockOtherVehicles(t *testing.T) {
exec := &selectiveFailingExec{failVIN: "FAIL-VIN"}
loc := time.FixedZone("Asia/Shanghai", 8*3600)
writer := NewWriter(exec, loc)
writer.projectionInterval = time.Hour
for _, vin := range []string{"FAIL-VIN", "OK-VIN"} {
sample := MetricSample{
VIN: vin,
Protocol: envelope.ProtocolJT808,
StatDate: "2026-07-19",
SourceKey: "jt808:test",
EventTime: time.Date(2026, 7, 19, 15, 4, 52, 0, loc),
TotalMileageKM: 100,
}
writer.markProjectionPending(sample, time.Now().Add(-time.Hour))
}
result, err := writer.FlushPendingProjections(context.Background(), time.Time{})
if err == nil {
t.Fatal("FlushPendingProjections() error = nil, want failed vehicle reported")
}
if result.Attempted != 2 || result.Written != 1 || result.Failed != 1 {
t.Fatalf("flush result = %+v, want one failure and one successful projection", result)
}
if got := writer.CacheStats().PendingProjectionEntries; got != 1 {
t.Fatalf("pending projections after partial failure = %d, want only failed vehicle retained", got)
}
}
func TestWriterReconcilesDurableProjectionAfterPendingQueueIsLost(t *testing.T) {
db, mock, err := sqlmock.New(sqlmock.QueryMatcherOption(sqlmock.QueryMatcherEqual))
if err != nil {
t.Fatalf("sqlmock.New() error = %v", err)
}
defer db.Close()
writer := NewWriter(db, time.FixedZone("Asia/Shanghai", 8*3600))
vin := "LMRKH9AC7R1004120"
statDate := "2026-07-19"
protocol := envelope.ProtocolJT808
mock.ExpectQuery(staleDailyMileageProjectionTargetsSQL).
WithArgs(statDate).
WillReturnRows(sqlmock.NewRows([]string{"vin", "protocol"}).AddRow(vin, string(protocol)))
expectProjectDailyMileageSQL(mock, vin, statDate, protocol)
mock.ExpectCommit()
result, err := writer.ReconcileDateProjections(context.Background(), statDate)
if err != nil {
t.Fatalf("ReconcileDateProjections() error = %v", err)
}
if result.Targets != 1 || result.Attempted != 1 || result.Written != 1 || result.Failed != 0 {
t.Fatalf("reconcile result = %+v, want one recovered projection", result)
}
if got := writer.CacheStats().PendingProjectionEntries; got != 0 {
t.Fatalf("startup reconciliation should not depend on pending memory, got %d entries", got)
}
if err := mock.ExpectationsWereMet(); err != nil {
t.Fatalf("sql expectations: %v", err)
}
}
func TestWriterProjectionReconciliationRequiresQueryableStore(t *testing.T) {
writer := NewWriter(&recordingExec{}, time.FixedZone("Asia/Shanghai", 8*3600))
result, err := writer.ReconcileDateProjections(context.Background(), "2026-07-19")
if err == nil || !strings.Contains(err.Error(), "query support") {
t.Fatalf("ReconcileDateProjections() error = %v, want query support failure", err)
}
if result != (ProjectionReconcileResult{}) {
t.Fatalf("reconcile result = %+v, want empty", result)
}
}
func TestWriterAppendProjectsImmediatelyForNewSource(t *testing.T) {
exec := &recordingExec{}
loc := time.FixedZone("Asia/Shanghai", 8*3600)
writer := NewWriter(exec, loc)
base := managedTestSource(envelope.FrameEnvelope{
Protocol: envelope.ProtocolJT808,
VIN: "LA9GG64L7PBAF4001",
Phone: "13307765812",
EventTimeMS: time.Date(2026, 7, 8, 13, 20, 0, 0, loc).UnixMilli(),
Fields: map[string]any{
"jt808.location.total_mileage_km": 4123.9,
},
})
sourceA := base
sourceA.SourceEndpoint = "115.231.168.135:20215"
if err := writer.Append(context.Background(), sourceA); err != nil {
t.Fatalf("Append(sourceA) error = %v", err)
}
sourceB := base
sourceB.SourceEndpoint = "115.159.85.149:28316"
sourceB.Fields = map[string]any{"jt808.location.total_mileage_km": 4124.0}
if err := writer.Append(context.Background(), sourceB); err != nil {
t.Fatalf("Append(sourceB) error = %v", err)
}
if got := countExecQueries(exec.calls, "INSERT INTO vehicle_daily_mileage\n"); got != 2 {
t.Fatalf("daily projections = %d, want immediate projection for each new source", got)
}
}
func TestWriterProjectionIntervalZeroKeepsLegacyPerSampleProjection(t *testing.T) {
exec := &recordingExec{}
loc := time.FixedZone("Asia/Shanghai", 8*3600)
writer := NewWriter(exec, loc)
writer.SetProjectionInterval(0)
base := managedTestSource(envelope.FrameEnvelope{
Protocol: envelope.ProtocolJT808,
VIN: "LA9GG64L7PBAF4001",
Phone: "13307765812",
SourceEndpoint: "115.231.168.135:20215",
Fields: map[string]any{
"jt808.location.total_mileage_km": 4123.9,
},
})
for i, mileage := range []float64{4123.9, 4124.0} {
event := base
event.EventTimeMS = time.Date(2026, 7, 8, 13, 20, i, 0, loc).UnixMilli()
event.Fields = map[string]any{"jt808.location.total_mileage_km": mileage}
if err := writer.Append(context.Background(), event); err != nil {
t.Fatalf("Append(%d) error = %v", i, err)
}
}
if got := countExecQueries(exec.calls, "INSERT INTO vehicle_daily_mileage\n"); got != 2 {
t.Fatalf("daily projections = %d, want 2", got)
}
}
func TestWriterAppendUsesCurrentSampleWhenNoHistoricalBaseline(t *testing.T) {
db, mock, err := sqlmock.New()
if err != nil {
t.Fatalf("sqlmock.New() error = %v", err)
}
defer db.Close()
loc := time.FixedZone("Asia/Shanghai", 8*3600)
writer := NewWriter(db, loc)
eventTime := time.Date(2026, 7, 8, 13, 20, 0, 0, loc)
event := managedTestSource(envelope.FrameEnvelope{
Protocol: envelope.ProtocolJT808,
VIN: "LA9GG64L7PBAF4001",
Phone: "13307765812",
SourceEndpoint: "115.231.168.135:20215",
EventTimeMS: eventTime.UnixMilli(),
Fields: map[string]any{
"jt808.location.total_mileage_km": 4123.9,
},
})
mock.ExpectExec(`INSERT INTO vehicle_data_source`).
WithArgs("JT808", "115.231.168.135", "115.231.168.135:20215", sqlmock.AnyArg(), sqlmock.AnyArg(), sqlmock.AnyArg(), sqlmock.AnyArg(), sqlmock.AnyArg()).
WillReturnResult(sqlmock.NewResult(0, 1))
mock.ExpectQuery(`SELECT latest_total_mileage_km, latest_event_time FROM vehicle_daily_mileage_source`).
WithArgs("LA9GG64L7PBAF4001", "2026-07-08", "JT808", "JT808:13307765812@115.231.168.135").
WillReturnRows(sqlmock.NewRows([]string{"latest_total_mileage_km", "latest_event_time"}))
mock.ExpectBegin()
mock.ExpectExec(`INSERT INTO vehicle_daily_mileage_source`).
WithArgs(
"LA9GG64L7PBAF4001",
"2026-07-08",
"JT808",
"JT808:13307765812@115.231.168.135",
"115.231.168.135",
"115.231.168.135:20215",
"13307765812",
"",
"",
float64(4123.9),
float64(4123.9),
float64(0),
int64(1),
eventTime,
eventTime,
QualityOK,
QualityReasonCurrentDayFirst,
).
WillReturnResult(sqlmock.NewResult(0, 1))
mock.ExpectExec(`INSERT INTO vehicle_daily_mileage`).
WithArgs("LA9GG64L7PBAF4001", "2026-07-08", "JT808", int64(maxSelectedDailyMileageKM)).
WillReturnResult(sqlmock.NewResult(0, 1))
mock.ExpectExec(`UPDATE vehicle_daily_mileage_source s`).
WithArgs(
"LA9GG64L7PBAF4001",
"2026-07-08",
"JT808",
int64(maxSelectedDailyMileageKM),
"LA9GG64L7PBAF4001",
"2026-07-08",
"JT808",
).
WillReturnResult(sqlmock.NewResult(0, 1))
mock.ExpectExec(`DELETE FROM vehicle_daily_mileage`).
WithArgs(
"LA9GG64L7PBAF4001",
"2026-07-08",
"JT808",
"LA9GG64L7PBAF4001",
"2026-07-08",
"JT808",
).
WillReturnResult(sqlmock.NewResult(0, 0))
mock.ExpectCommit()
if err := writer.Append(context.Background(), event); err != nil {
t.Fatalf("Append() error = %v", err)
}
if err := mock.ExpectationsWereMet(); err != nil {
t.Fatalf("sql expectations: %v", err)
}
}
func TestWriterCachesMissingBaselineAfterSuccessfulFirstSample(t *testing.T) {
db, mock, err := sqlmock.New()
if err != nil {
t.Fatalf("sqlmock.New() error = %v", err)
}
defer db.Close()
loc := time.FixedZone("Asia/Shanghai", 8*3600)
writer := NewWriter(db, loc)
firstTime := time.Date(2026, 7, 8, 13, 20, 0, 0, loc)
secondTime := firstTime.Add(5 * time.Second)
base := managedTestSource(envelope.FrameEnvelope{
Protocol: envelope.ProtocolJT808,
VIN: "LA9GG64L7PBAF4001",
Phone: "13307765812",
SourceEndpoint: "115.231.168.135:20215",
})
mock.ExpectExec(`INSERT INTO vehicle_data_source`).
WithArgs("JT808", "115.231.168.135", "115.231.168.135:20215", sqlmock.AnyArg(), sqlmock.AnyArg(), sqlmock.AnyArg(), sqlmock.AnyArg(), sqlmock.AnyArg()).
WillReturnResult(sqlmock.NewResult(0, 1))
mock.ExpectQuery(`SELECT latest_total_mileage_km, latest_event_time FROM vehicle_daily_mileage_source`).
WithArgs("LA9GG64L7PBAF4001", "2026-07-08", "JT808", "JT808:13307765812@115.231.168.135").
WillReturnRows(sqlmock.NewRows([]string{"latest_total_mileage_km", "latest_event_time"}))
mock.ExpectBegin()
mock.ExpectExec(`INSERT INTO vehicle_daily_mileage_source`).
WithArgs(
"LA9GG64L7PBAF4001",
"2026-07-08",
"JT808",
"JT808:13307765812@115.231.168.135",
"115.231.168.135",
"115.231.168.135:20215",
"13307765812",
"",
"",
float64(4123.9),
float64(4123.9),
float64(0),
int64(1),
firstTime,
firstTime,
QualityOK,
QualityReasonCurrentDayFirst,
).
WillReturnResult(sqlmock.NewResult(0, 1))
mock.ExpectExec(`INSERT INTO vehicle_daily_mileage`).
WithArgs("LA9GG64L7PBAF4001", "2026-07-08", "JT808", int64(maxSelectedDailyMileageKM)).
WillReturnResult(sqlmock.NewResult(0, 1))
mock.ExpectExec(`UPDATE vehicle_daily_mileage_source s`).
WithArgs(
"LA9GG64L7PBAF4001",
"2026-07-08",
"JT808",
int64(maxSelectedDailyMileageKM),
"LA9GG64L7PBAF4001",
"2026-07-08",
"JT808",
).
WillReturnResult(sqlmock.NewResult(0, 1))
mock.ExpectExec(`DELETE FROM vehicle_daily_mileage`).
WithArgs(
"LA9GG64L7PBAF4001",
"2026-07-08",
"JT808",
"LA9GG64L7PBAF4001",
"2026-07-08",
"JT808",
).
WillReturnResult(sqlmock.NewResult(0, 0))
mock.ExpectCommit()
mock.ExpectExec(`INSERT INTO vehicle_daily_mileage_source`).
WithArgs(
"LA9GG64L7PBAF4001",
"2026-07-08",
"JT808",
"JT808:13307765812@115.231.168.135",
"115.231.168.135",
"115.231.168.135:20215",
"13307765812",
"",
"",
float64(4123.9),
float64(4124.4),
approxFloat64{want: 0.5, tolerance: 0.000001},
int64(1),
firstTime,
secondTime,
QualityOK,
QualityReasonCurrentDayFirst,
).
WillReturnResult(sqlmock.NewResult(0, 1))
first := base
first.EventTimeMS = firstTime.UnixMilli()
first.Fields = map[string]any{"jt808.location.total_mileage_km": 4123.9}
if err := writer.Append(context.Background(), first); err != nil {
t.Fatalf("first Append() error = %v", err)
}
second := base
second.EventTimeMS = secondTime.UnixMilli()
second.Fields = map[string]any{"jt808.location.total_mileage_km": 4124.4}
if err := writer.Append(context.Background(), second); err != nil {
t.Fatalf("second Append() error = %v", err)
}
if err := mock.ExpectationsWereMet(); err != nil {
t.Fatalf("sql expectations: %v", err)
}
}
func TestWriterRetriesExpiredMissingPreviousDayBaseline(t *testing.T) {
db, mock, err := sqlmock.New()
if err != nil {
t.Fatalf("sqlmock.New() error = %v", err)
}
defer db.Close()
loc := time.FixedZone("Asia/Shanghai", 8*3600)
writer := NewWriter(db, loc)
writer.SetBaselineMissTTL(0)
candidate := SourceMileageSample{
VIN: "LA9GG64L7PBAF4001",
StatDate: "2026-07-13",
Protocol: envelope.ProtocolJT808,
SourceKey: "JT808:64013036430@PLATFORM:g7s",
}
mock.ExpectQuery(`SELECT latest_total_mileage_km, latest_event_time FROM vehicle_daily_mileage_source`).
WithArgs(candidate.VIN, candidate.StatDate, "JT808", candidate.SourceKey).
WillReturnRows(sqlmock.NewRows([]string{"latest_total_mileage_km", "latest_event_time"}))
if _, found, err := writer.previousBaseline(context.Background(), candidate); err != nil || found {
t.Fatalf("first previousBaseline() found=%v error=%v, want cacheable miss", found, err)
}
previousTime := time.Date(2026, 7, 12, 23, 58, 0, 0, loc)
mock.ExpectQuery(`SELECT latest_total_mileage_km, latest_event_time FROM vehicle_daily_mileage_source`).
WithArgs(candidate.VIN, candidate.StatDate, "JT808", candidate.SourceKey).
WillReturnRows(sqlmock.NewRows([]string{"latest_total_mileage_km", "latest_event_time"}).AddRow(42567.9, previousTime))
baseline, found, err := writer.previousBaseline(context.Background(), candidate)
if err != nil || !found {
t.Fatalf("second previousBaseline() found=%v error=%v, want recovered baseline", found, err)
}
if baseline.LatestTotalKM != 42567.9 || !baseline.LatestEventTime.Equal(previousTime) {
t.Fatalf("baseline = %+v, want previous natural-day last sample", baseline)
}
if err := mock.ExpectationsWereMet(); err != nil {
t.Fatalf("sql expectations: %v", err)
}
}
func TestWriterRefreshesExpiredFoundPreviousDayBaseline(t *testing.T) {
db, mock, err := sqlmock.New()
if err != nil {
t.Fatalf("sqlmock.New() error = %v", err)
}
defer db.Close()
loc := time.FixedZone("Asia/Shanghai", 8*3600)
writer := NewWriter(db, loc)
writer.SetBaselineHitTTL(time.Minute)
candidate := SourceMileageSample{
VIN: "LMRKH9AC6R1004111",
StatDate: "2026-07-17",
Protocol: envelope.ProtocolYutongMQTT,
SourceKey: "YUTONG_MQTT:LMRKH9AC6R1004111@PLATFORM:yutong",
}
cacheKey := mileageCacheKey(MetricSample{
VIN: candidate.VIN,
Protocol: candidate.Protocol,
StatDate: candidate.StatDate,
SourceKey: candidate.SourceKey,
})
staleTime := time.Date(2026, 7, 12, 4, 12, 20, 0, loc)
writer.baselineCache[cacheKey] = sourceBaselineCacheEntry{
baseline: sourceBaseline{LatestTotalKM: 90778, LatestEventTime: staleTime},
found: true,
cachedAt: time.Now().Add(-2 * time.Minute),
}
refreshedTime := time.Date(2026, 7, 16, 23, 59, 59, 0, loc)
mock.ExpectQuery(`SELECT latest_total_mileage_km, latest_event_time FROM vehicle_daily_mileage_source`).
WithArgs(candidate.VIN, candidate.StatDate, "YUTONG_MQTT", candidate.SourceKey).
WillReturnRows(sqlmock.NewRows([]string{"latest_total_mileage_km", "latest_event_time"}).
AddRow(91302.0, refreshedTime))
baseline, found, err := writer.previousBaseline(context.Background(), candidate)
if err != nil || !found {
t.Fatalf("previousBaseline() found=%v error=%v, want refreshed baseline", found, err)
}
if baseline.LatestTotalKM != 91302 || !baseline.LatestEventTime.Equal(refreshedTime) {
t.Fatalf("baseline = %+v, want nearest refreshed baseline", baseline)
}
if err := mock.ExpectationsWereMet(); err != nil {
t.Fatalf("sql expectations: %v", err)
}
}
func TestWriterMarkBaselineKeepsCacheAgeForUnchangedBoundary(t *testing.T) {
db, _, err := sqlmock.New()
if err != nil {
t.Fatalf("sqlmock.New() error = %v", err)
}
defer db.Close()
loc := time.FixedZone("Asia/Shanghai", 8*3600)
writer := NewWriter(db, loc)
candidate := SourceMileageSample{
VIN: "LMRKH9AC6R1004111",
StatDate: "2026-07-17",
Protocol: envelope.ProtocolYutongMQTT,
SourceKey: "YUTONG_MQTT:LMRKH9AC6R1004111@PLATFORM:yutong",
FirstTotalKM: 91302,
FirstEventTime: time.Date(2026, 7, 16, 23, 59, 59, 0, loc),
}
sample := MetricSample{
VIN: candidate.VIN,
Protocol: candidate.Protocol,
StatDate: candidate.StatDate,
SourceKey: candidate.SourceKey,
}
cacheKey := mileageCacheKey(sample)
cachedAt := time.Now().Add(-4 * time.Minute)
writer.baselineCache[cacheKey] = sourceBaselineCacheEntry{
baseline: sourceBaseline{LatestTotalKM: candidate.FirstTotalKM, LatestEventTime: candidate.FirstEventTime},
found: true,
cachedAt: cachedAt,
}
writer.markBaselineWritten(sample, candidate)
if got := writer.baselineCache[cacheKey].cachedAt; !got.Equal(cachedAt) {
t.Fatalf("cachedAt = %s, want unchanged %s", got, cachedAt)
}
}
func TestWriterAppendUsesPreviousSourceBaselineForRealtimeCandidate(t *testing.T) {
db, mock, err := sqlmock.New()
if err != nil {
t.Fatalf("sqlmock.New() error = %v", err)
}
defer db.Close()
loc := time.FixedZone("Asia/Shanghai", 8*3600)
writer := NewWriter(db, loc)
previousTime := time.Date(2026, 7, 7, 23, 58, 0, 0, loc)
currentTime := time.Date(2026, 7, 8, 13, 20, 0, 0, loc)
event := managedTestSource(envelope.FrameEnvelope{
Protocol: envelope.ProtocolJT808,
VIN: "LA9GG64L7PBAF4001",
Phone: "13307765812",
SourceEndpoint: "115.231.168.135:20215",
EventTimeMS: currentTime.UnixMilli(),
Fields: map[string]any{
"jt808.location.total_mileage_km": 4123.9,
},
})
mock.ExpectExec(`INSERT INTO vehicle_data_source`).
WithArgs("JT808", "115.231.168.135", "115.231.168.135:20215", sqlmock.AnyArg(), sqlmock.AnyArg(), sqlmock.AnyArg(), sqlmock.AnyArg(), sqlmock.AnyArg()).
WillReturnResult(sqlmock.NewResult(0, 1))
mock.ExpectQuery(`SELECT latest_total_mileage_km, latest_event_time FROM vehicle_daily_mileage_source`).
WithArgs("LA9GG64L7PBAF4001", "2026-07-08", "JT808", "JT808:13307765812@115.231.168.135").
WillReturnRows(sqlmock.NewRows([]string{"latest_total_mileage_km", "latest_event_time"}).
AddRow(4100.8, previousTime))
mock.ExpectBegin()
mock.ExpectExec(`INSERT INTO vehicle_daily_mileage_source`).
WithArgs(
"LA9GG64L7PBAF4001",
"2026-07-08",
"JT808",
"JT808:13307765812@115.231.168.135",
"115.231.168.135",
"115.231.168.135:20215",
"13307765812",
"",
"",
float64(4100.8),
float64(4123.9),
approxFloat64{want: 23.1, tolerance: 0.000001},
int64(1),
previousTime,
currentTime,
QualityOK,
QualityReasonHistorical,
).
WillReturnResult(sqlmock.NewResult(0, 1))
mock.ExpectExec(`INSERT INTO vehicle_daily_mileage`).
WithArgs("LA9GG64L7PBAF4001", "2026-07-08", "JT808", int64(maxSelectedDailyMileageKM)).
WillReturnResult(sqlmock.NewResult(0, 1))
mock.ExpectExec(`UPDATE vehicle_daily_mileage_source s`).
WithArgs(
"LA9GG64L7PBAF4001",
"2026-07-08",
"JT808",
int64(maxSelectedDailyMileageKM),
"LA9GG64L7PBAF4001",
"2026-07-08",
"JT808",
).
WillReturnResult(sqlmock.NewResult(0, 1))
mock.ExpectExec(`DELETE FROM vehicle_daily_mileage`).
WithArgs(
"LA9GG64L7PBAF4001",
"2026-07-08",
"JT808",
"LA9GG64L7PBAF4001",
"2026-07-08",
"JT808",
).
WillReturnResult(sqlmock.NewResult(0, 0))
mock.ExpectCommit()
if err := writer.Append(context.Background(), event); err != nil {
t.Fatalf("Append() error = %v", err)
}
if err := mock.ExpectationsWereMet(); err != nil {
t.Fatalf("sql expectations: %v", err)
}
}
func TestWriterAppendUsesOlderHistoricalSourceBaseline(t *testing.T) {
db, mock, err := sqlmock.New()
if err != nil {
t.Fatalf("sqlmock.New() error = %v", err)
}
defer db.Close()
loc := time.FixedZone("Asia/Shanghai", 8*3600)
writer := NewWriter(db, loc)
historicalTime := time.Date(2026, 7, 4, 23, 58, 0, 0, loc)
currentTime := time.Date(2026, 7, 8, 13, 20, 0, 0, loc)
event := managedTestSource(envelope.FrameEnvelope{
Protocol: envelope.ProtocolYutongMQTT,
VIN: "LMRKH9AC2R1004087",
DeviceID: "LMRKH9AC2R1004087",
SourceEndpoint: "mqtt://yutong/ytforward/shln/3",
EventTimeMS: currentTime.UnixMilli(),
Fields: map[string]any{
"yutong_mqtt.data.total_mileage": 120788000,
},
})
mock.ExpectExec(`INSERT INTO vehicle_data_source`).
WithArgs("YUTONG_MQTT", "mqtt", "mqtt://yutong/ytforward/shln/3", sqlmock.AnyArg(), sqlmock.AnyArg(), sqlmock.AnyArg(), sqlmock.AnyArg(), sqlmock.AnyArg()).
WillReturnResult(sqlmock.NewResult(0, 1))
mock.ExpectQuery(`SELECT latest_total_mileage_km, latest_event_time FROM vehicle_daily_mileage_source`).
WithArgs("LMRKH9AC2R1004087", "2026-07-08", "YUTONG_MQTT", "YUTONG_MQTT:LMRKH9AC2R1004087@mqtt").
WillReturnRows(sqlmock.NewRows([]string{"latest_total_mileage_km", "latest_event_time"}).
AddRow(120672.0, historicalTime))
mock.ExpectBegin()
mock.ExpectExec(`INSERT INTO vehicle_daily_mileage_source`).
WithArgs(
"LMRKH9AC2R1004087",
"2026-07-08",
"YUTONG_MQTT",
"YUTONG_MQTT:LMRKH9AC2R1004087@mqtt",
"mqtt",
"mqtt://yutong/ytforward/shln/3",
"",
"LMRKH9AC2R1004087",
"",
float64(120672.0),
float64(120788.0),
approxFloat64{want: 116.0, tolerance: 0.000001},
int64(1),
historicalTime,
currentTime,
QualityOK,
QualityReasonHistorical,
).
WillReturnResult(sqlmock.NewResult(0, 1))
mock.ExpectExec(`INSERT INTO vehicle_daily_mileage`).
WithArgs("LMRKH9AC2R1004087", "2026-07-08", "YUTONG_MQTT", int64(maxSelectedDailyMileageKM)).
WillReturnResult(sqlmock.NewResult(0, 1))
mock.ExpectExec(`UPDATE vehicle_daily_mileage_source s`).
WithArgs(
"LMRKH9AC2R1004087",
"2026-07-08",
"YUTONG_MQTT",
int64(maxSelectedDailyMileageKM),
"LMRKH9AC2R1004087",
"2026-07-08",
"YUTONG_MQTT",
).
WillReturnResult(sqlmock.NewResult(0, 1))
mock.ExpectExec(`DELETE FROM vehicle_daily_mileage`).
WithArgs(
"LMRKH9AC2R1004087",
"2026-07-08",
"YUTONG_MQTT",
"LMRKH9AC2R1004087",
"2026-07-08",
"YUTONG_MQTT",
).
WillReturnResult(sqlmock.NewResult(0, 0))
mock.ExpectCommit()
if err := writer.Append(context.Background(), event); err != nil {
t.Fatalf("Append() error = %v", err)
}
if err := mock.ExpectationsWereMet(); err != nil {
t.Fatalf("sql expectations: %v", err)
}
}
func TestWriterApplyRealtimeBaselineClampsSmallNegativeMileageJitter(t *testing.T) {
db, mock, err := sqlmock.New()
if err != nil {
t.Fatalf("sqlmock.New() error = %v", err)
}
defer db.Close()
loc := time.FixedZone("Asia/Shanghai", 8*3600)
writer := NewWriter(db, loc)
baselineTime := time.Date(2026, 7, 11, 19, 32, 20, 0, loc)
currentTime := time.Date(2026, 7, 12, 2, 38, 23, 0, loc)
candidate := SourceMileageSample{
VIN: "LB9A32A28R0LS1574",
StatDate: "2026-07-12",
Protocol: envelope.ProtocolJT808,
SourceKey: "JT808:64115156034@115.159.85.149",
SourceIP: "115.159.85.149",
LatestTotalKM: 15355.3,
LatestEventTime: currentTime,
}
mock.ExpectQuery(`SELECT latest_total_mileage_km, latest_event_time FROM vehicle_daily_mileage_source`).
WithArgs("LB9A32A28R0LS1574", "2026-07-12", "JT808", "JT808:64115156034@115.159.85.149").
WillReturnRows(sqlmock.NewRows([]string{"latest_total_mileage_km", "latest_event_time"}).
AddRow(15355.4, baselineTime))
if err := writer.applyRealtimeBaseline(context.Background(), &candidate); err != nil {
t.Fatalf("applyRealtimeBaseline() error = %v", err)
}
if candidate.QualityStatus != QualityOK || candidate.QualityReason != "negative_jitter_clamped" {
t.Fatalf("quality = %s/%s", candidate.QualityStatus, candidate.QualityReason)
}
if candidate.DailyKM != 0 {
t.Fatalf("daily km = %v, want 0", candidate.DailyKM)
}
if candidate.FirstTotalKM != 15355.4 || !candidate.FirstEventTime.Equal(baselineTime) {
t.Fatalf("baseline not preserved: %#v", candidate)
}
if err := mock.ExpectationsWereMet(); err != nil {
t.Fatalf("sql expectations: %v", err)
}
}
func TestWriterApplyRealtimeBaselineKeepsNegativeHistoricalDeltaInvalid(t *testing.T) {
db, mock, err := sqlmock.New()
if err != nil {
t.Fatalf("sqlmock.New() error = %v", err)
}
defer db.Close()
loc := time.FixedZone("Asia/Shanghai", 8*3600)
writer := NewWriter(db, loc)
baselineTime := time.Date(2026, 7, 11, 19, 32, 20, 0, loc)
currentTime := time.Date(2026, 7, 12, 2, 38, 23, 0, loc)
candidate := SourceMileageSample{
VIN: "LB9A32A28R0LS1574",
StatDate: "2026-07-12",
Protocol: envelope.ProtocolJT808,
SourceKey: "JT808:64115156034@115.159.85.149",
SourceIP: "115.159.85.149",
LatestTotalKM: 15300.0,
LatestEventTime: currentTime,
}
mock.ExpectQuery(`SELECT latest_total_mileage_km, latest_event_time FROM vehicle_daily_mileage_source`).
WithArgs("LB9A32A28R0LS1574", "2026-07-12", "JT808", "JT808:64115156034@115.159.85.149").
WillReturnRows(sqlmock.NewRows([]string{"latest_total_mileage_km", "latest_event_time"}).
AddRow(15355.4, baselineTime))
if err := writer.applyRealtimeBaseline(context.Background(), &candidate); err != nil {
t.Fatalf("applyRealtimeBaseline() error = %v", err)
}
if candidate.QualityStatus != QualityInvalidDelta || candidate.QualityReason != "outside_daily_range" {
t.Fatalf("quality = %s/%s", candidate.QualityStatus, candidate.QualityReason)
}
if candidate.DailyKM > -55 || candidate.DailyKM < -56 {
t.Fatalf("daily km = %v, want large negative delta", candidate.DailyKM)
}
if candidate.FirstTotalKM != 15355.4 || !candidate.FirstEventTime.Equal(baselineTime) {
t.Fatalf("previous-day baseline not preserved: %#v", candidate)
}
if err := mock.ExpectationsWereMet(); err != nil {
t.Fatalf("sql expectations: %v", err)
}
}
func TestWriterApplyRealtimeBaselineKeepsInvalidWhenCurrentDayBaselineIsStillHigher(t *testing.T) {
db, mock, err := sqlmock.New()
if err != nil {
t.Fatalf("sqlmock.New() error = %v", err)
}
defer db.Close()
loc := time.FixedZone("Asia/Shanghai", 8*3600)
writer := NewWriter(db, loc)
previousTime := time.Date(2026, 7, 11, 19, 32, 20, 0, loc)
currentTime := time.Date(2026, 7, 12, 2, 38, 23, 0, loc)
candidate := SourceMileageSample{
VIN: "LB9A32A28R0LS1574",
StatDate: "2026-07-12",
Protocol: envelope.ProtocolJT808,
SourceKey: "JT808:64115156034@115.159.85.149",
SourceIP: "115.159.85.149",
LatestTotalKM: 15300.0,
LatestEventTime: currentTime,
}
mock.ExpectQuery(`SELECT latest_total_mileage_km, latest_event_time FROM vehicle_daily_mileage_source`).
WithArgs("LB9A32A28R0LS1574", "2026-07-12", "JT808", "JT808:64115156034@115.159.85.149").
WillReturnRows(sqlmock.NewRows([]string{"latest_total_mileage_km", "latest_event_time"}).
AddRow(15355.4, previousTime))
if err := writer.applyRealtimeBaseline(context.Background(), &candidate); err != nil {
t.Fatalf("applyRealtimeBaseline() error = %v", err)
}
if candidate.QualityStatus != QualityInvalidDelta || candidate.QualityReason != "outside_daily_range" {
t.Fatalf("quality = %s/%s", candidate.QualityStatus, candidate.QualityReason)
}
if candidate.DailyKM > -55 || candidate.DailyKM < -56 {
t.Fatalf("daily km = %v, want large negative delta", candidate.DailyKM)
}
if err := mock.ExpectationsWereMet(); err != nil {
t.Fatalf("sql expectations: %v", err)
}
}
func TestWriterApplyRealtimeBaselineRejectsNegativeDeltaEvenWithLowerCurrentDaySample(t *testing.T) {
db, mock, err := sqlmock.New()
if err != nil {
t.Fatalf("sqlmock.New() error = %v", err)
}
defer db.Close()
loc := time.FixedZone("Asia/Shanghai", 8*3600)
writer := NewWriter(db, loc)
previousTime := time.Date(2026, 7, 11, 19, 32, 20, 0, loc)
currentTime := time.Date(2026, 7, 12, 2, 38, 23, 0, loc)
candidate := SourceMileageSample{
VIN: "LB9A32A28R0LS1574",
StatDate: "2026-07-12",
Protocol: envelope.ProtocolJT808,
SourceKey: "JT808:64115156034@115.159.85.149",
SourceIP: "115.159.85.149",
LatestTotalKM: 15300.0,
LatestEventTime: currentTime,
}
mock.ExpectQuery(`SELECT latest_total_mileage_km, latest_event_time FROM vehicle_daily_mileage_source`).
WithArgs("LB9A32A28R0LS1574", "2026-07-12", "JT808", "JT808:64115156034@115.159.85.149").
WillReturnRows(sqlmock.NewRows([]string{"latest_total_mileage_km", "latest_event_time"}).
AddRow(15355.4, previousTime))
if err := writer.applyRealtimeBaseline(context.Background(), &candidate); err != nil {
t.Fatalf("applyRealtimeBaseline() error = %v", err)
}
if candidate.QualityStatus != QualityInvalidDelta || candidate.QualityReason != "outside_daily_range" {
t.Fatalf("quality = %s/%s", candidate.QualityStatus, candidate.QualityReason)
}
if candidate.DailyKM > -55 || candidate.DailyKM < -56 {
t.Fatalf("daily km = %v, want large negative delta", candidate.DailyKM)
}
if candidate.FirstTotalKM != 15355.4 || !candidate.FirstEventTime.Equal(previousTime) {
t.Fatalf("previous-day baseline not preserved: %#v", candidate)
}
if err := mock.ExpectationsWereMet(); err != nil {
t.Fatalf("sql expectations: %v", err)
}
}
func TestWriterApplyRealtimeBaselineAcceptsPlausibleMultiDayFallbackDelta(t *testing.T) {
db, mock, err := sqlmock.New()
if err != nil {
t.Fatalf("sqlmock.New() error = %v", err)
}
defer db.Close()
loc := time.FixedZone("Asia/Shanghai", 8*3600)
writer := NewWriter(db, loc)
baselineTime := time.Date(2026, 7, 4, 11, 7, 58, 0, loc)
currentTime := time.Date(2026, 7, 12, 2, 52, 47, 0, loc)
candidate := SourceMileageSample{
VIN: "LNXNEGRR1SR319498",
StatDate: "2026-07-12",
Protocol: envelope.ProtocolGB32960,
SourceKey: "GB32960:unknown@8.134.95.166",
SourceIP: "8.134.95.166",
LatestTotalKM: 16665.6,
LatestEventTime: currentTime,
}
mock.ExpectQuery(`SELECT latest_total_mileage_km, latest_event_time FROM vehicle_daily_mileage_source`).
WithArgs("LNXNEGRR1SR319498", "2026-07-12", "GB32960", "GB32960:unknown@8.134.95.166").
WillReturnRows(sqlmock.NewRows([]string{"latest_total_mileage_km", "latest_event_time"}).
AddRow(8832.1, baselineTime))
if err := writer.applyRealtimeBaseline(context.Background(), &candidate); err != nil {
t.Fatalf("applyRealtimeBaseline() error = %v", err)
}
if candidate.QualityStatus != QualityOK || candidate.QualityReason != QualityReasonHistorical {
t.Fatalf("quality = %s/%s", candidate.QualityStatus, candidate.QualityReason)
}
if candidate.DailyKM < 7833.4 || candidate.DailyKM > 7833.6 {
t.Fatalf("daily km = %v, want multi-day gap delta", candidate.DailyKM)
}
if err := mock.ExpectationsWereMet(); err != nil {
t.Fatalf("sql expectations: %v", err)
}
}
func TestWriterApplyRealtimeBaselineRejectsHistoricalBaselineJump(t *testing.T) {
db, mock, err := sqlmock.New()
if err != nil {
t.Fatalf("sqlmock.New() error = %v", err)
}
defer db.Close()
loc := time.FixedZone("Asia/Shanghai", 8*3600)
writer := NewWriter(db, loc)
baselineTime := time.Date(2026, 7, 3, 19, 0, 39, 0, loc)
currentTime := time.Date(2026, 7, 12, 10, 44, 56, 0, loc)
candidate := SourceMileageSample{
VIN: "LNXNEGRR6SR319464",
StatDate: "2026-07-12",
Protocol: envelope.ProtocolGB32960,
SourceKey: "GB32960:unknown@8.134.95.166",
SourceIP: "8.134.95.166",
LatestTotalKM: 40009.7,
LatestEventTime: currentTime,
}
mock.ExpectQuery(`SELECT latest_total_mileage_km, latest_event_time FROM vehicle_daily_mileage_source`).
WithArgs("LNXNEGRR6SR319464", "2026-07-12", "GB32960", "GB32960:unknown@8.134.95.166").
WillReturnRows(sqlmock.NewRows([]string{"latest_total_mileage_km", "latest_event_time"}).
AddRow(10009.7, baselineTime))
if err := writer.applyRealtimeBaseline(context.Background(), &candidate); err != nil {
t.Fatalf("applyRealtimeBaseline() error = %v", err)
}
if candidate.QualityStatus != QualityInvalidDelta || candidate.QualityReason != "outside_daily_range" {
t.Fatalf("quality = %s/%s", candidate.QualityStatus, candidate.QualityReason)
}
if candidate.DailyKM < 29999.9 || candidate.DailyKM > 30000.1 {
t.Fatalf("daily km = %v, want historical jump delta", candidate.DailyKM)
}
if candidate.FirstTotalKM != 10009.7 || !candidate.FirstEventTime.Equal(baselineTime) {
t.Fatalf("previous-day baseline not preserved: %#v", candidate)
}
if err := mock.ExpectationsWereMet(); err != nil {
t.Fatalf("sql expectations: %v", err)
}
}
func TestWriterAppendMarksCandidateNoPreviousBaselineWhenPreviousBaselineMissing(t *testing.T) {
db, mock, err := sqlmock.New()
if err != nil {
t.Fatalf("sqlmock.New() error = %v", err)
}
defer db.Close()
loc := time.FixedZone("Asia/Shanghai", 8*3600)
writer := NewWriter(db, loc)
currentTime := time.Date(2026, 7, 8, 15, 56, 0, 0, loc)
event := managedTestSource(envelope.FrameEnvelope{
Protocol: envelope.ProtocolJT808,
VIN: "LA9GG64L7PBAF4001",
Phone: "13307765812",
SourceEndpoint: "115.231.168.135:20215",
EventTimeMS: currentTime.UnixMilli(),
Fields: map[string]any{
"jt808.location.total_mileage_km": 4136.8,
},
})
mock.ExpectExec(`INSERT INTO vehicle_data_source`).
WithArgs("JT808", "115.231.168.135", "115.231.168.135:20215", sqlmock.AnyArg(), sqlmock.AnyArg(), sqlmock.AnyArg(), sqlmock.AnyArg(), sqlmock.AnyArg()).
WillReturnResult(sqlmock.NewResult(0, 1))
mock.ExpectQuery(`SELECT latest_total_mileage_km, latest_event_time FROM vehicle_daily_mileage_source`).
WithArgs("LA9GG64L7PBAF4001", "2026-07-08", "JT808", "JT808:13307765812@115.231.168.135").
WillReturnRows(sqlmock.NewRows([]string{"latest_total_mileage_km", "latest_event_time"}))
mock.ExpectBegin()
mock.ExpectExec(`INSERT INTO vehicle_daily_mileage_source`).
WithArgs(
"LA9GG64L7PBAF4001",
"2026-07-08",
"JT808",
"JT808:13307765812@115.231.168.135",
"115.231.168.135",
"115.231.168.135:20215",
"13307765812",
"",
"",
float64(4136.8),
float64(4136.8),
float64(0),
int64(1),
currentTime,
currentTime,
QualityOK,
QualityReasonCurrentDayFirst,
).
WillReturnResult(sqlmock.NewResult(0, 1))
mock.ExpectExec(`INSERT INTO vehicle_daily_mileage`).
WithArgs("LA9GG64L7PBAF4001", "2026-07-08", "JT808", int64(maxSelectedDailyMileageKM)).
WillReturnResult(sqlmock.NewResult(0, 1))
mock.ExpectExec(`UPDATE vehicle_daily_mileage_source s`).
WithArgs(
"LA9GG64L7PBAF4001",
"2026-07-08",
"JT808",
int64(maxSelectedDailyMileageKM),
"LA9GG64L7PBAF4001",
"2026-07-08",
"JT808",
).
WillReturnResult(sqlmock.NewResult(0, 1))
mock.ExpectExec(`DELETE FROM vehicle_daily_mileage`).
WithArgs(
"LA9GG64L7PBAF4001",
"2026-07-08",
"JT808",
"LA9GG64L7PBAF4001",
"2026-07-08",
"JT808",
).
WillReturnResult(sqlmock.NewResult(0, 0))
mock.ExpectCommit()
if err := writer.Append(context.Background(), event); err != nil {
t.Fatalf("Append() error = %v", err)
}
if err := mock.ExpectationsWereMet(); err != nil {
t.Fatalf("sql expectations: %v", err)
}
}
func TestWriterEnsuresSchemaAndUpsertsDailyMileage(t *testing.T) {
exec := &recordingExec{}
writer := NewWriter(exec, time.FixedZone("Asia/Shanghai", 8*3600))
if err := writer.EnsureSchema(context.Background()); err != nil {
t.Fatalf("EnsureSchema() error = %v", err)
}
if err := writer.Append(context.Background(), managedTestSource(envelope.FrameEnvelope{
Protocol: envelope.ProtocolGB32960,
VIN: "LNBVIN00000000002",
Phone: "13307765812",
SourceEndpoint: "115.231.168.135:20215",
EventTimeMS: time.Date(2026, 7, 1, 9, 0, 0, 0, time.FixedZone("Asia/Shanghai", 8*3600)).UnixMilli(),
Fields: map[string]any{
"gb32960.vehicle.total_mileage_km": "10000.0",
},
})); err != nil {
t.Fatalf("Append() error = %v", err)
}
schemaCalls := 4 + len(DailyMileageAlterSQL)
if len(exec.calls) != schemaCalls+5 {
t.Fatalf("exec calls = %d", len(exec.calls))
}
for i, want := range []string{
"CREATE TABLE IF NOT EXISTS vehicle_data_source",
"CREATE TABLE IF NOT EXISTS vehicle_daily_gps_mileage_state",
"CREATE TABLE IF NOT EXISTS vehicle_daily_mileage_source",
"CREATE TABLE IF NOT EXISTS vehicle_daily_mileage",
} {
if !strings.Contains(exec.calls[i].query, want) {
t.Fatalf("schema call %d = %s, want %s", i, exec.calls[i].query, want)
}
}
for _, column := range []string{"vehicle_key", "AUTO_INCREMENT", "created_at", "first_total_mileage_km", "trusted_source_key", "trusted_phone", "trusted_source_endpoint", "sample_count"} {
if strings.Contains(exec.calls[3].query, column) {
t.Fatalf("schema should not include %s: %s", column, exec.calls[3].query)
}
}
for _, column := range []string{"source_id BIGINT NULL", "daily_mileage_km", "latest_total_mileage_km", "KEY idx_source_id (source_id)"} {
if !strings.Contains(exec.calls[3].query, column) {
t.Fatalf("schema should include %s: %s", column, exec.calls[3].query)
}
}
if !strings.Contains(exec.calls[3].query, "PRIMARY KEY (vin, stat_date, protocol)") {
t.Fatalf("daily mileage table should key by vin/stat_date/protocol: %s", exec.calls[3].query)
}
if strings.Contains(exec.calls[3].query, "KEY idx_vin (vin)") {
t.Fatalf("daily mileage table should not keep redundant vin index covered by the primary key: %s", exec.calls[3].query)
}
projectCall := exec.calls[schemaCalls+2]
if !strings.Contains(projectCall.query, "INSERT INTO vehicle_daily_mileage") {
t.Fatalf("unexpected project sql: %s", projectCall.query)
}
if !strings.Contains(projectCall.query, "ON DUPLICATE KEY UPDATE") {
t.Fatalf("unexpected upsert sql: %s", projectCall.query)
}
if strings.Contains(projectCall.query, "metric_key") || strings.Contains(projectCall.query, "metric_unit") {
t.Fatalf("daily mileage upsert should not use generic metric columns: %s", projectCall.query)
}
if !strings.Contains(projectCall.query, "JOIN vehicle_data_source ds") {
t.Fatalf("project sql should join data source: %s", projectCall.query)
}
if !strings.Contains(projectCall.query, "ds.id") {
t.Fatalf("project sql should write source id: %s", projectCall.query)
}
for _, forbidden := range []string{"trusted_source_key", "trusted_phone", "trusted_source_endpoint", "first_total_mileage_km"} {
if strings.Contains(projectCall.query, forbidden) {
t.Fatalf("project sql should not write final-table field %q: %s", forbidden, projectCall.query)
}
}
if got := projectCall.args[0]; got != "LNBVIN00000000002" {
t.Fatalf("first upsert arg should be vin, got %#v", got)
}
if !strings.Contains(exec.calls[schemaCalls].query, "INSERT INTO vehicle_data_source") {
t.Fatalf("source upsert query missing: %s", exec.calls[schemaCalls].query)
}
if !strings.Contains(exec.calls[schemaCalls+1].query, "INSERT INTO vehicle_daily_mileage_source") {
t.Fatalf("candidate upsert query missing: %s", exec.calls[schemaCalls+1].query)
}
}
func TestWriterAppendWithResultReportsProjectionThrottle(t *testing.T) {
exec := &recordingExec{}
loc := time.FixedZone("Asia/Shanghai", 8*3600)
writer := NewWriter(exec, loc)
base := managedTestSource(envelope.FrameEnvelope{
Protocol: envelope.ProtocolJT808,
VIN: "LA9GG64L7PBAF4001",
Phone: "13307765812",
SourceEndpoint: "115.231.168.135:20215",
Fields: map[string]any{
"jt808.location.total_mileage_km": 4123.9,
},
})
first := base
first.EventTimeMS = time.Date(2026, 7, 8, 13, 20, 0, 0, loc).UnixMilli()
firstResult, err := writer.AppendWithResult(context.Background(), first)
if err != nil {
t.Fatalf("first AppendWithResult() error = %v", err)
}
if firstResult.ProjectionsAttempted != 1 || firstResult.ProjectionsWritten != 1 || firstResult.ProjectionsSkippedThrottled != 0 {
t.Fatalf("first projection result = %+v", firstResult)
}
second := base
second.EventTimeMS = time.Date(2026, 7, 8, 13, 20, 5, 0, loc).UnixMilli()
second.Fields = map[string]any{"jt808.location.total_mileage_km": 4124.2}
secondResult, err := writer.AppendWithResult(context.Background(), second)
if err != nil {
t.Fatalf("second AppendWithResult() error = %v", err)
}
if secondResult.SamplesWritten != 1 || secondResult.ProjectionsAttempted != 0 || secondResult.ProjectionsWritten != 0 || secondResult.ProjectionsSkippedThrottled != 1 {
t.Fatalf("second projection result = %+v, want source write with throttled final projection", secondResult)
}
if secondResult.SourceTouchesSkippedThrottled != 1 || secondResult.SourceTouchesWritten != 0 {
t.Fatalf("second source result = %+v, want source touch throttled", secondResult)
}
third := base
third.EventTimeMS = time.Date(2026, 7, 8, 13, 20, 16, 0, loc).UnixMilli()
third.Fields = map[string]any{"jt808.location.total_mileage_km": 4125.0}
thirdResult, err := writer.AppendWithResult(context.Background(), third)
if err != nil {
t.Fatalf("third AppendWithResult() error = %v", err)
}
if thirdResult.ProjectionsAttempted != 1 || thirdResult.ProjectionsWritten != 1 || thirdResult.ProjectionsSkippedThrottled != 0 {
t.Fatalf("third projection result = %+v", thirdResult)
}
}
func TestWriterSkipsConsecutiveDuplicateMileageSamples(t *testing.T) {
exec := &recordingExec{}
writer := NewWriter(exec, time.FixedZone("Asia/Shanghai", 8*3600))
event := managedTestSource(envelope.FrameEnvelope{
Protocol: envelope.ProtocolJT808,
VIN: "LNBVIN00000000001",
SourceEndpoint: "115.231.168.135:20215",
EventTimeMS: time.Date(2026, 7, 1, 9, 0, 0, 0, time.FixedZone("Asia/Shanghai", 8*3600)).UnixMilli(),
Fields: map[string]any{
"jt808.location.total_mileage_km": 10241.2,
},
})
if err := writer.Append(context.Background(), event); err != nil {
t.Fatalf("first Append() error = %v", err)
}
event.ReceivedAtMS += 1000
if err := writer.Append(context.Background(), event); err != nil {
t.Fatalf("duplicate Append() error = %v", err)
}
if len(exec.calls) != 5 {
t.Fatalf("exec calls = %d, want 5", len(exec.calls))
}
}
func TestWriterCarriesPreviousYutongMileageIntoStationaryDay(t *testing.T) {
exec := &recordingExec{}
loc := time.FixedZone("Asia/Shanghai", 8*3600)
writer := NewWriter(exec, loc)
eventTime := time.Date(2026, 7, 19, 6, 5, 42, 0, loc)
previousTime := time.Date(2026, 7, 18, 16, 48, 10, 0, loc)
vin := "LMRKH9AC9R1004099"
sourceKey := "YUTONG_MQTT:" + vin + "@PLATFORM:yutong"
sample := MetricSample{
VIN: vin,
Protocol: envelope.ProtocolYutongMQTT,
StatDate: "2026-07-19",
SourceKey: sourceKey,
}
writer.baselineCache[mileageCacheKey(sample)] = sourceBaselineCacheEntry{
baseline: sourceBaseline{
LatestTotalKM: 24245,
LatestEventTime: previousTime,
QualityReason: QualityReasonHistorical,
},
found: true,
cachedAt: time.Now(),
}
event := managedTestSource(envelope.FrameEnvelope{
Protocol: envelope.ProtocolYutongMQTT,
VIN: vin,
DeviceID: vin,
SourceEndpoint: "mqtt://yutong/ytforward/shln/2",
SourceCode: "yutong",
PlatformName: "宇通",
EventTimeMS: eventTime.UnixMilli(),
ReceivedAtMS: eventTime.UnixMilli(),
Fields: map[string]any{
"yutong_mqtt.data.latitude": "30.645438",
"yutong_mqtt.data.longitude": "114.435672",
"yutong_mqtt.data.meter_speed": "0",
},
})
result, err := writer.AppendWithResult(context.Background(), event)
if err != nil {
t.Fatalf("AppendWithResult() error = %v", err)
}
if result.SamplesRecoveredStationary != 1 || result.SamplesWritten != 1 || result.ProjectionsWritten != 1 {
t.Fatalf("stationary carry result = %+v", result)
}
if result.SamplesSkippedMissingMileage != 1 {
t.Fatalf("source-data evidence must retain the missing-mileage counter: %+v", result)
}
if len(exec.calls) != 7 {
t.Fatalf("exec calls = %d, want source touch plus six mileage writes", len(exec.calls))
}
sourceWrite := exec.calls[1]
if !strings.Contains(sourceWrite.query, "INSERT INTO vehicle_daily_mileage_source") {
t.Fatalf("source mileage write missing: %s", sourceWrite.query)
}
if got := sourceWrite.args[9]; got != float64(24245) {
t.Fatalf("first total mileage = %#v, want carried 24245", got)
}
if got := sourceWrite.args[10]; got != float64(24245) {
t.Fatalf("latest total mileage = %#v, want carried 24245", got)
}
if got := sourceWrite.args[11]; got != float64(0) {
t.Fatalf("daily mileage = %#v, want explicit zero", got)
}
if got := sourceWrite.args[16]; got != QualityReasonStationaryCarry {
t.Fatalf("quality reason = %#v, want %q", got, QualityReasonStationaryCarry)
}
}
func TestWriterDoesNotCarryMileageForMovingYutongFrame(t *testing.T) {
exec := &recordingExec{}
loc := time.FixedZone("Asia/Shanghai", 8*3600)
writer := NewWriter(exec, loc)
eventTime := time.Date(2026, 7, 19, 8, 0, 0, 0, loc)
event := managedTestSource(envelope.FrameEnvelope{
Protocol: envelope.ProtocolYutongMQTT,
VIN: "LMRKH9AC9R1004099",
DeviceID: "LMRKH9AC9R1004099",
SourceEndpoint: "mqtt://yutong/ytforward/shln/2",
SourceCode: "yutong",
EventTimeMS: eventTime.UnixMilli(),
Fields: map[string]any{
"yutong_mqtt.data.latitude": "30.645438",
"yutong_mqtt.data.longitude": "114.435672",
"yutong_mqtt.data.meter_speed": "12",
},
})
result, err := writer.AppendWithResult(context.Background(), event)
if err != nil {
t.Fatalf("AppendWithResult() error = %v", err)
}
if result.SamplesRecoveredStationary != 0 || result.SamplesWritten != 0 || result.SamplesSkippedMissingMileage != 1 {
t.Fatalf("moving frame must remain missing-mileage evidence: %+v", result)
}
if len(exec.calls) != 1 || !strings.Contains(exec.calls[0].query, "INSERT INTO vehicle_data_source") {
t.Fatalf("moving frame writes = %+v, want source touch only", exec.calls)
}
}
func TestWriterAppendWithResultReportsDuplicateMileage(t *testing.T) {
exec := &recordingExec{}
writer := NewWriter(exec, time.FixedZone("Asia/Shanghai", 8*3600))
event := managedTestSource(envelope.FrameEnvelope{
Protocol: envelope.ProtocolJT808,
VIN: "LNBVIN00000000001",
SourceEndpoint: "115.231.168.135:20215",
EventTimeMS: time.Date(2026, 7, 1, 9, 0, 0, 0, time.FixedZone("Asia/Shanghai", 8*3600)).UnixMilli(),
Fields: map[string]any{
"jt808.location.total_mileage_km": 10241.2,
},
})
if _, err := writer.AppendWithResult(context.Background(), event); err != nil {
t.Fatalf("first AppendWithResult() error = %v", err)
}
event.ReceivedAtMS += 1000
result, err := writer.AppendWithResult(context.Background(), event)
if err != nil {
t.Fatalf("duplicate AppendWithResult() error = %v", err)
}
if result.SamplesFound != 1 || result.SamplesSkippedSameMileage != 1 || result.SamplesWritten != 0 {
t.Fatalf("result = %+v, want duplicate mileage skipped", result)
}
if result.SourceTouchesSkippedThrottled != 1 || result.SourceTouchesWritten != 0 {
t.Fatalf("source touch result = %+v, want duplicate to throttle source touch", result)
}
if len(exec.calls) != 5 {
t.Fatalf("exec calls = %d, want duplicate to avoid mysql writes", len(exec.calls))
}
}
func TestWriterDuplicateYutongOdometerStillEntersGPSFallback(t *testing.T) {
db, mock, err := sqlmock.New()
if err != nil {
t.Fatalf("sqlmock.New() error = %v", err)
}
defer db.Close()
loc := time.FixedZone("Asia/Shanghai", 8*3600)
writer := NewWriter(db, loc)
eventTime := time.Date(2026, 7, 19, 8, 0, 0, 0, loc)
event := managedTestSource(envelope.FrameEnvelope{
EventID: "evt-yutong-stale-odometer",
Protocol: envelope.ProtocolYutongMQTT,
VIN: "LMRKH9AC9R1004099",
DeviceID: "LMRKH9AC9R1004099",
SourceEndpoint: "mqtt://yutong/ytforward/shln/2",
EventTimeMS: eventTime.UnixMilli(),
Fields: map[string]any{
"yutong_mqtt.data.total_mileage": 24245000,
"yutong_mqtt.data.longitude": 114.435672,
"yutong_mqtt.data.latitude": 30.645438,
"yutong_mqtt.data.meter_speed": 18,
},
})
samples, _, err := samplesFromEnvelopeWithResult(event, loc)
if err != nil || len(samples) != 1 {
t.Fatalf("samplesFromEnvelopeWithResult() samples=%+v err=%v", samples, err)
}
identity, ok := NewSourceIdentityFromEnvelope(event)
if !ok {
t.Fatal("expected managed Yutong source identity")
}
writer.markSourceTouched(identity, eventTime)
writer.markMileageWritten(samples[0])
mock.ExpectBegin()
mock.ExpectQuery(`SELECT first_event_time, latest_event_time`).
WillReturnRows(sqlmock.NewRows([]string{
"first_event_time", "latest_event_time", "latest_event_id",
"latest_longitude", "latest_latitude", "daily_mileage_km",
"point_count", "usable_segment_count", "bad_jump_count",
"long_gap_count", "out_of_order_count",
}).AddRow(eventTime.Add(-20*time.Second), eventTime.Add(-20*time.Second), "evt-before", 114.434672, 30.645438, 0, 1, 0, 0, 0, 0))
mock.ExpectExec(`UPDATE vehicle_daily_gps_mileage_state`).
WillReturnResult(sqlmock.NewResult(0, 1))
mock.ExpectExec(`INSERT INTO vehicle_daily_mileage_source`).
WillReturnResult(sqlmock.NewResult(0, 1))
mock.ExpectExec(`INSERT INTO vehicle_daily_mileage`).
WillReturnResult(sqlmock.NewResult(0, 1))
mock.ExpectExec(`UPDATE vehicle_daily_mileage_source`).
WillReturnResult(sqlmock.NewResult(0, 1))
mock.ExpectExec(`DELETE FROM vehicle_daily_mileage`).
WillReturnResult(sqlmock.NewResult(0, 0))
mock.ExpectCommit()
result, err := writer.AppendWithResult(context.Background(), event)
if err != nil {
t.Fatalf("AppendWithResult() error = %v", err)
}
if result.SamplesFound != 1 || result.SamplesSkippedSameMileage != 1 ||
result.SamplesRecoveredGPSCoordinate != 1 || result.SamplesWritten != 1 ||
result.ProjectionsAttempted != 1 || result.ProjectionsWritten != 1 {
t.Fatalf("duplicate odometer evidence = %+v", result)
}
if got := writer.CacheStats().GPSAccumulationEntries; got != 1 {
t.Fatalf("GPS accumulation entries = %d, want stale moving odometer to enter fallback", got)
}
if err := mock.ExpectationsWereMet(); err != nil {
t.Fatalf("unmet SQL expectations: %v", err)
}
}
func TestWriterDoesNotCacheMileageWhenUpsertFails(t *testing.T) {
exec := &recordingExec{errs: []error{errors.New("mysql unavailable"), nil}}
writer := NewWriter(exec, time.FixedZone("Asia/Shanghai", 8*3600))
event := managedTestSource(envelope.FrameEnvelope{
Protocol: envelope.ProtocolJT808,
VIN: "LNBVIN00000000001",
SourceEndpoint: "115.231.168.135:20215",
EventTimeMS: time.Date(2026, 7, 1, 9, 0, 0, 0, time.FixedZone("Asia/Shanghai", 8*3600)).UnixMilli(),
Fields: map[string]any{
"jt808.location.total_mileage_km": 10241.2,
},
})
if err := writer.Append(context.Background(), event); err == nil {
t.Fatalf("first Append() error = nil, want mysql error")
}
if err := writer.Append(context.Background(), event); err != nil {
t.Fatalf("retry Append() error = %v", err)
}
if len(exec.calls) != 6 {
t.Fatalf("exec calls = %d, want 6", len(exec.calls))
}
}
func TestWriterRollsBackMileageTransactionWhenProjectionFails(t *testing.T) {
db, mock, err := sqlmock.New()
if err != nil {
t.Fatalf("sqlmock.New() error = %v", err)
}
defer db.Close()
loc := time.FixedZone("Asia/Shanghai", 8*3600)
writer := NewWriter(db, loc)
eventTime := time.Date(2026, 7, 8, 9, 30, 0, 0, loc)
event := managedTestSource(envelope.FrameEnvelope{
Protocol: envelope.ProtocolJT808,
VIN: "LA9GG64L7PBAF4001",
Phone: "13307765812",
SourceEndpoint: "115.231.168.135:20215",
EventTimeMS: eventTime.UnixMilli(),
Fields: map[string]any{
"jt808.location.total_mileage_km": 4123.9,
},
})
wantErr := errors.New("project final mileage failed")
mock.ExpectExec(`INSERT INTO vehicle_data_source`).
WithArgs("JT808", "115.231.168.135", "115.231.168.135:20215", sqlmock.AnyArg(), sqlmock.AnyArg(), sqlmock.AnyArg(), sqlmock.AnyArg(), sqlmock.AnyArg()).
WillReturnResult(sqlmock.NewResult(0, 1))
mock.ExpectQuery(`SELECT latest_total_mileage_km, latest_event_time FROM vehicle_daily_mileage_source`).
WithArgs("LA9GG64L7PBAF4001", "2026-07-08", "JT808", "JT808:13307765812@115.231.168.135").
WillReturnRows(sqlmock.NewRows([]string{"latest_total_mileage_km", "latest_event_time"}))
mock.ExpectBegin()
mock.ExpectExec(`INSERT INTO vehicle_daily_mileage_source`).
WithArgs(
"LA9GG64L7PBAF4001",
"2026-07-08",
"JT808",
"JT808:13307765812@115.231.168.135",
"115.231.168.135",
"115.231.168.135:20215",
"13307765812",
"",
"",
float64(4123.9),
float64(4123.9),
float64(0),
int64(1),
eventTime,
eventTime,
QualityOK,
QualityReasonCurrentDayFirst,
).
WillReturnResult(sqlmock.NewResult(0, 1))
mock.ExpectExec(`INSERT INTO vehicle_daily_mileage`).
WithArgs("LA9GG64L7PBAF4001", "2026-07-08", "JT808", int64(maxSelectedDailyMileageKM)).
WillReturnError(wantErr)
mock.ExpectRollback()
err = writer.Append(context.Background(), event)
if !errors.Is(err, wantErr) {
t.Fatalf("Append() error = %v, want %v", err, wantErr)
}
if err := mock.ExpectationsWereMet(); err != nil {
t.Fatalf("sql expectations: %v", err)
}
writer.mu.Lock()
defer writer.mu.Unlock()
if len(writer.lastTotalMileage) != 0 || len(writer.lastProjection) != 0 {
t.Fatalf("writer cache should not mark failed sample, mileage=%d projection=%d", len(writer.lastTotalMileage), len(writer.lastProjection))
}
}
func TestWriterKeepsOnlyLatestDateInMileageCache(t *testing.T) {
exec := &recordingExec{}
writer := NewWriter(exec, time.FixedZone("Asia/Shanghai", 8*3600))
event := managedTestSource(envelope.FrameEnvelope{
Protocol: envelope.ProtocolJT808,
VIN: "LNBVIN00000000001",
SourceEndpoint: "115.231.168.135:20215",
Fields: map[string]any{
"jt808.location.total_mileage_km": 10241.2,
},
})
event.EventTimeMS = time.Date(2026, 7, 1, 23, 59, 0, 0, time.FixedZone("Asia/Shanghai", 8*3600)).UnixMilli()
if err := writer.Append(context.Background(), event); err != nil {
t.Fatalf("first Append() error = %v", err)
}
event.EventTimeMS = time.Date(2026, 7, 2, 0, 1, 0, 0, time.FixedZone("Asia/Shanghai", 8*3600)).UnixMilli()
if err := writer.Append(context.Background(), event); err != nil {
t.Fatalf("next-day Append() error = %v", err)
}
if len(exec.calls) != 10 {
t.Fatalf("exec calls = %d, want 10", len(exec.calls))
}
if len(writer.lastTotalMileage) != 1 {
t.Fatalf("cache entries = %d, want 1", len(writer.lastTotalMileage))
}
}
func TestWriterCacheLimitEvictsOldestEntries(t *testing.T) {
loc := time.FixedZone("Asia/Shanghai", 8*3600)
writer := NewWriter(&recordingExec{}, loc)
writer.SetMaxCacheEntries(2)
samples := []struct {
sample MetricSample
sourceIP string
}{
{sample: MetricSample{VIN: "VIN00000000000001", Protocol: envelope.ProtocolJT808, StatDate: "2026-07-01", SourceKey: "JT808:a@115.231.168.135", EventTime: time.Date(2026, 7, 1, 8, 0, 0, 0, loc)}, sourceIP: "115.231.168.135"},
{sample: MetricSample{VIN: "VIN00000000000002", Protocol: envelope.ProtocolJT808, StatDate: "2026-07-02", SourceKey: "JT808:b@115.231.168.136", EventTime: time.Date(2026, 7, 2, 8, 0, 0, 0, loc)}, sourceIP: "115.231.168.136"},
{sample: MetricSample{VIN: "VIN00000000000003", Protocol: envelope.ProtocolJT808, StatDate: "2026-07-03", SourceKey: "JT808:c@115.231.168.137", EventTime: time.Date(2026, 7, 3, 8, 0, 0, 0, loc)}, sourceIP: "115.231.168.137"},
}
for index, item := range samples {
sample := item.sample
sample.TotalMileageKM = float64(100 + index)
writer.markMileageWritten(sample)
writer.markProjected(sample)
writer.markSourceTouched(SourceIdentity{
Protocol: sample.Protocol,
SourceIP: item.sourceIP,
SourceEndpoint: item.sourceIP + ":20215",
}, sample.EventTime)
writer.mu.Lock()
writer.baselineCache[mileageCacheKey(sample)] = sourceBaselineCacheEntry{found: true, baseline: sourceBaseline{LatestTotalKM: sample.TotalMileageKM, LatestEventTime: sample.EventTime}}
writer.addCacheKeyLocked(writer.baselineKeysByPrefix, mileageCachePrefix(sample), mileageCacheKey(sample))
writer.enforceCacheLimitsLocked()
writer.mu.Unlock()
}
stats := writer.CacheStats()
if stats.MaxEntries != 2 {
t.Fatalf("max entries = %d, want 2", stats.MaxEntries)
}
if stats.LastTotalMileageEntries != 2 ||
stats.LastProjectionEntries != 2 ||
stats.LastSourceSeenEntries != 2 ||
stats.BaselineEntries != 2 {
t.Fatalf("cache entries = %+v, want each cache capped at 2", stats)
}
if stats.TotalMileageEvictions == 0 ||
stats.ProjectionEvictions == 0 ||
stats.SourceSeenEvictions == 0 ||
stats.BaselineEvictions == 0 {
t.Fatalf("cache evictions = %+v, want all caches to evict", stats)
}
if _, ok := writer.lastTotalMileage[mileageCacheKey(samples[0].sample)]; ok {
t.Fatalf("oldest mileage cache key was not evicted")
}
if _, ok := writer.lastProjection[projectionCacheKey(samples[0].sample)]; ok {
t.Fatalf("oldest projection cache key was not evicted")
}
if _, ok := writer.baselineCache[mileageCacheKey(samples[0].sample)]; ok {
t.Fatalf("oldest baseline cache key was not evicted")
}
if _, ok := writer.lastSourceSeen["JT808|115.231.168.135"]; ok {
t.Fatalf("oldest source touch cache key was not evicted")
}
}
func TestWriterCleanupCachesDropsExpiredVehicleState(t *testing.T) {
loc := time.FixedZone("Asia/Shanghai", 8*3600)
writer := NewWriter(&recordingExec{}, loc)
writer.SetCacheRetention(48 * time.Hour)
writer.SetCacheCleanupInterval(0)
oldSample := MetricSample{
VIN: "OLDVIN00000000001",
Protocol: envelope.ProtocolJT808,
StatDate: "2026-07-01",
SourceKey: "JT808:old@115.231.168.135",
EventTime: time.Date(2026, 7, 1, 12, 0, 0, 0, loc),
}
currentSample := MetricSample{
VIN: "NEWVIN00000000001",
Protocol: envelope.ProtocolJT808,
StatDate: "2026-07-04",
SourceKey: "JT808:new@115.231.168.136",
EventTime: time.Date(2026, 7, 4, 12, 0, 0, 0, loc),
}
oldMileageKey := mileageCacheKey(oldSample)
currentMileageKey := mileageCacheKey(currentSample)
oldProjectionKey := projectionCacheKey(oldSample)
currentProjectionKey := projectionCacheKey(currentSample)
writer.lastTotalMileage[oldMileageKey] = 100
writer.lastTotalMileage[currentMileageKey] = 200
writer.baselineCache[oldMileageKey] = sourceBaselineCacheEntry{found: true}
writer.baselineCache[currentMileageKey] = sourceBaselineCacheEntry{found: true}
writer.lastProjection[oldProjectionKey] = projectionCacheEntry{projectedAt: oldSample.EventTime, sourceKeys: map[string]struct{}{oldSample.SourceKey: {}}}
writer.lastProjection[currentProjectionKey] = projectionCacheEntry{projectedAt: currentSample.EventTime, sourceKeys: map[string]struct{}{currentSample.SourceKey: {}}}
writer.lastSourceSeen["JT808|115.231.168.135"] = oldSample.EventTime
writer.lastSourceSeen["JT808|115.231.168.136"] = currentSample.EventTime
writer.maybeCleanupCaches(time.Date(2026, 7, 4, 12, 1, 0, 0, loc))
if _, ok := writer.lastTotalMileage[oldMileageKey]; ok {
t.Fatalf("expired mileage cache key was not removed")
}
if _, ok := writer.baselineCache[oldMileageKey]; ok {
t.Fatalf("expired baseline cache key was not removed")
}
if _, ok := writer.lastProjection[oldProjectionKey]; ok {
t.Fatalf("expired projection cache key was not removed")
}
if _, ok := writer.lastSourceSeen["JT808|115.231.168.135"]; ok {
t.Fatalf("expired source touch cache key was not removed")
}
if _, ok := writer.lastTotalMileage[currentMileageKey]; !ok {
t.Fatalf("current mileage cache key was removed")
}
if _, ok := writer.baselineCache[currentMileageKey]; !ok {
t.Fatalf("current baseline cache key was removed")
}
if _, ok := writer.lastProjection[currentProjectionKey]; !ok {
t.Fatalf("current projection cache key was removed")
}
if _, ok := writer.lastSourceSeen["JT808|115.231.168.136"]; !ok {
t.Fatalf("current source touch cache key was removed")
}
stats := writer.CacheStats()
if stats.LastTotalMileageEntries != 1 ||
stats.BaselineEntries != 1 ||
stats.LastProjectionEntries != 1 ||
stats.LastSourceSeenEntries != 1 {
t.Fatalf("cache stats entries = %+v, want one current entry in each cache", stats)
}
if stats.LastCleanupTotalMileage != 1 ||
stats.LastCleanupBaseline != 1 ||
stats.LastCleanupProjection != 1 ||
stats.LastCleanupSourceSeen != 1 {
t.Fatalf("cache cleanup stats = %+v, want one deleted from each cache", stats)
}
if !stats.LastCleanupAt.Equal(time.Date(2026, 7, 4, 12, 1, 0, 0, loc)) {
t.Fatalf("last cleanup at = %s", stats.LastCleanupAt)
}
}
func TestWriterCleanupCachesCanBeDisabled(t *testing.T) {
loc := time.FixedZone("Asia/Shanghai", 8*3600)
writer := NewWriter(&recordingExec{}, loc)
writer.SetCacheRetention(0)
writer.SetCacheCleanupInterval(0)
oldSample := MetricSample{
VIN: "OLDVIN00000000001",
Protocol: envelope.ProtocolJT808,
StatDate: "2026-07-01",
SourceKey: "JT808:old@115.231.168.135",
EventTime: time.Date(2026, 7, 1, 12, 0, 0, 0, loc),
}
key := mileageCacheKey(oldSample)
writer.lastTotalMileage[key] = 100
writer.baselineCache[key] = sourceBaselineCacheEntry{found: true}
writer.lastProjection[projectionCacheKey(oldSample)] = projectionCacheEntry{projectedAt: oldSample.EventTime}
writer.lastSourceSeen["JT808|115.231.168.135"] = oldSample.EventTime
writer.maybeCleanupCaches(time.Date(2026, 7, 10, 12, 0, 0, 0, loc))
if len(writer.lastTotalMileage) != 1 || len(writer.baselineCache) != 1 || len(writer.lastProjection) != 1 || len(writer.lastSourceSeen) != 1 {
t.Fatalf("cache cleanup should be disabled, got mileage=%d baseline=%d projection=%d source=%d", len(writer.lastTotalMileage), len(writer.baselineCache), len(writer.lastProjection), len(writer.lastSourceSeen))
}
}
func countExecQueries(calls []execCall, fragment string) int {
count := 0
for _, call := range calls {
if strings.Contains(call.query, fragment) {
count++
}
}
return count
}
func TestWriterSupportsConcurrentPartitionConsumers(t *testing.T) {
loc := time.FixedZone("Asia/Shanghai", 8*3600)
exec := &concurrentExec{}
writer := NewWriter(exec, loc)
writer.SetSourceTouchInterval(0)
writer.SetProjectionInterval(0)
const workers = 32
var wait sync.WaitGroup
errorsCh := make(chan error, workers)
for index := 0; index < workers; index++ {
wait.Add(1)
go func(index int) {
defer wait.Done()
env := managedTestSource(envelope.FrameEnvelope{
Protocol: envelope.ProtocolJT808,
VIN: fmt.Sprintf("LNBVIN%011d", index),
Phone: fmt.Sprintf("13%09d", index),
MessageID: "0x0200",
SourceEndpoint: fmt.Sprintf("10.0.0.%d:808", index+1),
EventTimeMS: time.Date(2026, 7, 13, 8, 0, index, 0, loc).UnixMilli(),
ReceivedAtMS: time.Date(2026, 7, 13, 8, 0, index, 0, loc).UnixMilli(),
Fields: map[string]any{
"jt808.location.total_mileage_km": 1000 + float64(index),
},
})
result, err := writer.AppendWithResult(context.Background(), env)
if err != nil {
errorsCh <- err
return
}
if result.SamplesWritten != 1 {
errorsCh <- fmt.Errorf("worker %d samples written = %d", index, result.SamplesWritten)
}
}(index)
}
wait.Wait()
close(errorsCh)
for err := range errorsCh {
t.Fatal(err)
}
if exec.CallCount() == 0 {
t.Fatal("concurrent writers did not execute any MySQL statements")
}
}
type execCall struct {
query string
args []any
}
type recordingExec struct {
calls []execCall
errs []error
}
type selectiveFailingExec struct {
failVIN string
}
func (e *selectiveFailingExec) ExecContext(_ context.Context, _ string, args ...any) (sql.Result, error) {
if len(args) > 0 && fmt.Sprint(args[0]) == e.failVIN {
return nil, errors.New("test projection failure")
}
return nil, nil
}
type concurrentExec struct {
mu sync.Mutex
calls int
}
func (e *concurrentExec) ExecContext(_ context.Context, _ string, _ ...any) (sql.Result, error) {
e.mu.Lock()
e.calls++
e.mu.Unlock()
return nil, nil
}
func (e *concurrentExec) CallCount() int {
e.mu.Lock()
defer e.mu.Unlock()
return e.calls
}
func (e *recordingExec) ExecContext(_ context.Context, query string, args ...any) (sql.Result, error) {
e.calls = append(e.calls, execCall{query: query, args: args})
if len(e.errs) > 0 {
err := e.errs[0]
e.errs = e.errs[1:]
return nil, err
}
return nil, nil
}
type approxFloat64 struct {
want float64
tolerance float64
}
func (m approxFloat64) Match(value driver.Value) bool {
got, ok := value.(float64)
if !ok {
return false
}
return math.Abs(got-m.want) <= m.tolerance
}
Reference in New Issue View Git Blame Copy Permalink