131 lines
4.2 KiB
Go
131 lines
4.2 KiB
Go
// Copyright 2026 Alibaba Group
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
package main
|
|
|
|
import (
|
|
"bytes"
|
|
"os"
|
|
"path/filepath"
|
|
"testing"
|
|
|
|
"github.com/DingTalk-Real-AI/dingtalk-workspace-cli/internal/interfacesnapshot"
|
|
)
|
|
|
|
func TestCrossPlatformCoverageRunGenerateCapturesActualRootOffline(t *testing.T) {
|
|
var stdout, stderr bytes.Buffer
|
|
if exitCode := run([]string{"generate"}, &stdout, &stderr); exitCode != 0 {
|
|
t.Fatalf("run(generate) exit=%d stderr=%s", exitCode, stderr.String())
|
|
}
|
|
snapshot, err := interfacesnapshot.Read(bytes.NewReader(stdout.Bytes()))
|
|
if err != nil {
|
|
t.Fatalf("decode generated snapshot: %v", err)
|
|
}
|
|
|
|
commands := make(map[string]interfacesnapshot.Command, len(snapshot.Commands))
|
|
for _, command := range snapshot.Commands {
|
|
commands[command.Path] = command
|
|
}
|
|
for _, path := range []string{"dws", "dws chat", "dws dev app create"} {
|
|
if _, ok := commands[path]; !ok {
|
|
t.Errorf("actual root snapshot is missing %q", path)
|
|
}
|
|
}
|
|
for _, path := range []string{"dws completion", "dws help"} {
|
|
if _, ok := commands[path]; ok {
|
|
t.Errorf("framework-noise path %q leaked into snapshot", path)
|
|
}
|
|
}
|
|
|
|
create := commands["dws dev app create"]
|
|
if !hasFlag(create.LocalFlags, "name", "string") {
|
|
t.Errorf("dev app create local flags do not contain --name string: %#v", create.LocalFlags)
|
|
}
|
|
if !hasFlag(create.InheritedFlags, "profile", "string") {
|
|
t.Errorf("dev app create inherited flags do not contain --profile string: %#v", create.InheritedFlags)
|
|
}
|
|
}
|
|
|
|
func TestCrossPlatformCoverageRunCompareUsesBothSnapshotInputsAndExitCode(t *testing.T) {
|
|
current := commandSnapshot("dws")
|
|
mergeBase := commandSnapshot("dws")
|
|
stable := commandSnapshot("dws", "dws legacy")
|
|
|
|
dir := t.TempDir()
|
|
currentPath := writeSnapshot(t, dir, "current.json", current)
|
|
mergeBasePath := writeSnapshot(t, dir, "base.json", mergeBase)
|
|
stablePath := writeSnapshot(t, dir, "stable.json", stable)
|
|
|
|
var stdout, stderr bytes.Buffer
|
|
exitCode := run([]string{
|
|
"compare",
|
|
"--current", currentPath,
|
|
"--base", mergeBasePath,
|
|
"--stable", stablePath,
|
|
}, &stdout, &stderr)
|
|
if exitCode != 1 {
|
|
t.Fatalf("run(compare) exit=%d, want 1; stdout=%s stderr=%s", exitCode, stdout.String(), stderr.String())
|
|
}
|
|
if !bytes.Contains(stdout.Bytes(), []byte(`"reference": "main"`)) ||
|
|
!bytes.Contains(stdout.Bytes(), []byte(`"reference": "stable"`)) ||
|
|
!bytes.Contains(stdout.Bytes(), []byte(`"kind": "command_removed"`)) {
|
|
t.Fatalf("comparison report does not contain both references and the blocking change:\n%s", stdout.String())
|
|
}
|
|
}
|
|
|
|
func commandSnapshot(paths ...string) interfacesnapshot.Snapshot {
|
|
commands := make([]interfacesnapshot.Command, 0, len(paths))
|
|
for _, path := range paths {
|
|
commands = append(commands, interfacesnapshot.Command{
|
|
Path: path,
|
|
Aliases: []string{},
|
|
LocalFlags: []interfacesnapshot.Flag{},
|
|
InheritedFlags: []interfacesnapshot.Flag{},
|
|
})
|
|
}
|
|
return interfacesnapshot.Snapshot{
|
|
SchemaVersion: interfacesnapshot.SchemaVersion,
|
|
Rules: interfacesnapshot.Rules{
|
|
ExcludedCommandSubtrees: []string{},
|
|
ExcludedFlags: []string{},
|
|
},
|
|
Commands: commands,
|
|
}
|
|
}
|
|
|
|
func writeSnapshot(t *testing.T, dir, name string, snapshot interfacesnapshot.Snapshot) string {
|
|
t.Helper()
|
|
path := filepath.Join(dir, name)
|
|
file, err := os.Create(path)
|
|
if err != nil {
|
|
t.Fatalf("create %s: %v", path, err)
|
|
}
|
|
if err := interfacesnapshot.Write(file, snapshot); err != nil {
|
|
file.Close()
|
|
t.Fatalf("write %s: %v", path, err)
|
|
}
|
|
if err := file.Close(); err != nil {
|
|
t.Fatalf("close %s: %v", path, err)
|
|
}
|
|
return path
|
|
}
|
|
|
|
func hasFlag(flags []interfacesnapshot.Flag, name, flagType string) bool {
|
|
for _, flag := range flags {
|
|
if flag.Name == name && flag.Type == flagType {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|