lingniu-vehicle-ingest/go/vehicle-gateway/internal/identity/resolver_test.go

package identity

import (
	"context"
	"database/sql"
	"errors"
	"strings"
	"testing"
	"time"

	"github.com/DATA-DOG/go-sqlmock"

	"lingniu-vehicle-ingest/go/vehicle-gateway/internal/envelope"
)

func TestCandidateKeysExcludeDeviceIDForBindingLookup(t *testing.T) {
	keys := CandidateKeys(envelope.FrameEnvelope{
		Phone:          "013307795425",
		DeviceID:       "D1",
		Plate:          "豫A12345",
		VehicleKeyHint: "D1",
	})
	got := []string{}
	for _, key := range keys {
		got = append(got, key.Column+"="+key.Value)
	}
	want := []string{"phone=13307795425", "plate=豫A12345", "vin=D1"}
	if len(got) != len(want) {
		t.Fatalf("candidate count = %d got=%#v", len(got), got)
	}
	for i := range want {
		if got[i] != want[i] {
			t.Fatalf("candidate[%d] = %q, want %q", i, got[i], want[i])
		}
	}
}

func TestCandidateKeysNormalizesPhone(t *testing.T) {
	keys := CandidateKeys(envelope.FrameEnvelope{
		Phone: "013079963379",
	})
	got := []string{}
	for _, key := range keys {
		got = append(got, key.Column+"="+key.Value)
	}
	want := []string{"phone=13079963379"}
	if len(got) != len(want) {
		t.Fatalf("candidate count = %d got=%#v", len(got), got)
	}
	for i := range want {
		if got[i] != want[i] {
			t.Fatalf("candidate[%d] = %q, want %q", i, got[i], want[i])
		}
	}
}

func TestMySQLResolverFillsVINFromPhone(t *testing.T) {
	db, mock := newMockDB(t)
	defer db.Close()
	mock.ExpectQuery("SELECT vin FROM vehicle_identity_binding WHERE phone = \\?").
		WithArgs("13307795425").
		WillReturnRows(sqlmock.NewRows([]string{"vin"}).AddRow("LNBVIN00000000001"))

	resolver := NewMySQLResolver(db, "vehicle_identity_binding")
	env, err := resolver.Resolve(context.Background(), envelope.FrameEnvelope{
		Protocol: envelope.ProtocolJT808,
		Phone:    "013307795425",
		Parsed:   map[string]any{},
	})
	if err != nil {
		t.Fatalf("Resolve() error = %v", err)
	}
	if env.VIN != "LNBVIN00000000001" {
		t.Fatalf("vin = %q", env.VIN)
	}
	identity, ok := env.Parsed["identity"].(map[string]any)
	if !ok || identity["source"] != "phone" {
		t.Fatalf("identity metadata = %#v", env.Parsed["identity"])
	}
	if err := mock.ExpectationsWereMet(); err != nil {
		t.Fatalf("sql expectations: %v", err)
	}
}

func TestMySQLResolverLooksUpVINByUniqueKeyWithoutSort(t *testing.T) {
	db, mock := newMockDB(t)
	defer db.Close()
	mock.ExpectQuery("SELECT vin FROM vehicle_identity_binding WHERE phone = \\? AND vin IS NOT NULL AND vin <> ''$").
		WithArgs("13307795425").
		WillReturnRows(sqlmock.NewRows([]string{"vin"}).AddRow("LNBVIN00000000001"))

	resolver := NewMySQLResolver(db, "vehicle_identity_binding")
	env, err := resolver.Resolve(context.Background(), envelope.FrameEnvelope{
		Protocol: envelope.ProtocolJT808,
		Phone:    "013307795425",
		Parsed:   map[string]any{},
	})
	if err != nil {
		t.Fatalf("Resolve() error = %v", err)
	}
	if env.VIN != "LNBVIN00000000001" {
		t.Fatalf("vin = %q", env.VIN)
	}
	if err := mock.ExpectationsWereMet(); err != nil {
		t.Fatalf("sql expectations: %v", err)
	}
}

func TestMySQLResolverDoesNotLookupBindingByDeviceID(t *testing.T) {
	db, mock := newMockDB(t)
	defer db.Close()
	mock.ExpectQuery("SELECT vin FROM vehicle_identity_binding WHERE phone = \\?").
		WithArgs("13307795425").
		WillReturnError(sql.ErrNoRows)

	resolver := NewMySQLResolver(db, "vehicle_identity_binding")
	env, err := resolver.Resolve(context.Background(), envelope.FrameEnvelope{
		Protocol: envelope.ProtocolJT808,
		Phone:    "013307795425",
		DeviceID: "D1",
	})
	if err != nil {
		t.Fatalf("Resolve() error = %v", err)
	}
	if env.VIN != "" {
		t.Fatalf("vin = %q", env.VIN)
	}
	if err := mock.ExpectationsWereMet(); err != nil {
		t.Fatalf("sql expectations: %v", err)
	}
}

func TestMySQLResolverTracksJT808RegistrationWithoutWritingBinding(t *testing.T) {
	db, mock := newMockDB(t)
	defer db.Close()
	mock.ExpectQuery("SELECT vin FROM vehicle_identity_binding WHERE phone = \\?").
		WithArgs("13079963379").
		WillReturnError(sql.ErrNoRows)
	mock.ExpectQuery("SELECT vin FROM vehicle_identity_binding WHERE plate = \\?").
		WithArgs("TEST123").
		WillReturnRows(sqlmock.NewRows([]string{"vin"}).AddRow("LKLG7C4E3NA774736"))
	mock.ExpectExec("INSERT INTO jt808_registration").
		WillReturnResult(sqlmock.NewResult(1, 1))

	resolver := NewMySQLResolver(db, "vehicle_identity_binding")
	env, err := resolver.Resolve(context.Background(), envelope.FrameEnvelope{
		Protocol:       envelope.ProtocolJT808,
		MessageID:      "0x0100",
		Phone:          "013079963379",
		DeviceID:       "DEV0001",
		Plate:          "TEST123",
		SourceEndpoint: "115.231.168.135:43625",
		Parsed: map[string]any{
			"registration": map[string]any{
				"province":     uint16(16),
				"city":         uint16(32),
				"manufacturer": "YUTNG",
				"device_type":  "ZK6105CHEVNPG4",
				"device_id":    "DEV0001",
				"plate_color":  uint8(2),
				"plate":        "TEST123",
			},
		},
	})
	if err != nil {
		t.Fatalf("Resolve() error = %v", err)
	}
	if env.VIN != "LKLG7C4E3NA774736" {
		t.Fatalf("vin = %q", env.VIN)
	}
	if err := mock.ExpectationsWereMet(); err != nil {
		t.Fatalf("sql expectations: %v", err)
	}
}

func TestMySQLResolverTracksFirstJT808LocationThenThrottles(t *testing.T) {
	db, mock := newMockDB(t)
	defer db.Close()
	mock.ExpectQuery("SELECT vin FROM vehicle_identity_binding WHERE phone = \\?").
		WithArgs("13307795425").
		WillReturnError(sql.ErrNoRows)
	mock.ExpectQuery("SELECT vin, device_id, plate FROM jt808_registration WHERE phone = \\?").
		WithArgs("13307795425").
		WillReturnError(sql.ErrNoRows)
	mock.ExpectExec("INSERT INTO jt808_registration").
		WillReturnResult(sqlmock.NewResult(1, 1))

	resolver := NewMySQLResolver(db, "vehicle_identity_binding")
	for i := 0; i < 2; i++ {
		_, err := resolver.Resolve(context.Background(), envelope.FrameEnvelope{
			Protocol:       envelope.ProtocolJT808,
			MessageID:      "0x0200",
			Phone:          "013307795425",
			SourceEndpoint: "115.231.168.135:43625",
			Parsed:         map[string]any{},
		})
		if err != nil {
			t.Fatalf("Resolve() error = %v", err)
		}
	}
	if err := mock.ExpectationsWereMet(); err != nil {
		t.Fatalf("sql expectations: %v", err)
	}
}

func TestMySQLResolverUsesJT808RegistrationPlateForLocationVIN(t *testing.T) {
	db, mock := newMockDB(t)
	defer db.Close()
	mock.ExpectQuery("SELECT vin FROM vehicle_identity_binding WHERE phone = \\?").
		WithArgs("40692934322").
		WillReturnError(sql.ErrNoRows)
	mock.ExpectQuery("SELECT vin, device_id, plate FROM jt808_registration WHERE phone = \\?").
		WithArgs("40692934322").
		WillReturnRows(sqlmock.NewRows([]string{"vin", "device_id", "plate"}).AddRow("unknown", "18285", "粤AG18285"))
	mock.ExpectQuery("SELECT vin FROM vehicle_identity_binding WHERE plate = \\?").
		WithArgs("粤AG18285").
		WillReturnRows(sqlmock.NewRows([]string{"vin"}).AddRow("LNXNEGRR7SR318212"))
	mock.ExpectExec("INSERT INTO jt808_registration").
		WillReturnResult(sqlmock.NewResult(1, 1))

	resolver := NewMySQLResolver(db, "vehicle_identity_binding")
	env, err := resolver.Resolve(context.Background(), envelope.FrameEnvelope{
		Protocol:       envelope.ProtocolJT808,
		MessageID:      "0x0200",
		Phone:          "40692934322",
		SourceEndpoint: "115.231.168.135:47822",
		Parsed:         map[string]any{},
		Fields: map[string]any{
			envelope.FieldLatitude:  30.1,
			envelope.FieldLongitude: 120.1,
		},
	})
	if err != nil {
		t.Fatalf("Resolve() error = %v", err)
	}
	if env.VIN != "LNXNEGRR7SR318212" {
		t.Fatalf("vin = %q", env.VIN)
	}
	if env.DeviceID != "18285" || env.Plate != "粤AG18285" {
		t.Fatalf("registration identity not copied: device=%q plate=%q", env.DeviceID, env.Plate)
	}
	identity, ok := env.Parsed["identity"].(map[string]any)
	if !ok || identity["source"] != "jt808_registration.plate" {
		t.Fatalf("identity metadata = %#v", env.Parsed["identity"])
	}
	if err := mock.ExpectationsWereMet(); err != nil {
		t.Fatalf("sql expectations: %v", err)
	}
}

func TestMySQLResolverCachesIdentityMissesForHighFrequencyFrames(t *testing.T) {
	db, mock := newMockDB(t)
	defer db.Close()
	mock.ExpectQuery("SELECT vin FROM vehicle_identity_binding WHERE phone = \\?").
		WithArgs("13307795425").
		WillReturnError(sql.ErrNoRows)

	resolver := NewMySQLResolverWithOptions(db, "vehicle_identity_binding", MySQLResolverOptions{
		LocationTouchInterval: time.Hour,
		LookupCacheTTL:        time.Hour,
	})
	for i := 0; i < 2; i++ {
		_, err := resolver.Resolve(context.Background(), envelope.FrameEnvelope{
			Protocol: envelope.ProtocolJT808,
			Phone:    "013307795425",
			Parsed:   map[string]any{},
		})
		if err != nil {
			t.Fatalf("Resolve() error = %v", err)
		}
	}
	if err := mock.ExpectationsWereMet(); err != nil {
		t.Fatalf("sql expectations: %v", err)
	}
}

func TestMySQLResolverEnsuresMinimalIdentitySchema(t *testing.T) {
	db, mock := newMockDB(t)
	defer db.Close()
	mock.ExpectExec("CREATE TABLE IF NOT EXISTS vehicle_identity_binding").
		WillReturnResult(sqlmock.NewResult(0, 0))
	mock.ExpectExec("ALTER TABLE vehicle_identity_binding ADD COLUMN oem").
		WillReturnResult(sqlmock.NewResult(0, 0))
	mock.ExpectExec("ALTER TABLE vehicle_identity_binding DROP INDEX uk_identity_device").
		WillReturnResult(sqlmock.NewResult(0, 0))
	mock.ExpectExec("ALTER TABLE vehicle_identity_binding DROP COLUMN device_id").
		WillReturnResult(sqlmock.NewResult(0, 0))
	mock.ExpectExec("CREATE TABLE IF NOT EXISTS jt808_registration").
		WillReturnResult(sqlmock.NewResult(0, 0))

	resolver := NewMySQLResolver(db, "vehicle_identity_binding")
	if err := resolver.EnsureSchema(context.Background()); err != nil {
		t.Fatalf("EnsureSchema() error = %v", err)
	}
	if err := mock.ExpectationsWereMet(); err != nil {
		t.Fatalf("sql expectations: %v", err)
	}
}

func TestMySQLResolverIgnoresExistingOEMColumn(t *testing.T) {
	db, mock := newMockDB(t)
	defer db.Close()
	mock.ExpectExec("CREATE TABLE IF NOT EXISTS vehicle_identity_binding").
		WillReturnResult(sqlmock.NewResult(0, 0))
	mock.ExpectExec("ALTER TABLE vehicle_identity_binding ADD COLUMN oem").
		WillReturnError(errors.New("Error 1060 (42S21): Duplicate column name 'oem'"))
	mock.ExpectExec("ALTER TABLE vehicle_identity_binding DROP INDEX uk_identity_device").
		WillReturnError(errors.New("Error 1091 (42000): Can't DROP 'uk_identity_device'; check that column/key exists"))
	mock.ExpectExec("ALTER TABLE vehicle_identity_binding DROP COLUMN device_id").
		WillReturnError(errors.New("Error 1091 (42000): Can't DROP 'device_id'; check that column/key exists"))
	mock.ExpectExec("CREATE TABLE IF NOT EXISTS jt808_registration").
		WillReturnResult(sqlmock.NewResult(0, 0))

	resolver := NewMySQLResolver(db, "vehicle_identity_binding")
	if err := resolver.EnsureSchema(context.Background()); err != nil {
		t.Fatalf("EnsureSchema() error = %v", err)
	}
	if err := mock.ExpectationsWereMet(); err != nil {
		t.Fatalf("sql expectations: %v", err)
	}
}

func TestIdentitySchemaUsesBusinessKeysOnly(t *testing.T) {
	binding := identityBindingTableSQL("vehicle_identity_binding")
	registration := jt808RegistrationTableSQL
	for _, sqlText := range []string{binding, registration} {
		for _, column := range []string{"id BIGINT", "AUTO_INCREMENT", "created_at"} {
			if strings.Contains(sqlText, column) {
				t.Fatalf("identity schema should not contain %s:\n%s", column, sqlText)
			}
		}
	}
	if !strings.Contains(binding, "vin VARCHAR(32) PRIMARY KEY") {
		t.Fatalf("binding table should key by vin:\n%s", binding)
	}
	if strings.Contains(binding, "device_id") {
		t.Fatalf("binding table should not contain device_id:\n%s", binding)
	}
	if !strings.Contains(registration, "phone VARCHAR(32) PRIMARY KEY") {
		t.Fatalf("registration table should key by phone:\n%s", registration)
	}
}

func newMockDB(t *testing.T) (*sql.DB, sqlmock.Sqlmock) {
	t.Helper()
	db, mock, err := sqlmock.New()
	if err != nil {
		t.Fatalf("sqlmock.New() error = %v", err)
	}
	return db, mock
}