package protocol import ( "go/ast" "go/parser" "go/token" "strconv" "strings" "testing" ) func TestSignMessageHMACVector(t *testing.T) { // Standard HMAC-SHA256 sanity vector. Anchors that SignMessage matches // the canonical RFC 4231 algorithm so signatures stay interoperable // with peers that compute the same digest. got := SignMessage("key", []byte("hello")) want := "9307b3b915efb5171ff14d8cb55fbcc798c6c0ef1456d66ded1a6aa723a58b7b" if got != want { t.Fatalf("SignMessage(key, hello) = %s, want %s", got, want) } } func TestSignMessageDeterministic(t *testing.T) { a := SignMessage("test-key", []byte("2026-01-01 12:00:00|123456789")) b := SignMessage("test-key", []byte("2026-01-01 12:00:00|123456789")) if a != b { t.Fatalf("non-deterministic: %s != %s", a, b) } if len(a) != 64 { t.Fatalf("expected 64 hex chars, got %d (%s)", len(a), a) } } func TestIsH264KeyframeBasic(t *testing.T) { // 4-byte start code + IDR (NAL type 5) idr := []byte{0x00, 0x00, 0x00, 0x01, 0x65, 0x88} if !IsH264Keyframe(idr) { t.Fatal("IDR should be detected as keyframe") } // 3-byte start code + SPS (NAL type 7) sps := []byte{0x00, 0x00, 0x01, 0x67, 0x42} if !IsH264Keyframe(sps) { t.Fatal("SPS should be detected as keyframe") } // 4-byte start code + non-IDR slice (NAL type 1) pframe := []byte{0x00, 0x00, 0x00, 0x01, 0x41, 0x9b} if IsH264Keyframe(pframe) { t.Fatal("non-IDR slice should not be detected as keyframe") } // Garbage if IsH264Keyframe([]byte{0xde, 0xad, 0xbe, 0xef}) { t.Fatal("non-H264 bytes should not match") } } // TestCommandTokenConstantsAreUnique guards the command/token byte values in // commands.go against a silent collision. The tokens are matched against the // first byte of every inbound packet, so two names sharing a value means the // wrong handler eats the packet — an added file-manager token that reuses // TOKEN_LOGIN's value would swallow the device's login. Constants outside the // Command*/Token*/Cmd* families are skipped: the file also defines field // offsets, which legitimately repeat small numbers (offset 1 in two packets). func TestCommandTokenConstantsAreUnique(t *testing.T) { fset := token.NewFileSet() file, err := parser.ParseFile(fset, "commands.go", nil, 0) if err != nil { t.Fatalf("parse commands.go: %v", err) } seen := make(map[int64]string) ast.Inspect(file, func(n ast.Node) bool { spec, ok := n.(*ast.ValueSpec) if !ok { return true } for i, name := range spec.Names { // A name without its own expression repeats the previous value. if i >= len(spec.Values) || !isCommandTokenName(name.Name) { continue } lit, ok := spec.Values[i].(*ast.BasicLit) if !ok || lit.Kind != token.INT { continue } v, err := strconv.ParseInt(lit.Value, 0, 64) if err != nil { continue } if prev, dup := seen[v]; dup { t.Errorf("%s and %s both use %d", prev, name.Name, v) continue } seen[v] = name.Name } return true }) if len(seen) < 20 { t.Fatalf("only %d command/token constants scanned; did commands.go change shape?", len(seen)) } } func isCommandTokenName(name string) bool { return strings.HasPrefix(name, "Command") || strings.HasPrefix(name, "Token") || strings.HasPrefix(name, "Cmd") }