github.com/goravel/framework@v1.13.9/console/application_test.go (about)

     1  package console
     2  
     3  import (
     4  	"testing"
     5  
     6  	"github.com/stretchr/testify/assert"
     7  	"github.com/urfave/cli/v2"
     8  
     9  	"github.com/goravel/framework/contracts/console"
    10  	"github.com/goravel/framework/contracts/console/command"
    11  )
    12  
    13  var testCommand = 0
    14  
    15  func TestRun(t *testing.T) {
    16  	cli := NewApplication()
    17  	cli.Register([]console.Command{
    18  		&TestCommand{},
    19  	})
    20  
    21  	cli.Call("test")
    22  	assert.Equal(t, 1, testCommand)
    23  }
    24  
    25  func TestFlagsToCliFlags(t *testing.T) {
    26  	// Mock flags of different types
    27  	boolFlag := &command.BoolFlag{Name: "boolFlag", Aliases: []string{"bf"}, Usage: "bool flag", Required: false, Value: false}
    28  	float64Flag := &command.Float64Flag{Name: "float64Flag", Aliases: []string{"ff"}, Usage: "float64 flag", Required: true, Value: 1.0}
    29  	float64SliceFlag := &command.Float64SliceFlag{Name: "float64SliceFlag", Aliases: []string{"fsf"}, Usage: "float64 slice flag", Required: false, Value: []float64{1.0, 2.0, 3.0}}
    30  	intFlag := &command.IntFlag{Name: "intFlag", Aliases: []string{"if"}, Usage: "int flag", Required: true, Value: 1}
    31  	intSliceFlag := &command.IntSliceFlag{Name: "intSliceFlag", Aliases: []string{"isf"}, Usage: "int slice flag", Required: false, Value: []int{1, 2, 3}}
    32  	int64Flag := &command.Int64Flag{Name: "int64Flag", Aliases: []string{"i64f"}, Usage: "int64 flag", Required: false, Value: 1}
    33  	int64SliceFlag := &command.Int64SliceFlag{Name: "int64SliceFlag", Aliases: []string{"i64sf"}, Usage: "int64 slice flag", Required: false, Value: []int64{1, 2, 3}}
    34  	stringFlag := &command.StringFlag{Name: "stringFlag", Aliases: []string{"sf"}, Usage: "string flag", Required: false, Value: "default"}
    35  	stringSliceFlag := &command.StringSliceFlag{Name: "stringSliceFlag", Aliases: []string{"ssf"}, Usage: "string slice flag", Required: false, Value: []string{"a", "b", "c"}}
    36  
    37  	// Create a slice of command flags
    38  	flags := []command.Flag{boolFlag, float64Flag, float64SliceFlag, intFlag, intSliceFlag, int64Flag, int64SliceFlag, stringFlag, stringSliceFlag}
    39  
    40  	// Convert command flags to CLI flags
    41  	cliFlags := flagsToCliFlags(flags)
    42  
    43  	// Assert that the number of CLI flags matches the number of command flags
    44  	assert.Equal(t, len(cliFlags), len(flags))
    45  
    46  	// Assert that each CLI flag has the expected name, aliases, usage, required, and value
    47  	for i, flag := range flags {
    48  		switch flag.Type() {
    49  		case command.FlagTypeBool:
    50  			boolFlag := flag.(*command.BoolFlag)
    51  			cliBoolFlag := cliFlags[i].(*cli.BoolFlag)
    52  			assert.Equal(t, boolFlag.Name, cliBoolFlag.Name)
    53  			assert.Equal(t, boolFlag.Aliases, cliBoolFlag.Aliases)
    54  			assert.Equal(t, boolFlag.Usage, cliBoolFlag.Usage)
    55  			assert.Equal(t, boolFlag.Required, cliBoolFlag.Required)
    56  			assert.Equal(t, boolFlag.Value, cliBoolFlag.Value)
    57  		case command.FlagTypeFloat64:
    58  			float64Flag := flag.(*command.Float64Flag)
    59  			cliFloat64Flag := cliFlags[i].(*cli.Float64Flag)
    60  			assert.Equal(t, float64Flag.Name, cliFloat64Flag.Name)
    61  			assert.Equal(t, float64Flag.Aliases, cliFloat64Flag.Aliases)
    62  			assert.Equal(t, float64Flag.Usage, cliFloat64Flag.Usage)
    63  			assert.Equal(t, float64Flag.Required, cliFloat64Flag.Required)
    64  			assert.Equal(t, float64Flag.Value, cliFloat64Flag.Value)
    65  		case command.FlagTypeFloat64Slice:
    66  			float64SliceFlag := flag.(*command.Float64SliceFlag)
    67  			cliFloat64SliceFlag := cliFlags[i].(*cli.Float64SliceFlag)
    68  			assert.Equal(t, float64SliceFlag.Name, cliFloat64SliceFlag.Name)
    69  			assert.Equal(t, float64SliceFlag.Aliases, cliFloat64SliceFlag.Aliases)
    70  			assert.Equal(t, float64SliceFlag.Usage, cliFloat64SliceFlag.Usage)
    71  			assert.Equal(t, float64SliceFlag.Required, cliFloat64SliceFlag.Required)
    72  			assert.Equal(t, cli.NewFloat64Slice(float64SliceFlag.Value...), cliFloat64SliceFlag.Value)
    73  		case command.FlagTypeInt:
    74  			intFlag := flag.(*command.IntFlag)
    75  			cliIntFlag := cliFlags[i].(*cli.IntFlag)
    76  			assert.Equal(t, intFlag.Name, cliIntFlag.Name)
    77  			assert.Equal(t, intFlag.Aliases, cliIntFlag.Aliases)
    78  			assert.Equal(t, intFlag.Usage, cliIntFlag.Usage)
    79  			assert.Equal(t, intFlag.Required, cliIntFlag.Required)
    80  			assert.Equal(t, intFlag.Value, cliIntFlag.Value)
    81  		case command.FlagTypeIntSlice:
    82  			intSliceFlag := flag.(*command.IntSliceFlag)
    83  			cliIntSliceFlag := cliFlags[i].(*cli.IntSliceFlag)
    84  			assert.Equal(t, intSliceFlag.Name, cliIntSliceFlag.Name)
    85  			assert.Equal(t, intSliceFlag.Aliases, cliIntSliceFlag.Aliases)
    86  			assert.Equal(t, intSliceFlag.Usage, cliIntSliceFlag.Usage)
    87  			assert.Equal(t, intSliceFlag.Required, cliIntSliceFlag.Required)
    88  			assert.Equal(t, cli.NewIntSlice(intSliceFlag.Value...), cliIntSliceFlag.Value)
    89  		case command.FlagTypeInt64:
    90  			int64Flag := flag.(*command.Int64Flag)
    91  			cliInt64Flag := cliFlags[i].(*cli.Int64Flag)
    92  			assert.Equal(t, int64Flag.Name, cliInt64Flag.Name)
    93  			assert.Equal(t, int64Flag.Aliases, cliInt64Flag.Aliases)
    94  			assert.Equal(t, int64Flag.Usage, cliInt64Flag.Usage)
    95  			assert.Equal(t, int64Flag.Required, cliInt64Flag.Required)
    96  			assert.Equal(t, int64Flag.Value, cliInt64Flag.Value)
    97  		case command.FlagTypeInt64Slice:
    98  			int64SliceFlag := flag.(*command.Int64SliceFlag)
    99  			cliInt64SliceFlag := cliFlags[i].(*cli.Int64SliceFlag)
   100  			assert.Equal(t, int64SliceFlag.Name, cliInt64SliceFlag.Name)
   101  			assert.Equal(t, int64SliceFlag.Aliases, cliInt64SliceFlag.Aliases)
   102  			assert.Equal(t, int64SliceFlag.Usage, cliInt64SliceFlag.Usage)
   103  			assert.Equal(t, int64SliceFlag.Required, cliInt64SliceFlag.Required)
   104  			assert.Equal(t, cli.NewInt64Slice(int64SliceFlag.Value...), cliInt64SliceFlag.Value)
   105  		case command.FlagTypeString:
   106  			stringFlag := flag.(*command.StringFlag)
   107  			cliStringFlag := cliFlags[i].(*cli.StringFlag)
   108  			assert.Equal(t, stringFlag.Name, cliStringFlag.Name)
   109  			assert.Equal(t, stringFlag.Aliases, cliStringFlag.Aliases)
   110  			assert.Equal(t, stringFlag.Usage, cliStringFlag.Usage)
   111  			assert.Equal(t, stringFlag.Required, cliStringFlag.Required)
   112  			assert.Equal(t, stringFlag.Value, cliStringFlag.Value)
   113  		case command.FlagTypeStringSlice:
   114  			stringSliceFlag := flag.(*command.StringSliceFlag)
   115  			cliStringSliceFlag := cliFlags[i].(*cli.StringSliceFlag)
   116  			assert.Equal(t, stringSliceFlag.Name, cliStringSliceFlag.Name)
   117  			assert.Equal(t, stringSliceFlag.Aliases, cliStringSliceFlag.Aliases)
   118  			assert.Equal(t, stringSliceFlag.Usage, cliStringSliceFlag.Usage)
   119  			assert.Equal(t, stringSliceFlag.Required, cliStringSliceFlag.Required)
   120  			assert.Equal(t, cli.NewStringSlice(stringSliceFlag.Value...), cliStringSliceFlag.Value)
   121  		}
   122  	}
   123  }
   124  
   125  type TestCommand struct {
   126  }
   127  
   128  func (receiver *TestCommand) Signature() string {
   129  	return "test"
   130  }
   131  
   132  func (receiver *TestCommand) Description() string {
   133  	return "Test command"
   134  }
   135  
   136  func (receiver *TestCommand) Extend() command.Extend {
   137  	return command.Extend{}
   138  }
   139  
   140  func (receiver *TestCommand) Handle(ctx console.Context) error {
   141  	testCommand++
   142  
   143  	return nil
   144  }