342 lines
9.6 KiB
Go
342 lines
9.6 KiB
Go
package model
|
|
|
|
import (
|
|
"fmt"
|
|
"strings"
|
|
"testing"
|
|
|
|
"modelRT/constants"
|
|
)
|
|
|
|
func TestFuzzyRecommendOffsetUsesFullMatchedInput(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
searchPrefix string
|
|
searchInput string
|
|
want int
|
|
}{
|
|
{
|
|
name: "zone fuzzy prefix",
|
|
searchPrefix: "grid000",
|
|
searchInput: "z",
|
|
want: len([]rune("grid000.z")),
|
|
},
|
|
{
|
|
name: "level one fuzzy",
|
|
searchPrefix: "",
|
|
searchInput: "g",
|
|
want: len([]rune("g")),
|
|
},
|
|
{
|
|
name: "measurement fuzzy preserves config token",
|
|
searchPrefix: "grid.zone.station.nspath.comp.config",
|
|
searchInput: "m",
|
|
want: len([]rune("grid.zone.station.nspath.comp.config.m")),
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
got := fuzzyRecommendOffset(tt.searchPrefix, tt.searchInput)
|
|
if got != tt.want {
|
|
t.Fatalf("expected offset %d, got %d", tt.want, got)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestNormalizeRecommendResultsUsesInputLengthForExactCompletion(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
input string
|
|
}{
|
|
{
|
|
name: "full token1 to token7 structure",
|
|
input: "grid000.zone000.station000.220kV_学府路1-testProject1.compTag.config.IA_rms_CTA-testProject1",
|
|
},
|
|
{
|
|
name: "local token4 to token7 structure",
|
|
input: "220kV_学府路1-testProject1.IA_rms_CTA-testProject1",
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
results := map[string]SearchResult{
|
|
constants.MeasTagRecommendHierarchyType.String(): {
|
|
RecommendType: constants.MeasTagRecommendHierarchyType,
|
|
QueryDatas: []string{""},
|
|
IsFuzzy: false,
|
|
},
|
|
}
|
|
|
|
got := normalizeRecommendResults(tt.input, results)
|
|
result := got[constants.MeasTagRecommendHierarchyType.String()]
|
|
wantOffset := len([]rune(tt.input))
|
|
if result.Offset != wantOffset {
|
|
t.Fatalf("expected offset %d, got %d", wantOffset, result.Offset)
|
|
}
|
|
if len(result.QueryDatas) != 0 {
|
|
t.Fatalf("expected exact completion to return no suffix, got %v", result.QueryDatas)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestNormalizeRecommendResultsUsesInputLengthForLevelContinuation(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
input string
|
|
recommendType constants.RecommendHierarchyType
|
|
}{
|
|
{
|
|
name: "token1 grid can continue",
|
|
input: "grid000",
|
|
recommendType: constants.GridRecommendHierarchyType,
|
|
},
|
|
{
|
|
name: "token1 token2 zone can continue",
|
|
input: "grid000.zone000",
|
|
recommendType: constants.ZoneRecommendHierarchyType,
|
|
},
|
|
{
|
|
name: "token1 token2 token3 station can continue",
|
|
input: "grid000.zone000.station000",
|
|
recommendType: constants.StationRecommendHierarchyType,
|
|
},
|
|
{
|
|
name: "token1 token2 token3 token4 nspath can continue",
|
|
input: "grid000.zone000.station000.110kV_TV-demoProject",
|
|
recommendType: constants.CompNSPathRecommendHierarchyType,
|
|
},
|
|
{
|
|
name: "token1 token2 token3 token4 token5 compTag can continue",
|
|
input: "grid000.zone000.station000.110kV_TV-demoProject.cable_26-demoProject110kV_TV",
|
|
recommendType: constants.CompTagRecommendHierarchyType,
|
|
},
|
|
{
|
|
name: "token1 through token6 config can continue",
|
|
input: "grid000.zone000.station000.110kV_TV-demoProject.cable_26-demoProject110kV_TV.base_extend",
|
|
recommendType: constants.ConfigRecommendHierarchyType,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
results := map[string]SearchResult{
|
|
tt.recommendType.String(): {
|
|
RecommendType: tt.recommendType,
|
|
QueryDatas: []string{"."},
|
|
IsFuzzy: false,
|
|
},
|
|
}
|
|
|
|
got := normalizeRecommendResults(tt.input, results)
|
|
result := got[tt.recommendType.String()]
|
|
wantOffset := len([]rune(tt.input))
|
|
if result.Offset != wantOffset {
|
|
t.Fatalf("expected offset %d, got %d", wantOffset, result.Offset)
|
|
}
|
|
if len(result.QueryDatas) != 1 || result.QueryDatas[0] != "." {
|
|
t.Fatalf("expected level continuation '.', got %v", result.QueryDatas)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestNormalizeRecommendResultsKeepsFallbackOffsetZero(t *testing.T) {
|
|
input := "x"
|
|
results := map[string]SearchResult{
|
|
constants.GridRecommendHierarchyType.String(): {
|
|
RecommendType: constants.GridRecommendHierarchyType,
|
|
QueryDatas: []string{"grid000", "grid001"},
|
|
IsFuzzy: true,
|
|
IsFallback: true,
|
|
Offset: 0,
|
|
},
|
|
constants.CompNSPathRecommendHierarchyType.String(): {
|
|
RecommendType: constants.CompNSPathRecommendHierarchyType,
|
|
QueryDatas: []string{"nspath000", "nspath001"},
|
|
IsFuzzy: true,
|
|
IsFallback: true,
|
|
Offset: 0,
|
|
},
|
|
}
|
|
|
|
got := normalizeRecommendResults(input, results)
|
|
for key, result := range got {
|
|
if result.Offset != 0 {
|
|
t.Fatalf("expected fallback offset 0 for %s, got %d", key, result.Offset)
|
|
}
|
|
if len(result.QueryDatas) != 2 {
|
|
t.Fatalf("expected fallback recommends to remain intact for %s, got %v", key, result.QueryDatas)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestNormalizeRecommendResultsKeepsParentPrefixOffsetForSpecificFallback(t *testing.T) {
|
|
nsPath := "220kV_学府路1-testProject1"
|
|
input := nsPath + ".x"
|
|
offset := recommendPrefixOffset([]string{nsPath})
|
|
results := map[string]SearchResult{
|
|
constants.CompTagRecommendHierarchyType.String(): {
|
|
RecommendType: constants.CompTagRecommendHierarchyType,
|
|
QueryDatas: []string{
|
|
nsPath + ".CTA-testProject1220kV_学府路1",
|
|
nsPath + ".CB-testProject1220kV_学府路1",
|
|
},
|
|
IsFuzzy: true,
|
|
IsFallback: true,
|
|
Offset: offset,
|
|
},
|
|
constants.MeasTagRecommendHierarchyType.String(): {
|
|
RecommendType: constants.MeasTagRecommendHierarchyType,
|
|
QueryDatas: []string{
|
|
nsPath + ".IA_rms_CTA-testProject1",
|
|
nsPath + ".IB_rms_CTA-testProject1",
|
|
},
|
|
IsFuzzy: true,
|
|
IsFallback: true,
|
|
Offset: offset,
|
|
},
|
|
}
|
|
|
|
got := normalizeRecommendResults(input, results)
|
|
if offset != 24 {
|
|
t.Fatalf("expected sample parent prefix offset 24, got %d", offset)
|
|
}
|
|
for key, result := range got {
|
|
if result.Offset != 24 {
|
|
t.Fatalf("expected specific fallback offset 24 for %s, got %d", key, result.Offset)
|
|
}
|
|
for _, recommend := range result.QueryDatas {
|
|
if strings.HasPrefix(recommend, nsPath+".") {
|
|
t.Fatalf("expected trimmed fallback recommend for %s, got %s", key, recommend)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestRecommendGroupTokens(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
inputSlice []string
|
|
wantCompTag string
|
|
wantConfig string
|
|
wantOK bool
|
|
}{
|
|
{
|
|
name: "full token1 to token7 input",
|
|
inputSlice: []string{"grid000", "zone000", "station000", "nspath", "comp_tag", "base_extend", ""},
|
|
wantCompTag: "comp_tag",
|
|
wantConfig: "base_extend",
|
|
wantOK: true,
|
|
},
|
|
{
|
|
name: "local token4 to token7 input",
|
|
inputSlice: []string{"nspath", "comp_tag", "component", ""},
|
|
wantCompTag: "comp_tag",
|
|
wantConfig: "component",
|
|
wantOK: true,
|
|
},
|
|
{
|
|
name: "missing config token",
|
|
inputSlice: []string{"nspath", ""},
|
|
wantOK: false,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
gotCompTag, gotConfig, gotOK := recommendGroupTokens(tt.inputSlice)
|
|
if gotOK != tt.wantOK {
|
|
t.Fatalf("expected ok %t, got %t", tt.wantOK, gotOK)
|
|
}
|
|
if gotCompTag != tt.wantCompTag || gotConfig != tt.wantConfig {
|
|
t.Fatalf("expected compTag/config %q/%q, got %q/%q", tt.wantCompTag, tt.wantConfig, gotCompTag, gotConfig)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestFallbackSpecificSetKey(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
hierarchy constants.RecommendHierarchyType
|
|
inputSlice []string
|
|
want string
|
|
wantOK bool
|
|
}{
|
|
{
|
|
name: "zone fallback uses grid specific set",
|
|
hierarchy: constants.ZoneRecommendHierarchyType,
|
|
inputSlice: []string{"grid000", "z"},
|
|
want: fmt.Sprintf(constants.RedisSpecGridZoneSetKey, "grid000"),
|
|
wantOK: true,
|
|
},
|
|
{
|
|
name: "component tag fallback uses previous nspath token",
|
|
hierarchy: constants.CompTagRecommendHierarchyType,
|
|
inputSlice: []string{"grid000", "I"},
|
|
want: fmt.Sprintf(constants.RedisSpecCompNSPathCompTagSetKey, "grid000"),
|
|
wantOK: true,
|
|
},
|
|
{
|
|
name: "measurement fallback skips config token and uses component tag",
|
|
hierarchy: constants.MeasTagRecommendHierarchyType,
|
|
inputSlice: []string{"nspath", "comp_tag", "config", "m"},
|
|
want: fmt.Sprintf(constants.RedisSpecCompTagMeasSetKey, "comp_tag"),
|
|
wantOK: true,
|
|
},
|
|
{
|
|
name: "config fallback has no parent specific set",
|
|
hierarchy: constants.ConfigRecommendHierarchyType,
|
|
inputSlice: []string{"nspath", "comp_tag", ""},
|
|
wantOK: false,
|
|
},
|
|
{
|
|
name: "missing previous token",
|
|
hierarchy: constants.ZoneRecommendHierarchyType,
|
|
inputSlice: []string{"z"},
|
|
wantOK: false,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
got, ok := fallbackSpecificSetKey(tt.hierarchy, tt.inputSlice)
|
|
if ok != tt.wantOK {
|
|
t.Fatalf("expected ok %t, got %t", tt.wantOK, ok)
|
|
}
|
|
if got != tt.want {
|
|
t.Fatalf("expected key %q, got %q", tt.want, got)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestShouldFallbackToInitialRecommend(t *testing.T) {
|
|
tests := []struct {
|
|
input string
|
|
want bool
|
|
}{
|
|
{input: "", want: false},
|
|
{input: ".", want: true},
|
|
{input: ".x", want: true},
|
|
{input: "..x", want: true},
|
|
{input: "...x", want: true},
|
|
{input: "grid000", want: false},
|
|
{input: "grid000.", want: false},
|
|
{input: "grid000.zone000", want: false},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.input, func(t *testing.T) {
|
|
got := shouldFallbackToInitialRecommend(tt.input)
|
|
if got != tt.want {
|
|
t.Fatalf("expected %t, got %t", tt.want, got)
|
|
}
|
|
})
|
|
}
|
|
}
|