mirror of
https://github.com/AlexxIT/go2rtc.git
synced 2026-04-22 23:57:20 +08:00
Sergey Krashevich
138 lines
3.7 KiB
Go
138 lines
3.7 KiB
Go
// Author: Sergei "svk" Krashevich <svk@svk.su>
|
|
package hksv
|
|
|
|
import (
|
|
"crypto/ed25519"
|
|
"encoding/hex"
|
|
"regexp"
|
|
"testing"
|
|
|
|
"github.com/AlexxIT/go2rtc/pkg/hap"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
// --- CalcName ---
|
|
|
|
func TestCalcName_CustomName(t *testing.T) {
|
|
require.Equal(t, "MyCamera", CalcName("MyCamera", "anything"))
|
|
}
|
|
|
|
func TestCalcName_Generated(t *testing.T) {
|
|
name := CalcName("", "camera1")
|
|
require.Regexp(t, `^go2rtc-[0-9A-F]{4}$`, name)
|
|
}
|
|
|
|
func TestCalcName_Deterministic(t *testing.T) {
|
|
require.Equal(t, CalcName("", "seed"), CalcName("", "seed"))
|
|
}
|
|
|
|
func TestCalcName_DifferentSeeds(t *testing.T) {
|
|
require.NotEqual(t, CalcName("", "a"), CalcName("", "b"))
|
|
}
|
|
|
|
// --- CalcDeviceID ---
|
|
|
|
var macRe = regexp.MustCompile(`^[0-9A-F]{2}(:[0-9A-F]{2}){5}$`)
|
|
|
|
func TestCalcDeviceID_Generated(t *testing.T) {
|
|
id := CalcDeviceID("", "seed")
|
|
require.Regexp(t, macRe, id)
|
|
}
|
|
|
|
func TestCalcDeviceID_CustomFull(t *testing.T) {
|
|
// Full MAC-length ID returned as-is
|
|
require.Equal(t, "AA:BB:CC:DD:EE:FF", CalcDeviceID("AA:BB:CC:DD:EE:FF", "seed"))
|
|
}
|
|
|
|
func TestCalcDeviceID_CustomShort(t *testing.T) {
|
|
// Short custom ID used as seed instead
|
|
id := CalcDeviceID("short", "seed")
|
|
require.Regexp(t, macRe, id)
|
|
// Should differ from empty seed because "short" is used as seed
|
|
require.NotEqual(t, CalcDeviceID("", "seed"), id)
|
|
}
|
|
|
|
func TestCalcDeviceID_Deterministic(t *testing.T) {
|
|
require.Equal(t, CalcDeviceID("", "cam1"), CalcDeviceID("", "cam1"))
|
|
}
|
|
|
|
// --- CalcDevicePrivate ---
|
|
|
|
func TestCalcDevicePrivate_Generated(t *testing.T) {
|
|
key := CalcDevicePrivate("", "seed")
|
|
require.Len(t, key, ed25519.PrivateKeySize)
|
|
}
|
|
|
|
func TestCalcDevicePrivate_ValidHex(t *testing.T) {
|
|
// Generate a key, encode to hex, pass back — should get same key
|
|
original := CalcDevicePrivate("", "seed")
|
|
hexStr := hex.EncodeToString(original)
|
|
restored := CalcDevicePrivate(hexStr, "other-seed")
|
|
require.Equal(t, original, restored)
|
|
}
|
|
|
|
func TestCalcDevicePrivate_InvalidHex(t *testing.T) {
|
|
// Invalid hex treated as seed
|
|
key := CalcDevicePrivate("not-hex", "seed")
|
|
require.Len(t, key, ed25519.PrivateKeySize)
|
|
// "not-hex" is used as seed, not "seed"
|
|
require.NotEqual(t, CalcDevicePrivate("", "seed"), key)
|
|
}
|
|
|
|
func TestCalcDevicePrivate_ShortHex(t *testing.T) {
|
|
// Valid hex but too short for ed25519 — treated as seed
|
|
key := CalcDevicePrivate("abcd", "seed")
|
|
require.Len(t, key, ed25519.PrivateKeySize)
|
|
}
|
|
|
|
func TestCalcDevicePrivate_Deterministic(t *testing.T) {
|
|
require.Equal(t, CalcDevicePrivate("", "x"), CalcDevicePrivate("", "x"))
|
|
}
|
|
|
|
func TestCalcDevicePrivate_SignsCorrectly(t *testing.T) {
|
|
// Verify the generated key is actually usable for signing
|
|
key := ed25519.PrivateKey(CalcDevicePrivate("", "seed"))
|
|
msg := []byte("test message")
|
|
sig := ed25519.Sign(key, msg)
|
|
pub := key.Public().(ed25519.PublicKey)
|
|
require.True(t, ed25519.Verify(pub, msg, sig))
|
|
}
|
|
|
|
// --- CalcSetupID ---
|
|
|
|
func TestCalcSetupID(t *testing.T) {
|
|
id := CalcSetupID("seed")
|
|
require.Regexp(t, `^[0-9A-F]{4}$`, id)
|
|
}
|
|
|
|
func TestCalcSetupID_Deterministic(t *testing.T) {
|
|
require.Equal(t, CalcSetupID("x"), CalcSetupID("x"))
|
|
}
|
|
|
|
func TestCalcSetupID_DifferentSeeds(t *testing.T) {
|
|
require.NotEqual(t, CalcSetupID("a"), CalcSetupID("b"))
|
|
}
|
|
|
|
// --- CalcCategoryID ---
|
|
|
|
func TestCalcCategoryID(t *testing.T) {
|
|
tests := []struct {
|
|
input string
|
|
expected string
|
|
}{
|
|
{"", hap.CategoryCamera},
|
|
{"camera", hap.CategoryCamera},
|
|
{"bridge", hap.CategoryBridge},
|
|
{"doorbell", hap.CategoryDoorbell},
|
|
{"5", "5"},
|
|
{"17", "17"},
|
|
{"0", hap.CategoryCamera}, // Atoi("0") == 0, not > 0
|
|
{"abc", hap.CategoryCamera}, // unknown string
|
|
}
|
|
for _, tc := range tests {
|
|
t.Run("input="+tc.input, func(t *testing.T) {
|
|
require.Equal(t, tc.expected, CalcCategoryID(tc.input))
|
|
})
|
|
}
|
|
}
|