github.com/criteo/command-launcher@v0.0.0-20230407142452-fb616f546e98/internal/command/default-command_test.go (about)

     1  package command
     2  
     3  import (
     4  	"fmt"
     5  	"runtime"
     6  	"testing"
     7  
     8  	"github.com/stretchr/testify/assert"
     9  )
    10  
    11  func getDefaultCommand() DefaultCommand {
    12  	return DefaultCommand{
    13  		CmdName:      "test",
    14  		CmdCategory:  "",
    15  		CmdType:      "executable",
    16  		CmdGroup:     "",
    17  		CmdArgsUsage: "[-O opt1] arg1 arg2",
    18  		CmdExamples: []ExampleEntry{
    19  			{
    20  				Scenario: "scenario 1",
    21  				Command:  "test -O opt1 arg1",
    22  			},
    23  		},
    24  		CmdShortDescription:   "test command",
    25  		CmdLongDescription:    "test command - long description",
    26  		CmdExecutable:         "ls",
    27  		CmdArguments:          []string{"-l", "-a"},
    28  		CmdDocFile:            "",
    29  		CmdDocLink:            "",
    30  		CmdValidArgs:          nil,
    31  		CmdValidArgsCmd:       nil,
    32  		CmdRequiredFlags:      nil,
    33  		CmdFlagValuesCmd:      nil,
    34  		CmdCheckFlags:         true,
    35  		CmdRequestedResources: nil,
    36  		PkgDir:                "/tmp/test/root",
    37  	}
    38  }
    39  
    40  func TestRequestResources(t *testing.T) {
    41  	cmd := getDefaultCommand()
    42  	assert.NotNil(t, cmd.RequestedResources())
    43  	assert.Equal(t, 0, len(cmd.RequestedResources()))
    44  }
    45  
    46  func TestCommandValidArgs(t *testing.T) {
    47  	cmd := getDefaultCommand()
    48  	cmd.CmdValidArgs = []string{"args1", "args2"}
    49  	cmd.CmdValidArgsCmd = []string{}
    50  	cmd.CmdRequiredFlags = []string{"moab", "moab-id"}
    51  	cmd.CmdFlagValuesCmd = []string{}
    52  
    53  	validArgs := cmd.ValidArgs()
    54  
    55  	assert.Equal(t, 2, len(validArgs))
    56  	assert.Equal(t, "args1", validArgs[0])
    57  	assert.Equal(t, "args2", validArgs[1])
    58  
    59  	validArgsCmd := cmd.ValidArgsCmd()
    60  	assert.Equal(t, 0, len(validArgsCmd))
    61  
    62  	flagValuesCmd := cmd.FlagValuesCmd()
    63  	assert.Equal(t, 0, len(flagValuesCmd))
    64  }
    65  
    66  func TestCommandValidArgsCmd(t *testing.T) {
    67  	cmd := getDefaultCommand()
    68  	cmd.CmdValidArgs = []string{"args1", "args2"}
    69  	cmd.CmdValidArgsCmd = []string{"#CACHE#/test", "arg1", "arg2"}
    70  	cmd.CmdRequiredFlags = []string{"moab", "moab-id"}
    71  	cmd.CmdFlagValuesCmd = []string{"#CACHE#/test", "arg1", "arg2"}
    72  
    73  	validArgsCmd := cmd.ValidArgsCmd()
    74  	assert.Equal(t, 3, len(validArgsCmd))
    75  	assert.Equal(t, "#CACHE#/test", validArgsCmd[0])
    76  	assert.Equal(t, "arg1", validArgsCmd[1])
    77  	assert.Equal(t, "arg2", validArgsCmd[2])
    78  
    79  	flagValuesCmd := cmd.FlagValuesCmd()
    80  	assert.Equal(t, 3, len(flagValuesCmd))
    81  	assert.Equal(t, "#CACHE#/test", flagValuesCmd[0])
    82  	assert.Equal(t, "arg1", flagValuesCmd[1])
    83  	assert.Equal(t, "arg2", flagValuesCmd[2])
    84  
    85  	flags := cmd.RequiredFlags()
    86  	assert.Equal(t, 2, len(flags))
    87  	assert.Equal(t, "moab", flags[0])
    88  	assert.Equal(t, "moab-id", flags[1])
    89  }
    90  
    91  func TestNullFields(t *testing.T) {
    92  	cmd := getDefaultCommand()
    93  
    94  	assert.NotNil(t, cmd.ValidArgs())
    95  	assert.NotNil(t, cmd.RequiredFlags())
    96  	validArgsCmd := cmd.ValidArgsCmd()
    97  	assert.NotNil(t, validArgsCmd)
    98  	assert.Equal(t, 0, len(validArgsCmd))
    99  }
   100  
   101  func TestNewDefaultCommandFromCopy(t *testing.T) {
   102  	cmd := getDefaultCommand()
   103  
   104  	newCmd := NewDefaultCommandFromCopy(&cmd, "/new-pkg-dir")
   105  	assert.NotNil(t, newCmd.CmdValidArgs)
   106  	assert.Equal(t, 0, len(newCmd.CmdValidArgs))
   107  	assert.NotNil(t, newCmd.CmdValidArgsCmd)
   108  	assert.Equal(t, 0, len(newCmd.CmdValidArgsCmd))
   109  	assert.NotNil(t, newCmd.CmdRequiredFlags)
   110  	assert.Equal(t, 0, len(newCmd.CmdRequiredFlags))
   111  
   112  	assert.Equal(t, 2, len(newCmd.Arguments()))
   113  	assert.Equal(t, "-l", newCmd.Arguments()[0])
   114  	assert.Equal(t, "-a", newCmd.Arguments()[1])
   115  	assert.Equal(t, "/new-pkg-dir", newCmd.PkgDir)
   116  
   117  	assert.Equal(t, "[-O opt1] arg1 arg2", newCmd.ArgsUsage())
   118  	assert.Equal(t, 1, len(newCmd.Examples()))
   119  	assert.Equal(t, "scenario 1", newCmd.Examples()[0].Scenario)
   120  	assert.Equal(t, "test -O opt1 arg1", newCmd.Examples()[0].Command)
   121  }
   122  
   123  func TestLegacyVariableInterpolation(t *testing.T) {
   124  	cmd := getDefaultCommand()
   125  	cmd.CmdExecutable = "#CACHE#/#OS#/test#EXT#"
   126  
   127  	if runtime.GOOS == "windows" {
   128  		assert.Equal(t, fmt.Sprintf("/tmp/test/root/%s/test.exe", runtime.GOOS), cmd.interpolateCmd())
   129  	} else {
   130  		assert.Equal(t, fmt.Sprintf("/tmp/test/root/%s/test", runtime.GOOS), cmd.interpolateCmd())
   131  	}
   132  }
   133  
   134  func TestVariableRender(t *testing.T) {
   135  	cmd := getDefaultCommand()
   136  	cmd.CmdExecutable = "{{.Root}}/{{.Os}}/test"
   137  
   138  	assert.Equal(t, fmt.Sprintf("/tmp/test/root/%s/test", runtime.GOOS), cmd.interpolateCmd())
   139  }
   140  
   141  func TestConditionalVariableRender(t *testing.T) {
   142  	cmd := getDefaultCommand()
   143  	cmd.CmdExecutable = "{{.Root}}/{{.Os}}/test{{if eq .Os \"windows\"}}.bat{{else}}.sh{{end}}"
   144  
   145  	if runtime.GOOS == "windows" {
   146  		cmd.PkgDir = "\\tmp\\test\\root"
   147  		assert.Equal(t, fmt.Sprintf("/tmp/test/root/%s/test.bat", runtime.GOOS), cmd.interpolateCmd())
   148  	} else {
   149  		cmd.PkgDir = "/tmp/test/root"
   150  		assert.Equal(t, fmt.Sprintf("/tmp/test/root/%s/test.sh", runtime.GOOS), cmd.interpolateCmd())
   151  	}
   152  }
   153  
   154  func TestConditionalBinaryRender(t *testing.T) {
   155  	cmd := getDefaultCommand()
   156  	cmd.CmdExecutable = "{{.Binary}}"
   157  
   158  	if runtime.GOOS == "windows" {
   159  		assert.Equal(t, "test.exe", cmd.interpolateCmd())
   160  	} else {
   161  		assert.Equal(t, "test", cmd.interpolateCmd())
   162  	}
   163  }
   164  
   165  func TestConditionalScriptRender(t *testing.T) {
   166  	cmd := getDefaultCommand()
   167  	cmd.CmdExecutable = "{{.Script}}"
   168  
   169  	if runtime.GOOS == "windows" {
   170  		assert.Equal(t, "test.bat", cmd.interpolateCmd())
   171  	} else {
   172  		assert.Equal(t, "test", cmd.interpolateCmd())
   173  	}
   174  }
   175  
   176  func TestConditionalExtensionRender(t *testing.T) {
   177  	cmd := getDefaultCommand()
   178  	cmd.CmdExecutable = "test{{.Extension}}"
   179  
   180  	if runtime.GOOS == "windows" {
   181  		assert.Equal(t, "test.exe", cmd.interpolateCmd())
   182  	} else {
   183  		assert.Equal(t, "test", cmd.interpolateCmd())
   184  	}
   185  }
   186  
   187  func TestConditionalScriptExtensionRender(t *testing.T) {
   188  	cmd := getDefaultCommand()
   189  	cmd.CmdExecutable = "test{{.ScriptExtension}}"
   190  
   191  	if runtime.GOOS == "windows" {
   192  		assert.Equal(t, "test.bat", cmd.interpolateCmd())
   193  	} else {
   194  		assert.Equal(t, "test", cmd.interpolateCmd())
   195  	}
   196  }
   197  
   198  func TestMixedRender(t *testing.T) {
   199  	cmd := getDefaultCommand()
   200  	cmd.CmdExecutable = "#CACHE#/#OS#/test{{if eq .Os \"windows\"}}.bat{{else}}.sh{{end}}"
   201  
   202  	if runtime.GOOS == "windows" {
   203  		assert.Equal(t, fmt.Sprintf("/tmp/test/root/%s/test.bat", runtime.GOOS), cmd.interpolateCmd())
   204  	} else {
   205  		assert.Equal(t, fmt.Sprintf("/tmp/test/root/%s/test.sh", runtime.GOOS), cmd.interpolateCmd())
   206  	}
   207  }
   208  
   209  func TestVariableRenderError(t *testing.T) {
   210  	cmd := getDefaultCommand()
   211  	cmd.CmdExecutable = "{{.Root}}/{{.Os}}/test{{.NonExistKey}}"
   212  
   213  	assert.Equal(t, "{{.Root}}/{{.Os}}/test{{.NonExistKey}}", cmd.interpolateCmd())
   214  }
   215  
   216  func TestInterpolate(t *testing.T) {
   217  	cmd := getDefaultCommand()
   218  	cmd.CmdExecutable = "#CACHE#/#OS#/#ARCH#/test#EXT#"
   219  	cmd.CmdArguments = []string{"-l", "-a", "#SCRIPT#"}
   220  
   221  	assert.Equal(t, ".bat", cmd.doInterpolate("windows", "x64", "#SCRIPT_EXT#"))
   222  	assert.Equal(t, "", cmd.doInterpolate("linux", "x64", "#SCRIPT_EXT#"))
   223  	assert.Equal(t, "test.bat", cmd.doInterpolate("windows", "x64", "#SCRIPT#"))
   224  	assert.Equal(t, "test", cmd.doInterpolate("linux", "x64", "#SCRIPT#"))
   225  	assert.Equal(t, "/tmp/test/root/windows/x64/test.exe", cmd.doInterpolate("windows", "x64", "#CACHE#/#OS#/#ARCH#/test#EXT#"))
   226  }
   227  
   228  func TestRuntimeNameAndGroup(t *testing.T) {
   229  	cmd := getDefaultCommand()
   230  
   231  	assert.Equal(t, cmd.Group(), cmd.RuntimeGroup(), "runtime name should be same as name by default")
   232  	assert.Equal(t, cmd.Name(), cmd.RuntimeName(), "runtime group should be same as group by default")
   233  
   234  	cmd.SetRuntimeGroup("new-group")
   235  	cmd.SetRuntimeName("new-name")
   236  
   237  	assert.Equal(t, "new-group", cmd.RuntimeGroup())
   238  	assert.Equal(t, "new-name", cmd.RuntimeName())
   239  
   240  	cmd.SetNamespace("test-repo", "test-package")
   241  	assert.Equal(t, "test@@test-package@test-repo", cmd.FullName())
   242  	assert.Equal(t, "@@test-package@test-repo", cmd.FullGroup())
   243  
   244  	assert.Equal(t, "test-repo>test-package>>test", cmd.ID())
   245  
   246  }