701 lines
29 KiB
Go
701 lines
29 KiB
Go
package stats
|
|
|
|
import (
|
|
"context"
|
|
"database/sql"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/DATA-DOG/go-sqlmock"
|
|
)
|
|
|
|
const dataSourceSelectPattern = "SELECT id, protocol, source_ip, latest_source_endpoint, platform_name, source_code, source_kind, trust_priority, enabled, first_seen_at, latest_seen_at, remark, updated_at FROM vehicle_data_source"
|
|
|
|
func TestDataSourceRepositoryQueriesWithOperationalFilters(t *testing.T) {
|
|
db, mock, err := sqlmock.New()
|
|
if err != nil {
|
|
t.Fatalf("sqlmock.New() error = %v", err)
|
|
}
|
|
defer db.Close()
|
|
mock.ExpectQuery(dataSourceSelectPattern).
|
|
WithArgs("JT808", "115.231.168.135", "G7S", "PLATFORM", 1, 20, 10).
|
|
WillReturnRows(sqlmock.NewRows([]string{
|
|
"id", "protocol", "source_ip", "latest_source_endpoint", "platform_name", "source_code", "source_kind",
|
|
"trust_priority", "enabled", "first_seen_at", "latest_seen_at", "remark", "updated_at",
|
|
}).AddRow(
|
|
3, "JT808", "115.231.168.135", "115.231.168.135:41561", "G7 平台", "G7S", "PLATFORM",
|
|
10, 1,
|
|
time.Date(2026, 7, 8, 10, 0, 0, 0, time.FixedZone("Asia/Shanghai", 8*3600)),
|
|
time.Date(2026, 7, 12, 1, 16, 4, 0, time.FixedZone("Asia/Shanghai", 8*3600)),
|
|
"trusted source",
|
|
time.Date(2026, 7, 12, 1, 16, 5, 0, time.FixedZone("Asia/Shanghai", 8*3600)),
|
|
))
|
|
|
|
enabled := true
|
|
rows, err := NewDataSourceRepository(db).Query(context.Background(), DataSourceQuery{
|
|
Protocol: "jt808",
|
|
SourceIP: "115.231.168.135",
|
|
SourceCode: "G7S",
|
|
SourceKind: "platform",
|
|
Enabled: &enabled,
|
|
Limit: 20,
|
|
Offset: 10,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("Query() error = %v", err)
|
|
}
|
|
if len(rows) != 1 {
|
|
t.Fatalf("row count = %d", len(rows))
|
|
}
|
|
row := rows[0]
|
|
if row.ID != 3 || row.Protocol != "JT808" || row.PlatformName != "G7 平台" || row.SourceCode != "G7S" || row.SourceKind != "PLATFORM" || !row.Enabled {
|
|
t.Fatalf("unexpected source row: %#v", row)
|
|
}
|
|
if row.LatestSeenAt != "2026-07-12 01:16:04" {
|
|
t.Fatalf("latest seen = %q", row.LatestSeenAt)
|
|
}
|
|
if err := mock.ExpectationsWereMet(); err != nil {
|
|
t.Fatalf("sql expectations: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestDataSourceRepositoryFiltersMissingSourceCode(t *testing.T) {
|
|
db, mock, err := sqlmock.New()
|
|
if err != nil {
|
|
t.Fatalf("sqlmock.New() error = %v", err)
|
|
}
|
|
defer db.Close()
|
|
mock.ExpectQuery(dataSourceSelectPattern).
|
|
WithArgs("JT808", 50, 0).
|
|
WillReturnRows(sqlmock.NewRows([]string{
|
|
"id", "protocol", "source_ip", "latest_source_endpoint", "platform_name", "source_code", "source_kind",
|
|
"trust_priority", "enabled", "first_seen_at", "latest_seen_at", "remark", "updated_at",
|
|
}))
|
|
|
|
missing := true
|
|
_, err = NewDataSourceRepository(db).Query(context.Background(), DataSourceQuery{
|
|
Protocol: "JT808",
|
|
SourceCodeMissing: &missing,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("Query() error = %v", err)
|
|
}
|
|
if err := mock.ExpectationsWereMet(); err != nil {
|
|
t.Fatalf("sql expectations: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestDataSourceRepositoryDiagnosesJT808SourceMapping(t *testing.T) {
|
|
db, mock, err := sqlmock.New()
|
|
if err != nil {
|
|
t.Fatalf("sqlmock.New() error = %v", err)
|
|
}
|
|
defer db.Close()
|
|
mock.ExpectQuery("FROM vehicle_data_source ds").
|
|
WithArgs("JT808", "117.132.194.31", 1, 10, 0).
|
|
WillReturnRows(sqlmock.NewRows([]string{
|
|
"id", "protocol", "source_ip", "latest_source_endpoint", "platform_name", "source_code",
|
|
"source_kind", "first_seen_at", "latest_seen_at", "active_span_seconds", "latest_seen_age_seconds", "registration_rows", "phone_count", "unknown_vin_rows",
|
|
"identifier_matched_phones", "unmapped_phone_count", "identifier_match_ratio", "configured_source_code_matched_phones", "configured_source_code_platform_name", "matched_source_code_count", "candidate_source_code",
|
|
"candidate_platform_name", "matched_source_codes", "matched_platform_names", "sample_phones",
|
|
}).AddRow(
|
|
242190, "JT808", "117.132.194.31", "117.132.194.31:20471", nil, nil,
|
|
"UNKNOWN", "2026-07-11 23:00:00", "2026-07-12 01:36:26", 9386, 120,
|
|
5, 4, 2,
|
|
3, 1, 0.75, 0, nil, 2, "g7s", "G7s", "g7s,xinda", "G7s,信达", "13307795425,14400000000",
|
|
))
|
|
|
|
missing := true
|
|
rows, err := NewDataSourceRepository(db).QueryDiagnostics(context.Background(), DataSourceDiagnosticsQuery{
|
|
Protocol: "jt808",
|
|
SourceIP: "117.132.194.31",
|
|
SourceCodeMissing: &missing,
|
|
Limit: 10,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("QueryDiagnostics() error = %v", err)
|
|
}
|
|
if len(rows) != 1 {
|
|
t.Fatalf("row count = %d", len(rows))
|
|
}
|
|
row := rows[0]
|
|
if row.Reason != "ambiguous_source_code" || row.IdentifierMatchedPhones != 3 || len(row.MatchedSourceCodes) != 2 || len(row.SamplePhones) != 2 {
|
|
t.Fatalf("unexpected diagnostic row: %#v", row)
|
|
}
|
|
if row.SuggestedSourceKind != "UNKNOWN" || row.SuggestionConfidence != "HIGH" {
|
|
t.Fatalf("unexpected kind suggestion: %#v", row)
|
|
}
|
|
sqlText, _ := buildDataSourceDiagnosticsSQL(DataSourceDiagnosticsQuery{Protocol: "JT808", Limit: 10})
|
|
if !strings.Contains(sqlText, "ON ds.protocol = 'JT808'") || !strings.Contains(sqlText, "AND r.source_ip = ds.source_ip") {
|
|
t.Fatalf("diagnostics should join by indexed source_ip:\n%s", sqlText)
|
|
}
|
|
if err := mock.ExpectationsWereMet(); err != nil {
|
|
t.Fatalf("sql expectations: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestDataSourceDiagnosticsMappingIssueFilterUsesHaving(t *testing.T) {
|
|
missing := false
|
|
query := normalizeDataSourceDiagnosticsQuery(DataSourceDiagnosticsQuery{
|
|
Protocol: "JT808",
|
|
SourceCodeMissing: &missing,
|
|
MappingIssueOnly: true,
|
|
Limit: 10,
|
|
})
|
|
sqlText, args := buildDataSourceDiagnosticsSQL(query)
|
|
if !strings.Contains(sqlText, "HAVING") || !strings.Contains(sqlText, "identifier_match_ratio < 0.8") || !strings.Contains(sqlText, "configured_source_code_platform_name") {
|
|
t.Fatalf("mapping issue query should include aggregate HAVING:\n%s", sqlText)
|
|
}
|
|
if strings.Contains(sqlText, "ds.platform_name IS NOT NULL") {
|
|
t.Fatalf("mapping issue HAVING should use aggregate aliases, not table-qualified platform_name:\n%s", sqlText)
|
|
}
|
|
if len(args) != 4 {
|
|
t.Fatalf("mapping issue query args = %#v, want protocol/enabled/limit/offset", args)
|
|
}
|
|
countSQL, _ := buildDataSourceDiagnosticsCountSQL(query)
|
|
if !strings.Contains(countSQL, "FROM (") || !strings.Contains(countSQL, "HAVING") {
|
|
t.Fatalf("mapping issue count should wrap grouped diagnostics:\n%s", countSQL)
|
|
}
|
|
if strings.Contains(countSQL, "ds.platform_name IS NOT NULL") {
|
|
t.Fatalf("mapping issue count HAVING should use aggregate aliases, not table-qualified platform_name:\n%s", countSQL)
|
|
}
|
|
}
|
|
|
|
func TestDiagnoseDataSourceHighlightsConfiguredMappingIssues(t *testing.T) {
|
|
lowCoverage := DataSourceDiagnosticRow{
|
|
Protocol: "JT808",
|
|
PlatformName: "东方北斗",
|
|
SourceCode: "dongfang_beidou",
|
|
RegistrationRows: 388,
|
|
PhoneCount: 388,
|
|
IdentifierMatchedPhones: 8,
|
|
UnmappedPhoneCount: 380,
|
|
IdentifierMatchRatio: 0.0206,
|
|
ConfiguredSourceCodeMatchedPhones: 8,
|
|
ConfiguredSourceCodePlatformName: "东方北斗",
|
|
MatchedSourceCodeCount: 1,
|
|
MatchedSourceCodes: []string{"dongfang_beidou"},
|
|
}
|
|
lowCoverage.ConfiguredSourceCodeConflict = configuredSourceCodeConflict(lowCoverage)
|
|
lowCoverage.SourcePlatformNameMismatch = sourcePlatformNameMismatch(lowCoverage)
|
|
reason, _ := diagnoseDataSource(lowCoverage)
|
|
if reason != "low_identifier_coverage" {
|
|
t.Fatalf("reason = %q, want low_identifier_coverage", reason)
|
|
}
|
|
|
|
lowCoverageMismatch := lowCoverage
|
|
lowCoverageMismatch.PlatformName = "G7易流"
|
|
lowCoverageMismatch.SourcePlatformNameMismatch = sourcePlatformNameMismatch(lowCoverageMismatch)
|
|
reason, _ = diagnoseDataSource(lowCoverageMismatch)
|
|
if reason != "low_identifier_coverage" {
|
|
t.Fatalf("reason = %q, want low_identifier_coverage when coverage is weak even if platform name differs", reason)
|
|
}
|
|
|
|
nameMismatch := DataSourceDiagnosticRow{
|
|
Protocol: "JT808",
|
|
PlatformName: "G7易流",
|
|
SourceCode: "dongfang_beidou",
|
|
RegistrationRows: 388,
|
|
PhoneCount: 388,
|
|
IdentifierMatchedPhones: 8,
|
|
ConfiguredSourceCodePlatformName: "东方北斗",
|
|
MatchedSourceCodeCount: 1,
|
|
MatchedSourceCodes: []string{"dongfang_beidou"},
|
|
}
|
|
nameMismatch.SourcePlatformNameMismatch = sourcePlatformNameMismatch(nameMismatch)
|
|
reason, _ = diagnoseDataSource(nameMismatch)
|
|
if reason != "source_platform_name_mismatch" {
|
|
t.Fatalf("reason = %q, want source_platform_name_mismatch", reason)
|
|
}
|
|
|
|
conflict := DataSourceDiagnosticRow{
|
|
Protocol: "JT808",
|
|
SourceCode: "g7s",
|
|
RegistrationRows: 20,
|
|
PhoneCount: 20,
|
|
IdentifierMatchedPhones: 20,
|
|
IdentifierMatchRatio: 1,
|
|
ConfiguredSourceCodeMatchedPhones: 0,
|
|
MatchedSourceCodeCount: 1,
|
|
MatchedSourceCodes: []string{"dongfang_beidou"},
|
|
}
|
|
conflict.ConfiguredSourceCodeConflict = configuredSourceCodeConflict(conflict)
|
|
reason, _ = diagnoseDataSource(conflict)
|
|
if reason != "source_code_conflict" {
|
|
t.Fatalf("reason = %q, want source_code_conflict", reason)
|
|
}
|
|
}
|
|
|
|
func TestDataSourceHandlerReturnsSourcePage(t *testing.T) {
|
|
db, mock, err := sqlmock.New()
|
|
if err != nil {
|
|
t.Fatalf("sqlmock.New() error = %v", err)
|
|
}
|
|
defer db.Close()
|
|
mock.ExpectQuery("SELECT COUNT\\(\\*\\) FROM vehicle_data_source").
|
|
WithArgs("GB32960", 1).
|
|
WillReturnRows(sqlmock.NewRows([]string{"total"}).AddRow(3))
|
|
mock.ExpectQuery(dataSourceSelectPattern).
|
|
WithArgs("GB32960", 1, 50, 0).
|
|
WillReturnRows(sqlmock.NewRows([]string{
|
|
"id", "protocol", "source_ip", "latest_source_endpoint", "platform_name", "source_code", "source_kind",
|
|
"trust_priority", "enabled", "first_seen_at", "latest_seen_at", "remark", "updated_at",
|
|
}).AddRow(
|
|
7, "GB32960", "8.134.95.166", "8.134.95.166:56432", "现代 HTWO", "HYUNDAI", "PLATFORM",
|
|
5, 1, "2026-07-11 18:27:10", "2026-07-12 01:15:52", "", "2026-07-12 01:15:52",
|
|
))
|
|
|
|
handler := NewDataSourceHandler(NewDataSourceRepository(db))
|
|
request := httptest.NewRequest(http.MethodGet, "/api/stats/data-sources?protocol=gb32960&enabled=true&includeTotal=true", nil)
|
|
response := httptest.NewRecorder()
|
|
|
|
handler.ServeHTTP(response, request)
|
|
|
|
if response.Code != http.StatusOK {
|
|
t.Fatalf("status = %d body=%s", response.Code, response.Body.String())
|
|
}
|
|
body := response.Body.String()
|
|
for _, want := range []string{`"total":3`, `"source_ip":"8.134.95.166"`, `"platform_name":"现代 HTWO"`, `"source_code":"HYUNDAI"`, `"source_kind":"PLATFORM"`} {
|
|
if !strings.Contains(body, want) {
|
|
t.Fatalf("response missing %s: %s", want, body)
|
|
}
|
|
}
|
|
if err := mock.ExpectationsWereMet(); err != nil {
|
|
t.Fatalf("sql expectations: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestDataSourceHandlerReturnsDiagnosticsPage(t *testing.T) {
|
|
db, mock, err := sqlmock.New()
|
|
if err != nil {
|
|
t.Fatalf("sqlmock.New() error = %v", err)
|
|
}
|
|
defer db.Close()
|
|
mock.ExpectQuery("SELECT COUNT\\(\\*\\) FROM vehicle_data_source ds").
|
|
WithArgs("JT808", 1).
|
|
WillReturnRows(sqlmock.NewRows([]string{"total"}).AddRow(1))
|
|
mock.ExpectQuery("FROM vehicle_data_source ds").
|
|
WithArgs("JT808", 1, 50, 0).
|
|
WillReturnRows(sqlmock.NewRows([]string{
|
|
"id", "protocol", "source_ip", "latest_source_endpoint", "platform_name", "source_code",
|
|
"source_kind", "first_seen_at", "latest_seen_at", "active_span_seconds", "latest_seen_age_seconds", "registration_rows", "phone_count", "unknown_vin_rows",
|
|
"identifier_matched_phones", "unmapped_phone_count", "identifier_match_ratio", "configured_source_code_matched_phones", "configured_source_code_platform_name", "matched_source_code_count", "candidate_source_code",
|
|
"candidate_platform_name", "matched_source_codes", "matched_platform_names", "sample_phones",
|
|
}).AddRow(
|
|
242190, "JT808", "117.132.194.31", "117.132.194.31:20471", nil, nil,
|
|
"UNKNOWN", "2026-07-12 01:00:00", "2026-07-12 01:36:26", 2186, 1800,
|
|
5, 4, 2,
|
|
0, 4, 0.0, 0, nil, 0, nil, nil, nil, nil, "13307795425",
|
|
))
|
|
|
|
handler := NewDataSourceHandler(NewDataSourceRepository(db))
|
|
request := httptest.NewRequest(http.MethodGet, "/api/stats/data-sources/diagnostics?protocol=jt808&includeTotal=true", nil)
|
|
response := httptest.NewRecorder()
|
|
|
|
handler.ServeHTTP(response, request)
|
|
|
|
if response.Code != http.StatusOK {
|
|
t.Fatalf("status = %d body=%s", response.Code, response.Body.String())
|
|
}
|
|
body := response.Body.String()
|
|
for _, want := range []string{`"total":1`, `"reason":"no_identifier_match"`, `"sample_phones":["13307795425"]`} {
|
|
if !strings.Contains(body, want) {
|
|
t.Fatalf("response missing %s: %s", want, body)
|
|
}
|
|
}
|
|
if err := mock.ExpectationsWereMet(); err != nil {
|
|
t.Fatalf("sql expectations: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestDataSourceHandlerReturnsJT808IdentityGaps(t *testing.T) {
|
|
db, mock, err := sqlmock.New()
|
|
if err != nil {
|
|
t.Fatalf("sqlmock.New() error = %v", err)
|
|
}
|
|
defer db.Close()
|
|
mock.ExpectQuery("SELECT COUNT\\(\\*\\) FROM jt808_registration r").
|
|
WithArgs("117.132.194.31", "guangan_beidou", 3600).
|
|
WillReturnRows(sqlmock.NewRows([]string{"total"}).AddRow(1))
|
|
mock.ExpectQuery("FROM jt808_registration r").
|
|
WithArgs("117.132.194.31", "guangan_beidou", 3600, 20, 0).
|
|
WillReturnRows(sqlmock.NewRows([]string{
|
|
"phone", "device_id", "plate", "vin", "source_ip", "source_endpoint",
|
|
"source_code", "platform_name", "source_kind",
|
|
"first_registered_at", "latest_registered_at", "latest_authenticated_at", "latest_seen_at", "latest_seen_age_seconds",
|
|
}).AddRow(
|
|
"13307795425", "", "沪A63305F", "unknown", "117.132.194.31", "117.132.194.31:20471",
|
|
"guangan_beidou", "广安北斗", "PLATFORM",
|
|
nil, nil, nil, "2026-07-12 22:24:53", 32,
|
|
))
|
|
|
|
handler := NewDataSourceHandler(NewDataSourceRepository(db))
|
|
request := httptest.NewRequest(http.MethodGet, "/api/stats/data-sources/jt808-identity-gaps?sourceIP=117.132.194.31&sourceCode=guangan_beidou&recentSeconds=3600&includeTotal=true&limit=20", nil)
|
|
response := httptest.NewRecorder()
|
|
|
|
handler.ServeHTTP(response, request)
|
|
|
|
if response.Code != http.StatusOK {
|
|
t.Fatalf("status = %d body=%s", response.Code, response.Body.String())
|
|
}
|
|
body := response.Body.String()
|
|
for _, want := range []string{
|
|
`"total":1`,
|
|
`"phone":"13307795425"`,
|
|
`"reason":"missing_phone_and_plate_binding"`,
|
|
`"raw_frame_query_path":"/api/history/raw-frames?`,
|
|
`phone=13307795425`,
|
|
`dateFrom=2026-07-12+00%3A00%3A00`,
|
|
`"data_source_query_path":"/api/stats/data-sources?`,
|
|
`sourceIP=117.132.194.31`,
|
|
} {
|
|
if !strings.Contains(body, want) {
|
|
t.Fatalf("response missing %s: %s", want, body)
|
|
}
|
|
}
|
|
if err := mock.ExpectationsWereMet(); err != nil {
|
|
t.Fatalf("sql expectations: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestDataSourceHandlerReturnsJT808MappingGaps(t *testing.T) {
|
|
db, mock, err := sqlmock.New()
|
|
if err != nil {
|
|
t.Fatalf("sqlmock.New() error = %v", err)
|
|
}
|
|
defer db.Close()
|
|
mock.ExpectQuery("SELECT COUNT\\(\\*\\) FROM jt808_registration r").
|
|
WithArgs("115.159.85.149", "dongfang_beidou", 3600).
|
|
WillReturnRows(sqlmock.NewRows([]string{"total"}).AddRow(1))
|
|
mock.ExpectQuery("FROM jt808_registration r").
|
|
WithArgs("115.159.85.149", "dongfang_beidou", 3600, 20, 0).
|
|
WillReturnRows(sqlmock.NewRows([]string{
|
|
"phone", "device_id", "plate", "vin", "source_ip", "source_endpoint",
|
|
"source_code", "platform_name", "source_kind", "identifier_vin", "identifier_plate",
|
|
"matched_source_codes", "matched_platform_names", "latest_seen_at", "latest_seen_age_seconds",
|
|
}).AddRow(
|
|
"64646848246", "", "粤AG18312", "LKLG7C4E8NA774778", "115.159.85.149", "115.159.85.149:16885",
|
|
"dongfang_beidou", "G7易流", "PLATFORM", nil, nil,
|
|
"g7s", "G7s", "2026-07-12 23:38:22", 32,
|
|
))
|
|
|
|
handler := NewDataSourceHandler(NewDataSourceRepository(db))
|
|
request := httptest.NewRequest(http.MethodGet, "/api/stats/data-sources/jt808-mapping-gaps?sourceIP=115.159.85.149&sourceCode=dongfang_beidou&recentSeconds=3600&includeTotal=true&limit=20", nil)
|
|
response := httptest.NewRecorder()
|
|
|
|
handler.ServeHTTP(response, request)
|
|
|
|
if response.Code != http.StatusOK {
|
|
t.Fatalf("status = %d body=%s", response.Code, response.Body.String())
|
|
}
|
|
body := response.Body.String()
|
|
for _, want := range []string{
|
|
`"total":1`,
|
|
`"phone":"64646848246"`,
|
|
`"suggested_source_code":"dongfang_beidou"`,
|
|
`"suggested_identifier_type":"JT808_PHONE"`,
|
|
`"suggested_vin":"LKLG7C4E8NA774778"`,
|
|
`"reason":"missing_source_phone_identifier"`,
|
|
`"matched_source_codes":["g7s"]`,
|
|
`"raw_frame_query_path":"/api/history/raw-frames?`,
|
|
`phone=64646848246`,
|
|
`"data_source_query_path":"/api/stats/data-sources?`,
|
|
`sourceIP=115.159.85.149`,
|
|
`"vehicle_identifier_example":"protocol=JT808, source_code=dongfang_beidou, identifier_type=JT808_PHONE, identifier_value=64646848246, vin=LKLG7C4E8NA774778, plate=粤AG18312, oem=G7易流"`,
|
|
} {
|
|
if !strings.Contains(body, want) {
|
|
t.Fatalf("response missing %s: %s", want, body)
|
|
}
|
|
}
|
|
if err := mock.ExpectationsWereMet(); err != nil {
|
|
t.Fatalf("sql expectations: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestJT808MappingGapSQLUsesConfiguredSourceIdentifier(t *testing.T) {
|
|
sqlText, args := buildJT808MappingGapSQL(normalizeJT808MappingGapQuery(JT808MappingGapQuery{
|
|
SourceIP: "115.159.85.149",
|
|
SourceCode: "dongfang_beidou",
|
|
RecentSeconds: 3600,
|
|
Limit: 20,
|
|
}))
|
|
for _, want := range []string{
|
|
"JOIN vehicle_data_source ds",
|
|
"source_vi.source_code = ds.source_code",
|
|
"source_vi.identifier_type = 'JT808_PHONE'",
|
|
"source_vi.identifier_value = r.phone",
|
|
"source_vi.identifier_value IS NULL OR source_vi.vin IS NULL",
|
|
} {
|
|
if !strings.Contains(sqlText, want) {
|
|
t.Fatalf("mapping gap SQL missing %q:\n%s", want, sqlText)
|
|
}
|
|
}
|
|
if len(args) != 5 {
|
|
t.Fatalf("args = %#v, want sourceIP/sourceCode/recent/limit/offset", args)
|
|
}
|
|
}
|
|
|
|
func TestDataSourceDiagnosticsCanQueryRetiredSources(t *testing.T) {
|
|
db, mock, err := sqlmock.New()
|
|
if err != nil {
|
|
t.Fatalf("sqlmock.New() error = %v", err)
|
|
}
|
|
defer db.Close()
|
|
mock.ExpectQuery("FROM vehicle_data_source ds").
|
|
WithArgs("JT808", 0, 50, 0).
|
|
WillReturnRows(sqlmock.NewRows([]string{
|
|
"id", "protocol", "source_ip", "latest_source_endpoint", "platform_name", "source_code",
|
|
"source_kind", "first_seen_at", "latest_seen_at", "active_span_seconds", "latest_seen_age_seconds", "registration_rows", "phone_count", "unknown_vin_rows",
|
|
"identifier_matched_phones", "unmapped_phone_count", "identifier_match_ratio", "configured_source_code_matched_phones", "configured_source_code_platform_name", "matched_source_code_count", "candidate_source_code",
|
|
"candidate_platform_name", "matched_source_codes", "matched_platform_names", "sample_phones",
|
|
}))
|
|
|
|
handler := NewDataSourceHandler(NewDataSourceRepository(db))
|
|
request := httptest.NewRequest(http.MethodGet, "/api/stats/data-sources/diagnostics?protocol=jt808&enabled=false", nil)
|
|
response := httptest.NewRecorder()
|
|
|
|
handler.ServeHTTP(response, request)
|
|
|
|
if response.Code != http.StatusOK {
|
|
t.Fatalf("status = %d body=%s", response.Code, response.Body.String())
|
|
}
|
|
sqlText, args := buildDataSourceDiagnosticsSQL(normalizeDataSourceDiagnosticsQuery(DataSourceDiagnosticsQuery{Protocol: "JT808"}))
|
|
if !strings.Contains(sqlText, "ds.enabled = ?") {
|
|
t.Fatalf("diagnostics should default to enabled sources:\n%s", sqlText)
|
|
}
|
|
if len(args) < 2 || args[1] != 1 {
|
|
t.Fatalf("diagnostics enabled default args = %#v, want enabled=1 before limit", args)
|
|
}
|
|
if err := mock.ExpectationsWereMet(); err != nil {
|
|
t.Fatalf("sql expectations: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestDataSourceHandlerReturnsGenericDiagnosticsForNonJT808(t *testing.T) {
|
|
db, mock, err := sqlmock.New()
|
|
if err != nil {
|
|
t.Fatalf("sqlmock.New() error = %v", err)
|
|
}
|
|
defer db.Close()
|
|
mock.ExpectQuery("FROM vehicle_data_source ds").
|
|
WithArgs("GB32960", 1, 50, 0).
|
|
WillReturnRows(sqlmock.NewRows([]string{
|
|
"id", "protocol", "source_ip", "latest_source_endpoint", "platform_name", "source_code",
|
|
"source_kind", "first_seen_at", "latest_seen_at", "active_span_seconds", "latest_seen_age_seconds", "registration_rows", "phone_count", "unknown_vin_rows",
|
|
"identifier_matched_phones", "unmapped_phone_count", "identifier_match_ratio", "configured_source_code_matched_phones", "configured_source_code_platform_name", "matched_source_code_count", "candidate_source_code",
|
|
"candidate_platform_name", "matched_source_codes", "matched_platform_names", "sample_phones",
|
|
}).AddRow(
|
|
7, "GB32960", "8.134.95.166", "8.134.95.166:32960", "现代 HTWO", nil,
|
|
"UNKNOWN", "2026-07-12 01:00:00", "2026-07-12 01:36:26", 2186, 1800,
|
|
0, 0, 0,
|
|
0, 0, 0.0, 0, nil, 0, nil, nil, nil, nil, nil,
|
|
))
|
|
|
|
handler := NewDataSourceHandler(NewDataSourceRepository(db))
|
|
request := httptest.NewRequest(http.MethodGet, "/api/stats/data-sources/diagnostics?protocol=GB32960", nil)
|
|
response := httptest.NewRecorder()
|
|
|
|
handler.ServeHTTP(response, request)
|
|
|
|
if response.Code != http.StatusOK {
|
|
t.Fatalf("status = %d body=%s", response.Code, response.Body.String())
|
|
}
|
|
body := response.Body.String()
|
|
for _, want := range []string{`"protocol":"GB32960"`, `"reason":"source_code_missing"`, `"suggested_source_kind":"PLATFORM"`} {
|
|
if !strings.Contains(body, want) {
|
|
t.Fatalf("response missing %s: %s", want, body)
|
|
}
|
|
}
|
|
if err := mock.ExpectationsWereMet(); err != nil {
|
|
t.Fatalf("sql expectations: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestDataSourceHandlerReturnsKindSuggestionsPage(t *testing.T) {
|
|
db, mock, err := sqlmock.New()
|
|
if err != nil {
|
|
t.Fatalf("sqlmock.New() error = %v", err)
|
|
}
|
|
defer db.Close()
|
|
mock.ExpectQuery("SELECT COUNT\\(\\*\\) FROM vehicle_data_source ds").
|
|
WithArgs("JT808", "UNKNOWN", 1).
|
|
WillReturnRows(sqlmock.NewRows([]string{"total"}).AddRow(1))
|
|
mock.ExpectQuery("FROM vehicle_data_source ds").
|
|
WithArgs("JT808", "UNKNOWN", 1, 50, 0).
|
|
WillReturnRows(sqlmock.NewRows([]string{
|
|
"id", "protocol", "source_ip", "latest_source_endpoint", "platform_name", "source_code",
|
|
"source_kind", "first_seen_at", "latest_seen_at", "active_span_seconds", "latest_seen_age_seconds", "registration_rows", "phone_count", "unknown_vin_rows",
|
|
"identifier_matched_phones", "unmapped_phone_count", "identifier_match_ratio", "configured_source_code_matched_phones", "configured_source_code_platform_name", "matched_source_code_count", "candidate_source_code",
|
|
"candidate_platform_name", "matched_source_codes", "matched_platform_names", "sample_phones",
|
|
}).AddRow(
|
|
242190, "JT808", "117.132.194.31", "117.132.194.31:20471", "广安北斗", "guangan_beidou",
|
|
"UNKNOWN", "2026-07-12 00:00:00", "2026-07-12 00:05:00", 300, 7200,
|
|
0, 0, 0,
|
|
0, 0, 0.0, 0, nil, 0, nil, nil, nil, nil, nil,
|
|
))
|
|
|
|
handler := NewDataSourceHandler(NewDataSourceRepository(db))
|
|
request := httptest.NewRequest(http.MethodGet, "/api/stats/data-sources/kind-suggestions?protocol=jt808&includeTotal=true", nil)
|
|
response := httptest.NewRecorder()
|
|
|
|
handler.ServeHTTP(response, request)
|
|
|
|
if response.Code != http.StatusOK {
|
|
t.Fatalf("status = %d body=%s", response.Code, response.Body.String())
|
|
}
|
|
body := response.Body.String()
|
|
for _, want := range []string{`"total":1`, `"suggested_source_kind":"UNKNOWN"`, `"suggestion_confidence":"MEDIUM"`, `"suggestion_reason":"manual_source_without_registration_evidence"`} {
|
|
if !strings.Contains(body, want) {
|
|
t.Fatalf("response missing %s: %s", want, body)
|
|
}
|
|
}
|
|
if err := mock.ExpectationsWereMet(); err != nil {
|
|
t.Fatalf("sql expectations: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestDataSourceHandlerReturnsKindSuggestionsForNonJT808(t *testing.T) {
|
|
db, mock, err := sqlmock.New()
|
|
if err != nil {
|
|
t.Fatalf("sqlmock.New() error = %v", err)
|
|
}
|
|
defer db.Close()
|
|
mock.ExpectQuery("FROM vehicle_data_source ds").
|
|
WithArgs("GB32960", "UNKNOWN", 1, 50, 0).
|
|
WillReturnRows(sqlmock.NewRows([]string{
|
|
"id", "protocol", "source_ip", "latest_source_endpoint", "platform_name", "source_code",
|
|
"source_kind", "first_seen_at", "latest_seen_at", "active_span_seconds", "latest_seen_age_seconds", "registration_rows", "phone_count", "unknown_vin_rows",
|
|
"identifier_matched_phones", "unmapped_phone_count", "identifier_match_ratio", "configured_source_code_matched_phones", "configured_source_code_platform_name", "matched_source_code_count", "candidate_source_code",
|
|
"candidate_platform_name", "matched_source_codes", "matched_platform_names", "sample_phones",
|
|
}).AddRow(
|
|
7, "GB32960", "8.134.95.166", "8.134.95.166:32960", "现代 HTWO", "HYUNDAI",
|
|
"UNKNOWN", "2026-07-12 01:00:00", "2026-07-12 01:36:26", 2186, 1800,
|
|
0, 0, 0,
|
|
0, 0, 0.0, 0, nil, 0, nil, nil, nil, nil, nil,
|
|
))
|
|
|
|
handler := NewDataSourceHandler(NewDataSourceRepository(db))
|
|
request := httptest.NewRequest(http.MethodGet, "/api/stats/data-sources/kind-suggestions?protocol=GB32960", nil)
|
|
response := httptest.NewRecorder()
|
|
|
|
handler.ServeHTTP(response, request)
|
|
|
|
if response.Code != http.StatusOK {
|
|
t.Fatalf("status = %d body=%s", response.Code, response.Body.String())
|
|
}
|
|
body := response.Body.String()
|
|
for _, want := range []string{`"reason":"source_configured"`, `"suggested_source_kind":"PLATFORM"`, `"suggestion_reason":"non_jt808_configured_source"`} {
|
|
if !strings.Contains(body, want) {
|
|
t.Fatalf("response missing %s: %s", want, body)
|
|
}
|
|
}
|
|
if err := mock.ExpectationsWereMet(); err != nil {
|
|
t.Fatalf("sql expectations: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestSuggestSourceKindMarksStaleUnclassifiedSourceAsDirect(t *testing.T) {
|
|
kind, confidence, reason := suggestSourceKind(DataSourceDiagnosticRow{
|
|
SourceKind: "UNKNOWN",
|
|
Reason: "no_registration",
|
|
LatestSeenAgeSeconds: 25 * 3600,
|
|
})
|
|
if kind != "DIRECT" || confidence != "LOW" || reason != "stale_unclassified_source_without_registration" {
|
|
t.Fatalf("unexpected suggestion: kind=%s confidence=%s reason=%s", kind, confidence, reason)
|
|
}
|
|
}
|
|
|
|
func TestDataSourceHandlerPatchesOnlyManualFields(t *testing.T) {
|
|
db, mock, err := sqlmock.New()
|
|
if err != nil {
|
|
t.Fatalf("sqlmock.New() error = %v", err)
|
|
}
|
|
defer db.Close()
|
|
mock.ExpectQuery("SELECT 1 FROM vehicle_data_source WHERE id = \\? LIMIT 1").
|
|
WithArgs(int64(3)).
|
|
WillReturnRows(sqlmock.NewRows([]string{"one"}).AddRow(1))
|
|
mock.ExpectExec("UPDATE vehicle_data_source SET platform_name = \\?, source_code = \\?, source_kind = \\?, trust_priority = \\?, enabled = \\?, remark = \\?, updated_at = CURRENT_TIMESTAMP WHERE id = \\?").
|
|
WithArgs("G7 平台", "G7S", "PLATFORM", 10, 0, "可信 808 来源", int64(3)).
|
|
WillReturnResult(sqlmock.NewResult(0, 0))
|
|
|
|
handler := NewDataSourceHandler(NewDataSourceRepository(db))
|
|
body := strings.NewReader(`{"platform_name":"G7 平台","source_code":"G7S","source_kind":"platform","trust_priority":10,"enabled":false,"remark":"可信 808 来源","latest_seen_at":"2099-01-01 00:00:00"}`)
|
|
request := httptest.NewRequest(http.MethodPatch, "/api/stats/data-sources/3", body)
|
|
response := httptest.NewRecorder()
|
|
|
|
handler.ServeHTTP(response, request)
|
|
|
|
if response.Code != http.StatusOK {
|
|
t.Fatalf("status = %d body=%s", response.Code, response.Body.String())
|
|
}
|
|
if !strings.Contains(response.Body.String(), `"updated":true`) {
|
|
t.Fatalf("patch response should confirm update: %s", response.Body.String())
|
|
}
|
|
if err := mock.ExpectationsWereMet(); err != nil {
|
|
t.Fatalf("sql expectations: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestDataSourceHandlerRejectsConflictingSourceCodeFilters(t *testing.T) {
|
|
handler := NewDataSourceHandler(NewDataSourceRepository(&sql.DB{}))
|
|
request := httptest.NewRequest(http.MethodGet, "/api/stats/data-sources?sourceCode=g7s&sourceCodeMissing=true", nil)
|
|
response := httptest.NewRecorder()
|
|
|
|
handler.ServeHTTP(response, request)
|
|
|
|
if response.Code != http.StatusBadRequest {
|
|
t.Fatalf("status = %d body=%s", response.Code, response.Body.String())
|
|
}
|
|
if !strings.Contains(response.Body.String(), "sourceCode") {
|
|
t.Fatalf("response should mention sourceCode: %s", response.Body.String())
|
|
}
|
|
}
|
|
|
|
func TestDataSourceHandlerRejectsInvalidSourceCode(t *testing.T) {
|
|
handler := NewDataSourceHandler(NewDataSourceRepository(&sql.DB{}))
|
|
request := httptest.NewRequest(http.MethodPatch, "/api/stats/data-sources/1", strings.NewReader(`{"source_code":"G7 中文"}`))
|
|
response := httptest.NewRecorder()
|
|
|
|
handler.ServeHTTP(response, request)
|
|
|
|
if response.Code != http.StatusBadRequest {
|
|
t.Fatalf("status = %d body=%s", response.Code, response.Body.String())
|
|
}
|
|
if !strings.Contains(response.Body.String(), "source_code") {
|
|
t.Fatalf("response should mention source_code: %s", response.Body.String())
|
|
}
|
|
}
|
|
|
|
func TestDataSourceHandlerRejectsInvalidSourceKind(t *testing.T) {
|
|
handler := NewDataSourceHandler(NewDataSourceRepository(&sql.DB{}))
|
|
request := httptest.NewRequest(http.MethodPatch, "/api/stats/data-sources/1", strings.NewReader(`{"source_kind":"temporary"}`))
|
|
response := httptest.NewRecorder()
|
|
|
|
handler.ServeHTTP(response, request)
|
|
|
|
if response.Code != http.StatusBadRequest {
|
|
t.Fatalf("status = %d body=%s", response.Code, response.Body.String())
|
|
}
|
|
if !strings.Contains(response.Body.String(), "source_kind") {
|
|
t.Fatalf("response should mention source_kind: %s", response.Body.String())
|
|
}
|
|
}
|
|
|
|
func TestDataSourceHandlerRejectsEmptyPatch(t *testing.T) {
|
|
handler := NewDataSourceHandler(NewDataSourceRepository(&sql.DB{}))
|
|
request := httptest.NewRequest(http.MethodPatch, "/api/stats/data-sources/1", strings.NewReader(`{}`))
|
|
response := httptest.NewRecorder()
|
|
|
|
handler.ServeHTTP(response, request)
|
|
|
|
if response.Code != http.StatusBadRequest {
|
|
t.Fatalf("status = %d body=%s", response.Code, response.Body.String())
|
|
}
|
|
if !strings.Contains(response.Body.String(), "no mutable fields") {
|
|
t.Fatalf("response should mention no mutable fields: %s", response.Body.String())
|
|
}
|
|
}
|