431 lines
20 KiB
Go
431 lines
20 KiB
Go
// Copyright 2026 Alibaba Group
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
package cli
|
|
|
|
import (
|
|
"errors"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/spf13/cobra"
|
|
)
|
|
|
|
func TestCrossPlatformCoverageEmbeddedRuntimeSchemaExclusionDecodeEdges(t *testing.T) {
|
|
previous := embeddedRuntimeSchemaExclusionsJSON
|
|
t.Cleanup(func() { embeddedRuntimeSchemaExclusionsJSON = previous })
|
|
cases := []struct {
|
|
data string
|
|
want string
|
|
}{
|
|
{data: "{", want: "decode"},
|
|
{data: `{"version":2,"groups":[]}`, want: "unsupported"},
|
|
{data: `{"version":1,"groups":[{"id":"","reason":"r","reviewed":true}]}`, want: "not reviewed"},
|
|
{data: `{"version":1,"groups":[{"id":"g","reason":"r","reviewed":true,"commands":[" "]}]}`, want: "empty command"},
|
|
{data: `{"version":1,"groups":[{"id":"g","reason":"r","reviewed":true,"commands":["a b","a b"]}]}`, want: "duplicate"},
|
|
}
|
|
for _, tc := range cases {
|
|
embeddedRuntimeSchemaExclusionsJSON = []byte(tc.data)
|
|
if _, err := EmbeddedRuntimeSchemaExclusions(); err == nil || !strings.Contains(err.Error(), tc.want) {
|
|
t.Errorf("EmbeddedRuntimeSchemaExclusions(%s) error = %v, want %q", tc.data, err, tc.want)
|
|
}
|
|
}
|
|
embeddedRuntimeSchemaExclusionsJSON = previous
|
|
}
|
|
|
|
func TestCrossPlatformCoverageCompletenessWrapperErrorBoundaries(t *testing.T) {
|
|
oldLoad := completenessLoadExclusions
|
|
oldApply := completenessApplyManual
|
|
oldBuild := completenessBuildEffective
|
|
oldBind := completenessBindEffective
|
|
oldRuntime := completenessRuntimeReport
|
|
oldDelivery := completenessDeliveryReport
|
|
oldCollect := completenessCollectEntries
|
|
t.Cleanup(func() {
|
|
completenessLoadExclusions = oldLoad
|
|
completenessApplyManual = oldApply
|
|
completenessBuildEffective = oldBuild
|
|
completenessBindEffective = oldBind
|
|
completenessRuntimeReport = oldRuntime
|
|
completenessDeliveryReport = oldDelivery
|
|
completenessCollectEntries = oldCollect
|
|
})
|
|
root := &cobra.Command{Use: "dws"}
|
|
completenessApplyManual = func(*cobra.Command) (ManualSchemaHintReport, error) {
|
|
return ManualSchemaHintReport{}, errors.New("apply failed")
|
|
}
|
|
if err := ValidateEmbeddedRuntimeSchemaCompleteness(root); err == nil || !strings.Contains(err.Error(), "apply failed") {
|
|
t.Fatalf("apply error = %v", err)
|
|
}
|
|
completenessApplyManual = func(*cobra.Command) (ManualSchemaHintReport, error) { return ManualSchemaHintReport{}, nil }
|
|
completenessBuildEffective = func(*cobra.Command) (EffectiveCommandRegistry, error) {
|
|
return EffectiveCommandRegistry{}, errors.New("build failed")
|
|
}
|
|
if err := ValidateEmbeddedRuntimeSchemaCompleteness(root); err == nil || !strings.Contains(err.Error(), "build failed") {
|
|
t.Fatalf("build error = %v", err)
|
|
}
|
|
completenessBuildEffective = func(*cobra.Command) (EffectiveCommandRegistry, error) { return EffectiveCommandRegistry{}, nil }
|
|
completenessBindEffective = func(*cobra.Command, EffectiveCommandRegistry) (BoundCommandRegistry, error) {
|
|
return BoundCommandRegistry{}, errors.New("bind failed")
|
|
}
|
|
if err := ValidateEmbeddedRuntimeSchemaCompleteness(root); err == nil || !strings.Contains(err.Error(), "bind failed") {
|
|
t.Fatalf("bind error = %v", err)
|
|
}
|
|
|
|
completenessLoadExclusions = func() ([]RuntimeSchemaExclusion, error) { return nil, errors.New("exclusions failed") }
|
|
if err := validateResolvedRuntimeSchemaCompleteness(root, BoundCommandRegistry{}); err == nil || !strings.Contains(err.Error(), "exclusions failed") {
|
|
t.Fatalf("resolved exclusions error = %v", err)
|
|
}
|
|
if err := validateResolvedSchemaCatalogDeliveryCompleteness(root, BoundCommandRegistry{}, SchemaCatalogSnapshot{}); err == nil || !strings.Contains(err.Error(), "exclusions failed") {
|
|
t.Fatalf("delivery exclusions error = %v", err)
|
|
}
|
|
completenessLoadExclusions = func() ([]RuntimeSchemaExclusion, error) { return nil, nil }
|
|
|
|
reports := []struct {
|
|
report RuntimeSchemaCompletenessReport
|
|
want string
|
|
}{
|
|
{report: RuntimeSchemaCompletenessReport{DeliveryErrors: []string{"delivery"}}, want: "invalid effective"},
|
|
{report: RuntimeSchemaCompletenessReport{Missing: []string{"missing"}}, want: "missing from Schema"},
|
|
{report: RuntimeSchemaCompletenessReport{InvalidExclusions: []string{"invalid"}}, want: "invalid runtime"},
|
|
{report: RuntimeSchemaCompletenessReport{StaleExclusions: []string{"stale"}}, want: "stale runtime"},
|
|
}
|
|
for _, tc := range reports {
|
|
completenessRuntimeReport = func(*cobra.Command, []RuntimeSchemaExclusion, BoundCommandRegistry) RuntimeSchemaCompletenessReport {
|
|
return tc.report
|
|
}
|
|
if err := validateResolvedRuntimeSchemaCompleteness(root, BoundCommandRegistry{}); err == nil || !strings.Contains(err.Error(), tc.want) {
|
|
t.Errorf("runtime report %#v error = %v, want %q", tc.report, err, tc.want)
|
|
}
|
|
}
|
|
|
|
badSnapshot := SchemaCatalogSnapshot{Catalog: map[string]any{"bad": func() {}}}
|
|
if err := validateSchemaCatalogDeliveryCompletenessFromBound(root, BoundCommandRegistry{}, badSnapshot, nil); err == nil || !strings.Contains(err.Error(), "encode final") {
|
|
t.Fatalf("delivery marshal error = %v", err)
|
|
}
|
|
invalidSnapshot := SchemaCatalogSnapshot{Version: 999, Catalog: map[string]any{}, Tools: map[string]map[string]any{}}
|
|
if err := validateSchemaCatalogDeliveryCompletenessFromBound(root, BoundCommandRegistry{}, invalidSnapshot, nil); err == nil || !strings.Contains(err.Error(), "production loader") {
|
|
t.Fatalf("delivery loader error = %v", err)
|
|
}
|
|
validLoaded := deliveryCoverageLoaded(t)
|
|
for _, tc := range reports {
|
|
completenessDeliveryReport = func(*cobra.Command, loadedSchemaCatalog, []RuntimeSchemaExclusion, BoundCommandRegistry) RuntimeSchemaCompletenessReport {
|
|
return tc.report
|
|
}
|
|
err := validateSchemaCatalogDeliveryCompletenessFromBound(root, BoundCommandRegistry{}, validLoaded.Snapshot, nil)
|
|
if err == nil {
|
|
t.Errorf("delivery report %#v unexpectedly succeeded", tc.report)
|
|
}
|
|
}
|
|
|
|
completenessCollectEntries = func(*cobra.Command) ([]runtimeSchemaEntry, error) { return nil, errors.New("collect failed") }
|
|
report := RuntimeSchemaCompleteness(root, nil)
|
|
if len(report.DeliveryErrors) != 1 || !strings.Contains(report.DeliveryErrors[0], "collect failed") {
|
|
t.Fatalf("collect report = %#v", report)
|
|
}
|
|
}
|
|
|
|
func TestCrossPlatformCoverageCatalogDeliveryCompletenessLoadedIdentityEdges(t *testing.T) {
|
|
oldQuery := deliverySchemaPayload
|
|
oldResolve := deliveryIndexResolve
|
|
oldTool := deliveryToolPayload
|
|
t.Cleanup(func() {
|
|
deliverySchemaPayload = oldQuery
|
|
deliveryIndexResolve = oldResolve
|
|
deliveryToolPayload = oldTool
|
|
})
|
|
reset := func() {
|
|
deliverySchemaPayload = oldQuery
|
|
deliveryIndexResolve = oldResolve
|
|
deliveryToolPayload = oldTool
|
|
}
|
|
root := commandRegistryTestRoot("sample category run", "extra leaf")
|
|
loaded := deliveryCoverageLoaded(t)
|
|
identities := map[string]runtimeSchemaResolvedIdentity{
|
|
"sample category run": {CanonicalPath: "sample.run", Source: "expected-source"},
|
|
"sample legacy execute": {CanonicalPath: "sample.run", Source: "expected-source"},
|
|
}
|
|
|
|
// An unreviewed public leaf has no expected identity and is left to the
|
|
// reverse-completeness report.
|
|
schemaCatalogDeliveryCompletenessAgainstLoadedAndIdentity(root, loaded, nil, identities, nil)
|
|
deliverySchemaPayload = func(loaded loadedSchemaCatalog, args []string) (map[string]any, error) {
|
|
if len(args) > 0 && args[0] == "sample category run" {
|
|
return nil, errors.New("query failed")
|
|
}
|
|
return oldQuery(loaded, args)
|
|
}
|
|
schemaCatalogDeliveryCompletenessAgainstLoadedAndIdentity(root, loaded, nil, identities, nil)
|
|
reset()
|
|
deliverySchemaPayload = func(loaded loadedSchemaCatalog, args []string) (map[string]any, error) {
|
|
if len(args) > 0 && args[0] == "sample category run" {
|
|
return map[string]any{"canonical_path": "other.run"}, nil
|
|
}
|
|
return oldQuery(loaded, args)
|
|
}
|
|
report := schemaCatalogDeliveryCompletenessAgainstLoadedAndIdentity(root, loaded, nil, identities, nil)
|
|
if !strings.Contains(strings.Join(report.DeliveryErrors, ";"), "public CLI path") {
|
|
t.Fatalf("wrong public canonical report = %#v", report)
|
|
}
|
|
reset()
|
|
deliveryIndexResolve = func(SchemaIndex, string) (ToolSpec, bool) { return ToolSpec{}, false }
|
|
report = schemaCatalogDeliveryCompletenessAgainstLoadedAndIdentity(root, loaded, nil, identities, nil)
|
|
if !strings.Contains(strings.Join(report.DeliveryErrors, ";"), "lost canonical") {
|
|
t.Fatalf("lost canonical report = %#v", report)
|
|
}
|
|
reset()
|
|
report = schemaCatalogDeliveryCompletenessAgainstLoadedAndIdentity(root, loaded, nil, identities, nil)
|
|
if !strings.Contains(strings.Join(report.DeliveryErrors, ";"), "identity source") {
|
|
t.Fatalf("identity source report = %#v", report)
|
|
}
|
|
|
|
deliverySchemaPayload = func(loaded loadedSchemaCatalog, args []string) (map[string]any, error) {
|
|
if len(args) > 0 && args[0] == "sample.run" {
|
|
return nil, errors.New("canonical failed")
|
|
}
|
|
return oldQuery(loaded, args)
|
|
}
|
|
report = schemaCatalogDeliveryCompletenessAgainstLoadedAndIdentity(root, loaded, nil, identities, nil)
|
|
if !strings.Contains(strings.Join(report.DeliveryErrors, ";"), "canonical \"sample.run\" is not queryable") {
|
|
t.Fatalf("canonical query report = %#v", report)
|
|
}
|
|
reset()
|
|
deliverySchemaPayload = func(loaded loadedSchemaCatalog, args []string) (map[string]any, error) {
|
|
if len(args) > 0 && args[0] == "sample.run" {
|
|
return map[string]any{"canonical_path": "other.run"}, nil
|
|
}
|
|
return oldQuery(loaded, args)
|
|
}
|
|
report = schemaCatalogDeliveryCompletenessAgainstLoadedAndIdentity(root, loaded, nil, identities, nil)
|
|
if !strings.Contains(strings.Join(report.DeliveryErrors, ";"), "resolves to \"other.run\"") {
|
|
t.Fatalf("canonical mismatch report = %#v", report)
|
|
}
|
|
reset()
|
|
deliveryToolPayload = func(ToolSpec) (map[string]any, error) { return nil, errors.New("render failed") }
|
|
report = schemaCatalogDeliveryCompletenessAgainstLoadedAndIdentity(root, loaded, nil, identities, nil)
|
|
if !strings.Contains(strings.Join(report.DeliveryErrors, ";"), "cannot render typed payload") {
|
|
t.Fatalf("canonical render report = %#v", report)
|
|
}
|
|
reset()
|
|
deliverySchemaPayload = func(loaded loadedSchemaCatalog, args []string) (map[string]any, error) {
|
|
payload, err := oldQuery(loaded, args)
|
|
if len(args) > 0 && args[0] == "sample.run" && err == nil {
|
|
payload["title"] = "changed"
|
|
}
|
|
return payload, err
|
|
}
|
|
report = schemaCatalogDeliveryCompletenessAgainstLoadedAndIdentity(root, loaded, nil, identities, nil)
|
|
if !strings.Contains(strings.Join(report.DeliveryErrors, ";"), "query differs from final ToolSpec") {
|
|
t.Fatalf("canonical drift report = %#v", report)
|
|
}
|
|
reset()
|
|
|
|
missing := map[string]runtimeSchemaResolvedIdentity{}
|
|
report = schemaCatalogDeliveryCompletenessAgainstLoadedAndIdentity(root, loaded, nil, missing, nil)
|
|
if !strings.Contains(strings.Join(report.DeliveryErrors, ";"), "non-executable Schema path") {
|
|
t.Fatalf("missing path report = %#v", report)
|
|
}
|
|
wrongOwner := map[string]runtimeSchemaResolvedIdentity{
|
|
"sample category run": {CanonicalPath: "sample.other"},
|
|
"sample legacy execute": {CanonicalPath: "sample.other"},
|
|
}
|
|
report = schemaCatalogDeliveryCompletenessAgainstLoadedAndIdentity(root, loaded, nil, wrongOwner, nil)
|
|
if !strings.Contains(strings.Join(report.DeliveryErrors, ";"), "owned by sample.other") {
|
|
t.Fatalf("wrong owner report = %#v", report)
|
|
}
|
|
|
|
deliverySchemaPayload = func(loaded loadedSchemaCatalog, args []string) (map[string]any, error) {
|
|
if len(args) > 0 && args[0] == "sample legacy execute" {
|
|
return nil, errors.New("path failed")
|
|
}
|
|
return oldQuery(loaded, args)
|
|
}
|
|
report = schemaCatalogDeliveryCompletenessAgainstLoadedAndIdentity(root, loaded, nil, identities, nil)
|
|
if !strings.Contains(strings.Join(report.DeliveryErrors, ";"), "path \"sample legacy execute\" is not queryable") {
|
|
t.Fatalf("path query report = %#v", report)
|
|
}
|
|
reset()
|
|
deliverySchemaPayload = func(loaded loadedSchemaCatalog, args []string) (map[string]any, error) {
|
|
if len(args) > 0 && args[0] == "sample legacy execute" {
|
|
return map[string]any{"canonical_path": "other.run"}, nil
|
|
}
|
|
return oldQuery(loaded, args)
|
|
}
|
|
report = schemaCatalogDeliveryCompletenessAgainstLoadedAndIdentity(root, loaded, nil, identities, nil)
|
|
if !strings.Contains(strings.Join(report.DeliveryErrors, ";"), "path \"sample legacy execute\" resolves") {
|
|
t.Fatalf("path canonical report = %#v", report)
|
|
}
|
|
reset()
|
|
deliveryToolPayload = func(tool ToolSpec) (map[string]any, error) {
|
|
if tool.Identity.IsAlias {
|
|
return nil, errors.New("alias render failed")
|
|
}
|
|
return oldTool(tool)
|
|
}
|
|
report = schemaCatalogDeliveryCompletenessAgainstLoadedAndIdentity(root, loaded, nil, identities, nil)
|
|
if !strings.Contains(strings.Join(report.DeliveryErrors, ";"), "path \"sample legacy execute\" cannot render") {
|
|
t.Fatalf("path render report = %#v", report)
|
|
}
|
|
reset()
|
|
deliverySchemaPayload = func(loaded loadedSchemaCatalog, args []string) (map[string]any, error) {
|
|
payload, err := oldQuery(loaded, args)
|
|
if len(args) > 0 && args[0] == "sample legacy execute" && err == nil {
|
|
payload["title"] = "changed"
|
|
}
|
|
return payload, err
|
|
}
|
|
report = schemaCatalogDeliveryCompletenessAgainstLoadedAndIdentity(root, loaded, nil, identities, nil)
|
|
if !strings.Contains(strings.Join(report.DeliveryErrors, ";"), "path \"sample legacy execute\" query differs") {
|
|
t.Fatalf("path drift report = %#v", report)
|
|
}
|
|
reset()
|
|
|
|
loaded.Index.registry.Products[0].Tools[0].Identity.Aliases = append(loaded.Index.registry.Products[0].Tools[0].Identity.Aliases, " ", "sample category run")
|
|
schemaCatalogDeliveryCompletenessAgainstLoadedAndIdentity(root, loaded, nil, identities, nil)
|
|
}
|
|
|
|
func TestCrossPlatformCoverageSchemaRegistryProjectionRemainingEdges(t *testing.T) {
|
|
oldRegistry := deliveryRegistryPayload
|
|
oldProduct := renderRegistryProductSummary
|
|
oldQuery := deliverySchemaPayload
|
|
oldTool := deliveryToolPayload
|
|
oldSummary := deliveryToolSummary
|
|
t.Cleanup(func() {
|
|
deliveryRegistryPayload = oldRegistry
|
|
renderRegistryProductSummary = oldProduct
|
|
deliverySchemaPayload = oldQuery
|
|
deliveryToolPayload = oldTool
|
|
deliveryToolSummary = oldSummary
|
|
})
|
|
reset := func() {
|
|
deliveryRegistryPayload = oldRegistry
|
|
renderRegistryProductSummary = oldProduct
|
|
deliverySchemaPayload = oldQuery
|
|
deliveryToolPayload = oldTool
|
|
deliveryToolSummary = oldSummary
|
|
}
|
|
loaded := deliveryCoverageLoaded(t)
|
|
deliveryRegistryPayload = func(SchemaRegistry) (map[string]any, error) { return nil, errors.New("all failed") }
|
|
if got := schemaRegistryProjectionErrors(loaded); len(got) == 0 || !strings.Contains(got[0], "render final Schema --all") {
|
|
t.Fatalf("all render problems = %v", got)
|
|
}
|
|
reset()
|
|
deliveryRegistryPayload = func(SchemaRegistry) (map[string]any, error) {
|
|
return map[string]any{"products": []map[string]any{{"tools": []map[string]any{{}, {"canonical_path": "sample.run"}, {"canonical_path": "sample.run"}}}}}, nil
|
|
}
|
|
problems := schemaRegistryProjectionErrors(loaded)
|
|
if joined := strings.Join(problems, ";"); !strings.Contains(joined, "without canonical_path") || !strings.Contains(joined, "duplicate tool") {
|
|
t.Fatalf("all identity problems = %v", problems)
|
|
}
|
|
reset()
|
|
renderRegistryProductSummary = func(ProductSpec) (map[string]any, error) { return nil, errors.New("product failed") }
|
|
if joined := strings.Join(schemaRegistryProjectionErrors(loaded), ";"); !strings.Contains(joined, "render product") {
|
|
t.Fatalf("product render problems = %s", joined)
|
|
}
|
|
reset()
|
|
deliverySchemaPayload = func(loaded loadedSchemaCatalog, args []string) (map[string]any, error) {
|
|
if len(args) > 0 && args[0] == "sample" {
|
|
return nil, errors.New("product query failed")
|
|
}
|
|
return oldQuery(loaded, args)
|
|
}
|
|
if joined := strings.Join(schemaRegistryProjectionErrors(loaded), ";"); !strings.Contains(joined, "product sample is not queryable") {
|
|
t.Fatalf("product query problems = %s", joined)
|
|
}
|
|
reset()
|
|
deliverySchemaPayload = func(loaded loadedSchemaCatalog, args []string) (map[string]any, error) {
|
|
if len(args) > 0 && args[0] == "sample" {
|
|
return map[string]any{"product": map[string]any{}}, nil
|
|
}
|
|
return oldQuery(loaded, args)
|
|
}
|
|
if joined := strings.Join(schemaRegistryProjectionErrors(loaded), ";"); !strings.Contains(joined, "query differs from final ProductSpec") {
|
|
t.Fatalf("product drift problems = %s", joined)
|
|
}
|
|
reset()
|
|
deliveryToolPayload = func(ToolSpec) (map[string]any, error) { return nil, errors.New("tool failed") }
|
|
if joined := strings.Join(schemaRegistryProjectionErrors(loaded), ";"); !strings.Contains(joined, "render final ToolSpec") {
|
|
t.Fatalf("tool render problems = %s", joined)
|
|
}
|
|
reset()
|
|
deliveryRegistryPayload = func(SchemaRegistry) (map[string]any, error) {
|
|
return map[string]any{"products": []map[string]any{}}, nil
|
|
}
|
|
if joined := strings.Join(schemaRegistryProjectionErrors(loaded), ";"); !strings.Contains(joined, "Schema --all is missing") {
|
|
t.Fatalf("missing all tool problems = %s", joined)
|
|
}
|
|
reset()
|
|
deliveryRegistryPayload = func(registry SchemaRegistry) (map[string]any, error) {
|
|
payload, err := oldRegistry(registry)
|
|
products := schemaMapSlice(payload["products"])
|
|
tools := schemaMapSlice(products[0]["tools"])
|
|
tools[0]["title"] = "changed"
|
|
products[0]["tools"] = tools
|
|
payload["products"] = products
|
|
return payload, err
|
|
}
|
|
if joined := strings.Join(schemaRegistryProjectionErrors(loaded), ";"); !strings.Contains(joined, "differs from final ToolSpec") {
|
|
t.Fatalf("all tool drift problems = %s", joined)
|
|
}
|
|
reset()
|
|
|
|
loaded.Registry.Products[0].Tools[0].Identity.CLIPath = "other group run"
|
|
loaded.Registry.Products[0].Tools[0].Identity.PrimaryCLIPath = "other group run"
|
|
if joined := strings.Join(schemaRegistryProjectionErrors(loaded), ";"); !strings.Contains(joined, "has no typed product") {
|
|
t.Fatalf("missing group product problems = %s", joined)
|
|
}
|
|
loaded = deliveryCoverageLoaded(t)
|
|
deliveryToolSummary = func(ToolSpec) (map[string]any, error) { return nil, errors.New("summary failed") }
|
|
if joined := strings.Join(schemaRegistryProjectionErrors(loaded), ";"); !strings.Contains(joined, "render group") {
|
|
t.Fatalf("group summary problems = %s", joined)
|
|
}
|
|
reset()
|
|
deliverySchemaPayload = func(loaded loadedSchemaCatalog, args []string) (map[string]any, error) {
|
|
if len(args) > 0 && args[0] == "sample category" {
|
|
return nil, errors.New("group failed")
|
|
}
|
|
return oldQuery(loaded, args)
|
|
}
|
|
if joined := strings.Join(schemaRegistryProjectionErrors(deliveryCoverageLoaded(t)), ";"); !strings.Contains(joined, "group sample category is not queryable") {
|
|
t.Fatalf("group query problems = %s", joined)
|
|
}
|
|
reset()
|
|
deliverySchemaPayload = func(loaded loadedSchemaCatalog, args []string) (map[string]any, error) {
|
|
if len(args) > 0 && args[0] == "sample category" {
|
|
return map[string]any{"tools": []map[string]any{}}, nil
|
|
}
|
|
return oldQuery(loaded, args)
|
|
}
|
|
if joined := strings.Join(schemaRegistryProjectionErrors(deliveryCoverageLoaded(t)), ";"); !strings.Contains(joined, "query differs from final ToolSpec summaries") {
|
|
t.Fatalf("group drift problems = %s", joined)
|
|
}
|
|
}
|
|
|
|
func TestCrossPlatformCoverageCompletenessIdentityAndPathHelpersRemainingEdges(t *testing.T) {
|
|
bound := BoundCommandRegistry{Commands: []BoundCommandSpec{
|
|
{CommandSpec: CommandSpec{CanonicalPath: "sample.one", PrimaryCLIPath: "sample run", Visibility: SchemaVisibilityPublic}},
|
|
{CommandSpec: CommandSpec{CanonicalPath: "sample.two", PrimaryCLIPath: "sample run", Visibility: SchemaVisibilityPublic}},
|
|
{CommandSpec: CommandSpec{CanonicalPath: "hidden.tool", PrimaryCLIPath: "hidden run", Visibility: SchemaVisibilityInternal}},
|
|
{CommandSpec: CommandSpec{CanonicalPath: "", PrimaryCLIPath: "empty run", Visibility: SchemaVisibilityPublic}},
|
|
}}
|
|
identities, conflicts := runtimeSchemaIdentityByBound(bound)
|
|
if len(identities) != 1 || len(conflicts) != 1 || !strings.Contains(conflicts[0], "belongs to both") {
|
|
t.Fatalf("identities=%#v conflicts=%v", identities, conflicts)
|
|
}
|
|
if got := sortedUniqueSchemaStrings([]string{" b ", "", "a", "b"}); strings.Join(got, ",") != "a,b" {
|
|
t.Fatalf("sorted unique = %v", got)
|
|
}
|
|
covered := map[string]bool{}
|
|
addSchemaCoveredPath(covered, " dws sample run ")
|
|
addSchemaCoveredPath(covered, " ")
|
|
if !covered["sample run"] || len(covered) != 1 {
|
|
t.Fatalf("covered paths = %#v", covered)
|
|
}
|
|
runtimeSchemaCompletenessFromBound(&cobra.Command{Use: "dws"}, nil, bound)
|
|
emptyRoot := &cobra.Command{Use: "dws", Run: func(*cobra.Command, []string) {}}
|
|
runtimeSchemaCompletenessAgainstPaths(emptyRoot, nil, nil)
|
|
hiddenRoot := &cobra.Command{Use: "dws"}
|
|
hiddenRoot.AddCommand(&cobra.Command{Use: "hidden", Hidden: true, Run: func(*cobra.Command, []string) {}})
|
|
walkPublicRunnableLeaves(hiddenRoot, func(*cobra.Command) { t.Fatal("hidden leaf visited") })
|
|
walkPublicRunnableLeaves(nil, func(*cobra.Command) { t.Fatal("nil root visited") })
|
|
}
|