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 }