135 lines
4 KiB
Go
135 lines
4 KiB
Go
package main
|
|
|
|
import (
|
|
"reflect"
|
|
"testing"
|
|
)
|
|
|
|
// providerMapEntryCase describes one provider map entry verification case.
|
|
type providerMapEntryCase struct {
|
|
name string
|
|
entries map[string]interface{}
|
|
selector string
|
|
wantPath string
|
|
wantValue interface{}
|
|
}
|
|
|
|
// providerMapEntryCases is the table of provider map entry verification cases.
|
|
var providerMapEntryCases = []providerMapEntryCase{
|
|
{
|
|
name: "scalar value matches selector",
|
|
entries: map[string]interface{}{"scalar-provider": "gx10-vllm"},
|
|
selector: "gx10-vllm",
|
|
wantPath: "model.active_edge_model_group.providers.scalar-provider",
|
|
wantValue: "gx10-vllm",
|
|
},
|
|
{
|
|
name: "entity id matches selector",
|
|
entries: map[string]interface{}{
|
|
"some-other-key": map[string]interface{}{
|
|
"id": "gx10-vllm",
|
|
"type": "vllm",
|
|
"region": "us",
|
|
},
|
|
},
|
|
selector: "gx10-vllm",
|
|
wantPath: "model.active_edge_model_group.providers.some-other-key",
|
|
wantValue: map[string]interface{}{"id": "gx10-vllm", "type": "vllm", "region": "us"},
|
|
},
|
|
{
|
|
name: "entity provider field matches selector",
|
|
entries: map[string]interface{}{
|
|
"another-key": map[string]interface{}{
|
|
"provider": "gx10-vllm",
|
|
"type": "vllm",
|
|
},
|
|
},
|
|
selector: "gx10-vllm",
|
|
wantPath: "model.active_edge_model_group.providers.another-key",
|
|
wantValue: map[string]interface{}{"provider": "gx10-vllm", "type": "vllm"},
|
|
},
|
|
{
|
|
name: "key and value both match selector dedupes",
|
|
entries: map[string]interface{}{"gx10-vllm": "gx10-vllm"},
|
|
selector: "gx10-vllm",
|
|
wantPath: "model.active_edge_model_group.providers.gx10-vllm",
|
|
wantValue: "gx10-vllm",
|
|
},
|
|
}
|
|
|
|
// TestQueryProviderMatchesMapEntries verifies each provider map entry shape
|
|
// with an independent fixture so scalar, entity id, entity provider, and
|
|
// key+value dedupe cases run in isolation.
|
|
func TestQueryProviderMatchesMapEntries(t *testing.T) {
|
|
for _, tc := range providerMapEntryCases {
|
|
tc := tc
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
verifyProviderMapEntry(t, tc)
|
|
})
|
|
}
|
|
}
|
|
|
|
// verifyProviderMapEntry runs the query and asserts path/value/dedupe for one case.
|
|
func verifyProviderMapEntry(t *testing.T, tc providerMapEntryCase) {
|
|
t.Helper()
|
|
data := parseFixture(t)
|
|
setProviderEntries(t, data, tc.entries)
|
|
matches := queryProviders(data, tc.selector)
|
|
assertProviderEntryMatch(t, matches, tc)
|
|
}
|
|
|
|
// assertProviderEntryMatch checks that matches contains the expected path
|
|
// with the exact value, no duplicate paths, and paths sorted ascending.
|
|
func assertProviderEntryMatch(t *testing.T, matches []match, tc providerMapEntryCase) {
|
|
t.Helper()
|
|
if len(matches) == 0 {
|
|
t.Fatalf("expected at least 1 match for %q, got 0", tc.selector)
|
|
}
|
|
found := false
|
|
for _, m := range matches {
|
|
if m.Path == tc.wantPath {
|
|
found = true
|
|
if !reflect.DeepEqual(m.Value, tc.wantValue) {
|
|
t.Errorf("value at %s = %#v, want %#v", tc.wantPath, m.Value, tc.wantValue)
|
|
}
|
|
break
|
|
}
|
|
}
|
|
if !found {
|
|
t.Errorf("expected match at %s for %q, got %+v", tc.wantPath, tc.selector, matches)
|
|
}
|
|
assertMatchPathsSorted(t, matches)
|
|
pathCount := make(map[string]int)
|
|
for _, m := range matches {
|
|
pathCount[m.Path]++
|
|
}
|
|
for p, count := range pathCount {
|
|
if count > 1 {
|
|
t.Errorf("duplicate path %s: %d", p, count)
|
|
}
|
|
}
|
|
}
|
|
|
|
// assertMatchPathsSorted verifies that match paths are in ascending order.
|
|
func assertMatchPathsSorted(t *testing.T, matches []match) {
|
|
t.Helper()
|
|
for i := 1; i < len(matches); i++ {
|
|
if matches[i].Path < matches[i-1].Path {
|
|
t.Errorf("matches not sorted: %s < %s", matches[i].Path, matches[i-1].Path)
|
|
}
|
|
}
|
|
}
|
|
|
|
// setProviderEntries replaces active_edge_model_group.providers with the given entries.
|
|
func setProviderEntries(t *testing.T, data map[string]interface{}, entries map[string]interface{}) {
|
|
t.Helper()
|
|
model, ok := data["model"].(map[string]interface{})
|
|
if !ok {
|
|
t.Fatalf("model not a map")
|
|
}
|
|
activeGroup, ok := model["active_edge_model_group"].(map[string]interface{})
|
|
if !ok {
|
|
t.Fatalf("active_edge_model_group not a map")
|
|
}
|
|
activeGroup["providers"] = entries
|
|
}
|