package gcli_test

import (

"bytes"

"fmt"

"strings"

"testing"

"github.com/gookit/color"

"github.com/gookit/gcli/v3"

"github.com/gookit/goutil/byteutil"

"github.com/gookit/goutil/dump"

"github.com/gookit/goutil/x/assert"

)

// 以下夹具改为工厂函数, 每个用例独立构造全新实例, 消除跨用例的可变状态共享,

// 使 go test -shuffle=on 稳定通过。

func newEmptyCmd() *gcli.Command {

return &gcli.Command{

Name: "empty",

Desc: "an test command",

}

}

func newSimpleCmd() *gcli.Command {

return &gcli.Command{

Name: "simple",

Desc: "an simple command",

Func: func(c *gcli.Command, args []string) error {

dump.Println(c.Path(), args)

c.Ctx.Set("simple", "simple command")

return nil

},

}

}

func newSubCmd() *gcli.Command {

return &gcli.Command{

Name: "sub",

Desc: "an simple sub command",

Func: func(c *gcli.Command, args []string) error {

fmt.Println(c.Path(), args)

return nil

},

}

}

// newAppWithMl 构造一个与原共享 appWithMl 等价的多级命令应用(top1/sub1/sub1-1/top2),

// 每个用例独立调用获得全新实例。

func newAppWithMl() *gcli.App {

return gcli.New(func(app *gcli.App) {

app.ExitOnEnd = false

app.Add(&gcli.Command{

Name: "top1",

Desc: "desc for top1",

Subs: []*gcli.Command{

{

Name: "sub1",

Desc: "desc for top1.sub1",

Func: func(c *gcli.Command, args []string) error {

c.Ctx.Set("msg", c.App().Ctx.Get("top1:sub1"))

return nil

},

Subs: []*gcli.Command{

{

Name: "sub1-1",

Desc: "desc for top1.sub1.sub1-1",

Func: func(c *gcli.Command, args []string) error {

c.Ctx.Set("msg", c.App().Ctx.Get("top1:sub1:sub1-1"))

return nil

},

},

},

},

},

})

app.Add(&gcli.Command{

Name: "top2",

Desc: "desc for top2",

})

})

}

func TestApp_MatchByPath(t *testing.T) {

// is := assert.New(t)

app := gcli.NewApp()

app.Add(

gcli.NewCommand("cmd1", "desc"),

gcli.NewCommand("cmd2", "desc2"),

)

simpleCmd := newSimpleCmd()

simpleCmd.AddCommand(newSubCmd())

app.AddCommand(simpleCmd)

assert.True(t, app.HasCommand(simpleCmd.Name))

c := app.MatchByPath("simple:sub")

assert.NotNil(t, c)

assert.Eq(t, "sub", c.Name)

assert.Eq(t, "simple", c.ParentName())

c = newAppWithMl().FindByPath("top1:sub1")

assert.Eq(t, "sub1", c.Name)

}

func TestApp_Add(t *testing.T) {

is := assert.New(t)

app := gcli.NewApp()

app.Add(gcli.NewCommand("c1", "c1 desc", func(c *gcli.Command) {

is.Eq("c1", c.Name)

}), gcli.NewCommand("c2", "c2 desc", func(c *gcli.Command) {

is.Eq("c2", c.Name)

}))

app.AddCommand(&gcli.Command{

Name: "c3",

Desc: "{$cmd} desc",

Aliases: []string{"alias1"},

Config: func(c *gcli.Command) {

is.Eq("c3", c.Name)

},

})

is.True(app.IsCommand("c1"))

is.True(app.IsCommand("c2"))

is.True(app.HasCommand("c3"))

is.Len(app.CmdNames(), 3)

is.Len(app.CmdNameMap(), 3)

is.NotEmpty(app.CommandNames())

c := gcli.NewCommand("mdl-test", "desc test2")

app.AddCommand(c)

is.Eq("", c.ParentName())

is.Eq("mdl-test", c.Name)

is.Eq("c3", app.ResolveAlias("alias1"))

is.True(app.IsAlias("alias1"))

}

func TestApp_AddCommand(t *testing.T) {

app := gcli.NewApp(func(a *gcli.App) {

a.ExitOnEnd = false

})

app.AddCommand(newEmptyCmd())

cmd1 := gcli.NewCommand("cmd1", "desc")

cmd1.Disable()

app.AddCommand(cmd1)

assert.Len(t, app.Commands(), 1)

assert.Len(t, app.CommandNames(), 1)

assert.False(t, app.IsCommand("cmd1"))

assert.Eq(t, "", app.CommandName())

assert.PanicsMsg(t, func() {

app.AddCommand(&gcli.Command{})

}, "GCli: the command name can not be empty")

assert.PanicsMsg(t, func() {

app.AddCommand(&gcli.Command{Name: "+xdd"})

}, "GCli: the command name '+xdd' is invalid, must match: ^[a-zA-Z][\\w-]*$")

}

func TestApp_CommandsByGroup(t *testing.T) {

is := assert.New(t)

app := gcli.NewApp(func(a *gcli.App) { a.ExitOnEnd = false })

app.Add(&gcli.Command{Name: "migrate", Desc: "d", Category: "database"})

app.Add(&gcli.Command{Name: "serve", Desc: "d"}) // default group

app.Add(&gcli.Command{Name: "seed", Desc: "d", Category: "database"})

app.Add(&gcli.Command{Name: "commit", Desc: "d", Category: "git"})

groups := app.CommandsByGroup("Available Commands")

is.Len(groups, 3)

// keep category insertion order

is.Eq("database", groups[0].Name)

is.Eq("Database", groups[0].Title)

is.Eq("", groups[1].Name)

is.Eq("Available Commands", groups[1].Title)

is.Eq("git", groups[2].Name)

// commands inside a group sorted by name

is.Len(groups[0].Cmds, 2)

is.Eq("migrate", groups[0].Cmds[0].Name)

is.Eq("seed", groups[0].Cmds[1].Name)

}

func TestApp_Opts_singleSource(t *testing.T) {

is := assert.New(t)

defer gcli.ResetVerbose()

app := gcli.NewApp(func(a *gcli.App) { a.ExitOnEnd = false })

// App 复用包级 gOpts —— 同一指针

is.True(app.Opts() == gcli.GOpts())

// SetVerbose 写 gOpts，app.Opts() 立即可见(无需同步)

gcli.SetVerbose(gcli.VerbDebug)

is.Eq(gcli.VerbDebug, app.Opts().Verbose)

// ResetGOpts 就地刷新，App 持有的指针同步可见

gcli.ResetGOpts()

is.Eq(gcli.VerbError, app.Opts().Verbose)

}

func TestApp_AddAliases(t *testing.T) {

app := gcli.NewApp(func(a *gcli.App) {

a.ExitOnEnd = false

})

cmd := &gcli.Command{

Name: "test",

Desc: "the desc",

Aliases: []string{"alias1"},

}

app.AddCommand(cmd)

app.AddCommand(gcli.NewCommand("cmd2", "desc"))

assert.True(t, app.IsAlias("alias1"))

assert.PanicsMsg(t, func() {

app.AddCommand(gcli.NewCommand("alias1", "desc"))

}, "GCli: The name 'alias1' is already used as an alias in \"GCliApp\"")

assert.PanicsMsg(t, func() {

app.AddAliases("cmd2", "test")

}, "GCli: The name 'test' has been used as an command name")

}

func TestApp_Run_noCommands(t *testing.T) {

is := assert.New(t)

app := gcli.NewApp(func(a *gcli.App) {

a.ExitOnEnd = false

a.Version = "1.3.9"

})

app.Run([]string{})

// disable color code, re-set output for test

b := byteutil.NewBuffer()

color.Disable()

color.SetOutput(b)

gcli.SetVerbose(gcli.VerbCrazy)

defer func() {

color.ResetOptions()

gcli.SetVerbose(gcli.VerbError)

}()

// run

code := app.Run([]string{})

str := b.ResetGet()

is.Eq(0, code)

is.Contains(str, "1.3.9")

is.Contains(str, "Version: 1.3.9")

is.Contains(str, "This is my console application")

is.Contains(str, "Display help information")

err := app.Exec("not-exists", []string{})

is.Err(err)

}

func TestApp_Run_command_withArguments(t *testing.T) {

is := assert.New(t)

app := gcli.NewApp(func(a *gcli.App) {

a.ExitOnEnd = false

})

// run with command

var argStr, cmdRet string

app.Add(&gcli.Command{

Name: "test",

Desc: "desc for test command",

Config: func(c *gcli.Command) {

c.AddArg("arg0", "desc")

c.BindArg(&gcli.Argument{Name: "arg1", Desc: "desc1"})

},

Func: func(c *gcli.Command, args []string) error {

cmdRet = c.Name

argStr = strings.Join(args, ",")

return nil

},

})

// run a command

code := app.Run([]string{"test"})

is.Eq(0, code)

is.Eq("", argStr)

is.Eq("test", cmdRet)

is.Eq("test", app.CommandName())

// clear

argStr = ""

cmdRet = ""

err := app.Exec("test", []string{"val0", "val1", "val2"})

is.NoErr(err)

is.Eq("test", cmdRet)

is.Eq("val2", argStr)

err = app.Exec("not-exists", []string{})

is.Err(err)

is.ErrMsg(err, `exec unknown command "not-exists"`)

// other

// app.AddError(fmt.Errorf("test error"))

}

func TestApp_Run_command_withOptions(t *testing.T) {

is := assert.New(t)

app := gcli.NewApp(gcli.NotExitOnEnd())

// run with command

var optStr, cmdRet string

var opt1 string

app.Add(&gcli.Command{

Name: "test",

Desc: "desc for test command",

Config: func(c *gcli.Command) {

c.AddArg("arg0", "desc")

c.BindArg(&gcli.Argument{Name: "arg1", Desc: "desc1"})

c.StrOpt(&opt1, "opt1", "o", "", "opt desc")

},

Func: func(c *gcli.Command, args []string) error {

cmdRet = c.Name

optStr = strings.Join(args, ",")

return nil

},

})

// run command

code := app.Run([]string{"test"})

is.Eq(0, code)

is.Eq("", optStr)

is.Eq("test", cmdRet)

is.Eq("test", app.CommandName())

// help option

app.Run([]string{"test", "-h"})

// disable color code, reset output for test

b := byteutil.NewBuffer()

color.Disable()

color.SetOutput(b)

gcli.SetVerbose(gcli.VerbCrazy)

defer func() {

color.ResetOptions()

gcli.SetVerbose(gcli.VerbError)

}()

app.Run([]string{"test", "-h"})

s := b.String()

fmt.Println(s)

is.Contains(s, "-o, --opt1 string")

}

func TestApp_Run_subcommand(t *testing.T) {

is := assert.New(t)

id := "top1:sub1"

app := newAppWithMl()

app.Ctx.Set(id, "TestApp_Run_subcommand")

app.Run([]string{"top1", "sub1"})

c := app.FindCommand(id)

is.NotEmpty(c)

is.Eq("TestApp_Run_subcommand", c.Ctx.Get("msg"))

}

func TestApp_Run_by_cmd_ID(t *testing.T) {

is := assert.New(t)

app := newAppWithMl()

app.Ctx.Set("top1:sub1", "TestApp_Run_by_cmd_ID")

app.Run([]string{"top1:sub1"})

c := app.FindCommand("top1:sub1")

is.NotEmpty(c)

is.Eq("TestApp_Run_by_cmd_ID", c.Ctx.Get("msg"))

}

func TestApp_AddAliases_and_run(t *testing.T) {

is := assert.New(t)

id := "top1:sub1"

app := newAppWithMl()

app.AddAliases(id, "ts1")

app.Ctx.Set(id, "TestApp_AddAliases_and_run")

app.Run([]string{"ts1"})

c := app.FindCommand(id)

is.NotEmpty(c)

is.Eq("TestApp_AddAliases_and_run", c.Ctx.Get("msg"))

}

func TestApp_showCommandHelp(t *testing.T) {

is := assert.New(t)

// 每个场景使用全新 app，避免跨次 Run 的状态干扰(原测试靠一次 warmup 运行

// 触发 findSimilarCmd 污染 cmdNames 才能"碰巧"通过，已随 help 修复一并修正)

runHelp := func(args []string) (int, string) {

app := gcli.NewApp(func(a *gcli.App) { a.ExitOnEnd = false })

app.AddCommand(gcli.NewCommand("test", "desc for test command"))

b := new(bytes.Buffer)

color.Disable()

color.SetOutput(b)

defer color.ResetOptions()

code := app.Run(args)

return code, b.String()

}

// show command help

code, str := runHelp([]string{"help", "test"})

is.Eq(gcli.OK.ToInt(), code)

is.StrContains(str, "Name: test")

is.StrContains(str, "Desc for test command")

// show command help: arg error

code, str = runHelp([]string{"help", "test", "more"})

is.Eq(gcli.ERR.ToInt(), code)

is.StrContains(str, "Too many arguments given.")

// show command help for 'help'

code, str = runHelp([]string{"help", "help"})

is.Eq(gcli.OK.ToInt(), code)

is.StrContains(str, "Display help message for application or command.")

// show command help: unknown command

code, str = runHelp([]string{"help", "not-exist"})

is.Eq(gcli.ERR.ToInt(), code)

is.StrContains(str, "Unknown command name 'not-exist'")

}

func TestApp_findSimilarCmd_noPollution(t *testing.T) {

is := assert.New(t)

app := gcli.NewApp(func(a *gcli.App) { a.ExitOnEnd = false })

app.AddCommand(gcli.NewCommand("test", "desc"))

b := new(bytes.Buffer)

color.Disable()

color.SetOutput(b)

defer color.ResetOptions()

// 拼错的命令会触发 findSimilarCmd，给出相似命令提示

app.Run([]string{"helpp"})

is.StrContains(b.String(), "Maybe you mean")

// 关键回归：findSimilarCmd 不能把 'help' 写进真实的命令注册表

is.False(app.IsCommand("help"))

is.Len(app.CmdNameMap(), 1)

}

func TestApp_showVersion(t *testing.T) {

app := gcli.NewApp(func(a *gcli.App) {

a.ExitOnEnd = false

a.Version = "1.3.9"

a.Desc = "application desc"

a.Logo.Text = "MY-LOGO"

})

app.Run([]string{"--version"})

// disable color code, re-set output for test

b := byteutil.NewBuffer()

color.Disable()

color.SetOutput(b)

defer color.ResetOptions()

app.Run([]string{"--version"})

str := b.ResetGet()

assert.Contains(t, str, "Version: 1.3.9")

assert.Contains(t, str, "Application desc")

assert.Contains(t, str, "MY-LOGO")

}

func TestApp_showCommandTips(t *testing.T) {

app := gcli.NewApp()

app.ExitOnEnd = false

app.AddCommand(newEmptyCmd())

app.Run([]string{"emp"})

// disable color code, re-set output for test

b := byteutil.NewBuffer()

color.Disable()

color.SetOutput(b)

defer color.ResetOptions()

app.Run([]string{"emp"})

str := b.ResetGet()

assert.Contains(t, str, "ERROR: unknown input command \"emp\"")

assert.Contains(t, str, `Maybe you mean:

empty`)

}

// func TestApp_RemoveCommand(t *testing.T) {

// app := gcli.NewApp()

//

// app.Add(

// gcli.NewCommand("cmd1", "desc"),

// gcli.NewCommand("cmd2", "desc"),

// )

//

// assert.Len(t, app.Commands(), 2)

// assert.True(t, app.IsCommand("cmd1"))

//

// assert.Eq(t, 1, app.RemoveCommand("cmd1"))

// assert.Len(t, app.Commands(), 1)

// assert.False(t, app.IsCommand("cmd1"))

// }

func TestApp_AddHandler(t *testing.T) {

app := gcli.NewApp()

app.AddHandler(&UserCommand{})

assert.True(t, app.HasCommand("test"))

}

// UserCommand for tests

type UserCommand struct {

opt1 string

}

func (uc *UserCommand) Creator() *gcli.Command {

return gcli.NewCommand("test", "desc message")

}

func (uc *UserCommand) Config(c *gcli.Command) {

c.StrOpt(&uc.opt1, "opt", "o", "", "desc")

}

func (uc *UserCommand) Execute(_ *gcli.Command, _ []string) error {

return nil

}

func TestApp_default_command(t *testing.T) {

b := byteutil.NewBuffer()

app := gcli.NewApp(func(a *gcli.App) {

a.SetDefaultCommand("test")

})

app.Add(gcli.NewCommand("test", "desc").WithFunc(func(c *gcli.Command, args []string) error {

b.Println("the", c.Name, "command is run completed")

return nil

}))

assert.True(t, app.HasCommand("test"))

assert.Eq(t, 0, app.Run([]string{}))

assert.Eq(t, b.ResetGet(), "the test command is run completed\n")

}

func TestApp_Use(t *testing.T) {

t.Run("order", func(t *testing.T) {

defer gcli.ResetGOpts()

var calls []string

app := gcli.NewApp(gcli.NotExitOnEnd())

ret := app.Use(func(c *gcli.Command, args []string) error {

calls = append(calls, "app-mw1")

return nil

}, func(c *gcli.Command, args []string) error {

calls = append(calls, "app-mw2")

return nil

})

// 链式: Use 返回 *App

assert.True(t, ret == app)

cmd := gcli.NewCommand("c1", "desc").WithFunc(func(c *gcli.Command, args []string) error {

calls = append(calls, "func")

return nil

})

cmd.Use(func(c *gcli.Command, args []string) error {

calls = append(calls, "cmd-mw")

return nil

})

app.Add(cmd)

assert.Eq(t, 0, app.Run([]string{"c1"}))

assert.Eq(t, []string{"app-mw1", "app-mw2", "cmd-mw", "func"}, calls)

})

t.Run("abort", func(t *testing.T) {

defer gcli.ResetGOpts()

var calls []string

app := gcli.NewApp(gcli.NotExitOnEnd())

app.Use(func(c *gcli.Command, args []string) error {

calls = append(calls, "app-mw")

return fmt.Errorf("abort by app middleware")

})

cmd := gcli.NewCommand("c1", "desc").WithFunc(func(c *gcli.Command, args []string) error {

calls = append(calls, "func")

return nil

})

cmd.Use(func(c *gcli.Command, args []string) error {

calls = append(calls, "cmd-mw")

return nil

})

app.Add(cmd)

app.Run([]string{"c1"})

// app 级中间件返回 error, 命令级中间件与 func 都不执行

assert.Eq(t, []string{"app-mw"}, calls)

})

t.Run("all commands", func(t *testing.T) {

defer gcli.ResetGOpts()

var hits int

app := gcli.NewApp(gcli.NotExitOnEnd())

app.Use(func(c *gcli.Command, args []string) error {

hits++

return nil

})

app.Add(gcli.NewCommand("c1", "desc").WithFunc(func(c *gcli.Command, args []string) error {

return nil

}))

app.Add(gcli.NewCommand("c2", "desc").WithFunc(func(c *gcli.Command, args []string) error {

return nil

}))

assert.Eq(t, 0, app.Run([]string{"c1"}))

assert.Eq(t, 0, app.Run([]string{"c2"}))

assert.Eq(t, 2, hits)

})

}