This is an automated email from the ASF dual-hosted git repository.
nferraro pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/camel-k.git
The following commit(s) were added to refs/heads/master by this push:
new 26491cb refactor(test): included all run command flag test
26491cb is described below
commit 26491cb2ea13653802900525f6f2298a8ecb7c33
Author: Pasquale Congiusti <[email protected]>
AuthorDate: Mon Jan 11 16:02:59 2021 +0100
refactor(test): included all run command flag test
* Added all run command flag test in run_test.go
* Refactored root_test.go to use new methods in run_test.go
---
pkg/cmd/root_test.go | 46 +-----
pkg/cmd/run_test.go | 423 ++++++++++++++++++++++++++++++++++++++++-----------
2 files changed, 341 insertions(+), 128 deletions(-)
diff --git a/pkg/cmd/root_test.go b/pkg/cmd/root_test.go
index a050a5f..d7ee8d9 100644
--- a/pkg/cmd/root_test.go
+++ b/pkg/cmd/root_test.go
@@ -46,42 +46,16 @@ func kamelTestPreAddCommandInit() (*RootCmdOptions,
*cobra.Command) {
return &options, rootCmd
}
-func TestLoadFromCommandLine(t *testing.T) {
- options, rootCmd := kamelTestPreAddCommandInit()
-
- runCmdOptions := addTestRunCmd(options, rootCmd)
-
- kamelTestPostAddCommandInit(t, rootCmd)
-
- const VAR2 = "VAR2=value2"
- _, err := test.ExecuteCommand(rootCmd, "run", "route.java", "--env",
"VAR1=value,othervalue", "--env", VAR2)
- if err != nil {
- t.Fatalf("Unexpected error: %v", err)
- }
-
- if len(runCmdOptions.EnvVars) != 2 {
- t.Errorf("Properties expected to contain: \n %v
elements\nGot:\n %v elemtns\n", 2, len(runCmdOptions.EnvVars))
- }
- if runCmdOptions.EnvVars[0] != "VAR1=value,othervalue" ||
runCmdOptions.EnvVars[1] != VAR2 {
- t.Errorf("EnvVars expected to be: \n %v\nGot:\n %v\n",
"[VAR1=value,othervalue VAR=value2]", runCmdOptions.EnvVars)
- }
-}
-
func TestLoadFromEnvVar(t *testing.T) {
//shows how to include a "," character inside an env value see VAR1
value
os.Setenv("KAMEL_RUN_ENVS",
"\"VAR1=value,\"\"othervalue\"\"\",VAR2=value2")
- options, rootCmd := kamelTestPreAddCommandInit()
-
- runCmdOptions := addTestRunCmd(options, rootCmd)
-
- kamelTestPostAddCommandInit(t, rootCmd)
+ runCmdOptions, rootCmd, _ := initializeRunCmdOptions(t)
_, err := test.ExecuteCommand(rootCmd, "run", "route.java")
if err != nil {
t.Fatalf("Unexpected error: %v", err)
}
-
if len(runCmdOptions.EnvVars) != 2 {
t.Fatalf("Properties expected to contain: \n %v
elements\nGot:\n %v elemtns\n", 2, len(runCmdOptions.EnvVars))
}
@@ -95,17 +69,13 @@ func TestLoadFromFile(t *testing.T) {
var propertiesFile = []byte(`kamel.run.envs:
"VAR1=value,""othervalue""",VAR2=value2`)
viper.SetConfigType("properties")
readViperConfigFromBytes(propertiesFile, t)
- options, rootCmd := kamelTestPreAddCommandInit()
-
- runCmdOptions := addTestRunCmd(options, rootCmd)
- kamelTestPostAddCommandInit(t, rootCmd)
+ runCmdOptions, rootCmd, _ := initializeRunCmdOptions(t)
_, err := test.ExecuteCommand(rootCmd, "run", "route.java")
if err != nil {
t.Fatalf("Unexpected error: %v", err)
}
-
if len(runCmdOptions.EnvVars) != 2 {
t.Fatalf("Properties expected to contain: \n %v
elements\nGot:\n %v elemtns\n", 2, len(runCmdOptions.EnvVars))
}
@@ -119,17 +89,13 @@ func TestPrecedenceEnvVarOverFile(t *testing.T) {
var propertiesFile = []byte(`kamel.run.envs: VAR2=file`)
viper.SetConfigType("properties")
readViperConfigFromBytes(propertiesFile, t)
- options, rootCmd := kamelTestPreAddCommandInit()
-
- runCmdOptions := addTestRunCmd(options, rootCmd)
- kamelTestPostAddCommandInit(t, rootCmd)
+ runCmdOptions, rootCmd, _ := initializeRunCmdOptions(t)
_, err := test.ExecuteCommand(rootCmd, "run", "route.java")
if err != nil {
t.Fatalf("Unexpected error: %v", err)
}
-
if len(runCmdOptions.EnvVars) != 1 {
t.Fatalf("Properties expected to contain: \n %v
elements\nGot:\n %v elements\n", 1, len(runCmdOptions.EnvVars))
}
@@ -143,17 +109,13 @@ func TestPrecedenceCommandLineOverEverythingElse(t
*testing.T) {
var propertiesFile = []byte(`kamel.run.envs: VAR2=file`)
viper.SetConfigType("properties")
readViperConfigFromBytes(propertiesFile, t)
- options, rootCmd := kamelTestPreAddCommandInit()
- runCmdOptions := addTestRunCmd(options, rootCmd)
-
- kamelTestPostAddCommandInit(t, rootCmd)
+ runCmdOptions, rootCmd, _ := initializeRunCmdOptions(t)
_, err := test.ExecuteCommand(rootCmd, "run", "route.java", "--env",
"VAR3=commandLine")
if err != nil {
t.Fatalf("Unexpected error: %v", err)
}
-
if len(runCmdOptions.EnvVars) != 1 {
t.Fatalf("Properties expected to contain: \n %v
elements\nGot:\n %v elements\n", 1, len(runCmdOptions.EnvVars))
}
diff --git a/pkg/cmd/run_test.go b/pkg/cmd/run_test.go
index 0be892b..9db4193 100644
--- a/pkg/cmd/run_test.go
+++ b/pkg/cmd/run_test.go
@@ -29,123 +29,226 @@ import (
"github.com/stretchr/testify/assert"
)
-func addTestRunCmd(options *RootCmdOptions, rootCmd *cobra.Command)
*runCmdOptions {
- //add a testing version of run Command
- runCmd, runCmdOptions := newCmdRun(options)
- runCmd.RunE = func(c *cobra.Command, args []string) error {
- return nil
- }
- runCmd.Args = test.ArbitraryArgs
- rootCmd.AddCommand(runCmd)
- return runCmdOptions
-}
+const cmdRun = "run"
+const integrationSource = "example.js"
-func TestRunPropertyFlag(t *testing.T) {
+func initializeRunCmdOptions(t *testing.T) (*runCmdOptions, *cobra.Command,
RootCmdOptions) {
options, rootCmd := kamelTestPreAddCommandInit()
-
- runCmdOptions := addTestRunCmd(options, rootCmd)
-
+ runCmdOptions := addTestRunCmd(*options, rootCmd)
kamelTestPostAddCommandInit(t, rootCmd)
- _, err := test.ExecuteCommand(rootCmd, "run", "route.java",
"--property", "key1=value,othervalue", "--property", "key2=value2")
- if err != nil {
- t.Fatalf("Unexpected error: %v", err)
- }
+ return runCmdOptions, rootCmd, *options
+}
- if len(runCmdOptions.Properties) != 2 {
- t.Fatalf("Properties expected to contain: \n %v
elements\nGot:\n %v elements\n", 2, len(runCmdOptions.Properties))
+func addTestRunCmd(options RootCmdOptions, rootCmd *cobra.Command)
*runCmdOptions {
+ //add a testing version of run Command
+ runCmd, runOptions := newCmdRun(&options)
+ runCmd.RunE = func(c *cobra.Command, args []string) error {
+ return nil
}
- if runCmdOptions.Properties[0] != "key1=value,othervalue" ||
runCmdOptions.Properties[1] != "key2=value2" {
- t.Fatalf("Properties expected to be: \n %v\nGot:\n %v\n",
"[key1=value,othervalue key2=value2]", runCmdOptions.Properties)
+ runCmd.PostRunE = func(c *cobra.Command, args []string) error {
+ return nil
}
+ runCmd.Args = test.ArbitraryArgs
+ rootCmd.AddCommand(runCmd)
+ return runOptions
}
-func TestRunWithAdditionalSourcesFlag(t *testing.T) {
- options, rootCmd := kamelTestPreAddCommandInit()
-
- runCmdOptions := addTestRunCmd(options, rootCmd)
-
- kamelTestPostAddCommandInit(t, rootCmd)
-
- _, err := test.ExecuteCommand(rootCmd, "run", "route.java", "--source",
"additional-source1.java", "--source", "additional-source2.java")
-
+func TestRunNoFlag(t *testing.T) {
+ runCmdOptions, rootCmd, _ := initializeRunCmdOptions(t)
+ _, err := test.ExecuteCommand(rootCmd, cmdRun, integrationSource)
assert.Nil(t, err)
- assert.Len(t, runCmdOptions.Sources, 2)
+ //Check default expected values
+ assert.Equal(t, false, runCmdOptions.Wait)
+ assert.Equal(t, false, runCmdOptions.Logs)
+ assert.Equal(t, false, runCmdOptions.Sync)
+ assert.Equal(t, false, runCmdOptions.Dev)
+ assert.Equal(t, true, runCmdOptions.UseFlows)
+ assert.Equal(t, false, runCmdOptions.Compression)
+ assert.Equal(t, true, runCmdOptions.CompressBinary)
+ assert.Equal(t, false, runCmdOptions.Save)
}
-func TestRunWithTraitFlag(t *testing.T) {
- options, rootCmd := kamelTestPreAddCommandInit()
-
- runCmdOptions := addTestRunCmd(options, rootCmd)
-
- kamelTestPostAddCommandInit(t, rootCmd)
+func TestRunNonExistingFlag(t *testing.T) {
+ _, rootCmd, _ := initializeRunCmdOptions(t)
+ _, err := test.ExecuteCommand(rootCmd, cmdRun, "--nonExistingFlag",
integrationSource)
+ assert.NotNil(t, err)
+}
- _, err := test.ExecuteCommand(rootCmd, "run", "--trait",
"sample.enabled=true", "example.js")
+func TestRunCompressBinaryFlag(t *testing.T) {
+ runCmdOptions, rootCmd, _ := initializeRunCmdOptions(t)
+ _, err := test.ExecuteCommand(rootCmd, cmdRun,
"--compress-binary=false", integrationSource)
+ assert.Nil(t, err)
+ assert.Equal(t, false, runCmdOptions.CompressBinary)
+}
+func TestRunCompressionFlag(t *testing.T) {
+ runCmdOptions, rootCmd, _ := initializeRunCmdOptions(t)
+ _, err := test.ExecuteCommand(rootCmd, cmdRun, "--compression",
integrationSource)
assert.Nil(t, err)
- assert.Equal(t, 1, len(runCmdOptions.Traits))
- assert.Equal(t, "sample.enabled=true", runCmdOptions.Traits[0])
+ assert.Equal(t, true, runCmdOptions.CompressBinary)
}
-func TestRunWithAdditionalTraitFlag(t *testing.T) {
- options, rootCmd := kamelTestPreAddCommandInit()
+func TestRunConfigMapFlag(t *testing.T) {
+ runCmdOptions, rootCmd, _ := initializeRunCmdOptions(t)
+ _, err := test.ExecuteCommand(rootCmd, cmdRun,
+ "--configmap", "configMap1",
+ "--configmap", "configMap2",
+ integrationSource)
+ assert.Nil(t, err)
+ assert.Len(t, runCmdOptions.ConfigMaps, 2)
+ assert.Equal(t, "configMap1", runCmdOptions.ConfigMaps[0])
+ assert.Equal(t, "configMap2", runCmdOptions.ConfigMaps[1])
+}
- runCmdOptions := addTestRunCmd(options, rootCmd)
+func TestRunDependencyFlag(t *testing.T) {
+ runCmdOptions, rootCmd, _ := initializeRunCmdOptions(t)
+ _, err := test.ExecuteCommand(rootCmd, cmdRun,
+ "--dependency", "dependency1",
+ "--dependency", "dependency2",
+ "--dependency", "dependency3",
+ integrationSource)
+ assert.Nil(t, err)
+ assert.Len(t, runCmdOptions.Dependencies, 3)
+ assert.Equal(t, "dependency1", runCmdOptions.Dependencies[0])
+ assert.Equal(t, "dependency2", runCmdOptions.Dependencies[1])
+ assert.Equal(t, "dependency3", runCmdOptions.Dependencies[2])
+}
- kamelTestPostAddCommandInit(t, rootCmd)
+func TestRunDevFlag(t *testing.T) {
+ runCmdOptions, rootCmd, _ := initializeRunCmdOptions(t)
+ _, err := test.ExecuteCommand(rootCmd, cmdRun, "--dev",
integrationSource)
+ assert.Nil(t, err)
+ assert.Equal(t, true, runCmdOptions.Dev)
+}
- _, err := test.ExecuteCommand(rootCmd, "run", "--trait",
"sample.enabled=true", "--trait", "sample.second=true", "example.js")
+func TestRunEnvFlag(t *testing.T) {
+ runCmdOptions, rootCmd, _ := initializeRunCmdOptions(t)
+ _, err := test.ExecuteCommand(rootCmd, cmdRun,
+ "--env", "env1",
+ "--env", "env2",
+ integrationSource)
+ assert.Nil(t, err)
+ assert.Len(t, runCmdOptions.EnvVars, 2)
+ assert.Equal(t, "env1", runCmdOptions.EnvVars[0])
+ assert.Equal(t, "env2", runCmdOptions.EnvVars[1])
+}
+func TestRunKitFlag(t *testing.T) {
+ runCmdOptions, rootCmd, _ := initializeRunCmdOptions(t)
+ _, err := test.ExecuteCommand(rootCmd, cmdRun, "--kit", "myKit",
integrationSource)
assert.Nil(t, err)
- assert.Equal(t, 2, len(runCmdOptions.Traits))
- assert.Equal(t, "sample.enabled=true", runCmdOptions.Traits[0])
- assert.Equal(t, "sample.second=true", runCmdOptions.Traits[1])
+ assert.Equal(t, "myKit", runCmdOptions.IntegrationKit)
}
-//
-// This test does work when running as single test but fails
-// otherwise as we are using a global viper instance
-//
+func TestRunLabelFlag(t *testing.T) {
+ runCmdOptions, rootCmd, _ := initializeRunCmdOptions(t)
+ _, err := test.ExecuteCommand(rootCmd, cmdRun,
+ "--label", "label1=l1",
+ "--label", "label2=l2",
+ "--label", "label3=l3",
+ integrationSource)
+ assert.Nil(t, err)
+ assert.Len(t, runCmdOptions.Labels, 3)
+ assert.Equal(t, "label1=l1", runCmdOptions.Labels[0])
+ assert.Equal(t, "label2=l2", runCmdOptions.Labels[1])
+ assert.Equal(t, "label3=l3", runCmdOptions.Labels[2])
+}
-/*
-const TestKamelConfigContent = `
-kamel:
- install:
- olm: false
- run:
- integration:
- route:
- sources:
- - examples/dns.js
- - examples/Sample.java
-`
+func TestRunLabelWrongFormatFlag(t *testing.T) {
+ _, rootCmd, _ := initializeRunCmdOptions(t)
+ _, err := test.ExecuteCommand(rootCmd, cmdRun, "--label", "label1",
integrationSource)
+ assert.NotNil(t, err)
+}
-func TestRunWithSavedValues(t *testing.T) {
- dir, err := ioutil.TempDir("", "run-")
+func TestRunLoggingLevelFlag(t *testing.T) {
+ runCmdOptions, rootCmd, _ := initializeRunCmdOptions(t)
+ _, err := test.ExecuteCommand(rootCmd, cmdRun,
+ "--logging-level", "lev1",
+ "--logging-level", "lev2",
+ integrationSource)
assert.Nil(t, err)
+ assert.Len(t, runCmdOptions.LoggingLevels, 2)
+ assert.Equal(t, "lev1", runCmdOptions.LoggingLevels[0])
+ assert.Equal(t, "lev2", runCmdOptions.LoggingLevels[1])
+}
- defer func() {
- _ = os.RemoveAll(dir)
- }()
-
- assert.Nil(t, os.Setenv("KAMEL_CONFIG_PATH", dir))
- defer func() {
- _ = os.Unsetenv("KAMEL_CONFIG_PATH")
- }()
+func TestRunLogsFlag(t *testing.T) {
+ runCmdOptions, rootCmd, _ := initializeRunCmdOptions(t)
+ _, err := test.ExecuteCommand(rootCmd, cmdRun, "--logs",
integrationSource)
+ assert.Nil(t, err)
+ assert.Equal(t, true, runCmdOptions.Logs)
+}
- assert.Nil(t, ioutil.WriteFile(path.Join(dir, "kamel-config.yaml"),
[]byte(TestKamelConfigContent), 0644))
+func TestRunMavenRepositoryFlag(t *testing.T) {
+ runCmdOptions, rootCmd, _ := initializeRunCmdOptions(t)
+ _, err := test.ExecuteCommand(rootCmd, cmdRun,
+ "--maven-repository", "repo1",
+ "--maven-repository", "repo2",
+ "--maven-repository", "repo3",
+ integrationSource)
+ assert.Nil(t, err)
+ assert.Len(t, runCmdOptions.Repositories, 3)
+ assert.Equal(t, "repo1", runCmdOptions.Repositories[0])
+ assert.Equal(t, "repo2", runCmdOptions.Repositories[1])
+ assert.Equal(t, "repo3", runCmdOptions.Repositories[2])
+}
- options, rootCmd := kamelTestPreAddCommandInit()
+func TestRunNameFlag(t *testing.T) {
+ runCmdOptions, rootCmd, _ := initializeRunCmdOptions(t)
+ _, err := test.ExecuteCommand(rootCmd, cmdRun, "--name",
"myIntegration", integrationSource)
+ assert.Nil(t, err)
+ assert.Equal(t, "myIntegration", runCmdOptions.IntegrationName)
+}
- runCmdOptions := addTestRunCmd(options, rootCmd)
+func TestRunOpenApiFlag(t *testing.T) {
+ runCmdOptions, rootCmd, _ := initializeRunCmdOptions(t)
+ _, err := test.ExecuteCommand(rootCmd, cmdRun,
+ "--open-api", "oapi1",
+ "--open-api", "oapi2",
+ integrationSource)
+ assert.Nil(t, err)
+ assert.Len(t, runCmdOptions.OpenAPIs, 2)
+ assert.Equal(t, "oapi1", runCmdOptions.OpenAPIs[0])
+ assert.Equal(t, "oapi2", runCmdOptions.OpenAPIs[1])
+}
- kamelTestPostAddCommandInit(t, rootCmd)
+func TestRunOutputFlag(t *testing.T) {
+ runCmdOptions, rootCmd, _ := initializeRunCmdOptions(t)
+ _, err := test.ExecuteCommand(rootCmd, cmdRun, "-o", "yaml",
integrationSource)
+ assert.Nil(t, err)
+ assert.Equal(t, "yaml", runCmdOptions.OutputFormat)
+}
- _, err = test.ExecuteCommand(rootCmd, "run", "route.java")
+func TestRunProfileFlag(t *testing.T) {
+ runCmdOptions, rootCmd, _ := initializeRunCmdOptions(t)
+ _, err := test.ExecuteCommand(rootCmd, cmdRun, "--profile",
"myProfile", integrationSource)
+ assert.Nil(t, err)
+ assert.Equal(t, "myProfile", runCmdOptions.Profile)
+}
+func TestRunPropertyFlag(t *testing.T) {
+ runCmdOptions, rootCmd, _ := initializeRunCmdOptions(t)
+ _, err := test.ExecuteCommand(rootCmd, cmdRun,
+ "--property", "property1",
+ "--property", "property2",
+ "--property", "property3",
+ integrationSource)
assert.Nil(t, err)
- assert.Len(t, runCmdOptions.Sources, 2)
-}*/
+ assert.Len(t, runCmdOptions.Properties, 3)
+ assert.Equal(t, "property1", runCmdOptions.Properties[0])
+ assert.Equal(t, "property2", runCmdOptions.Properties[1])
+ assert.Equal(t, "property3", runCmdOptions.Properties[2])
+}
+
+func TestRunPropertyFileFlagMissingFileExtension(t *testing.T) {
+ _, rootCmd, _ := initializeRunCmdOptions(t)
+ _, err := test.ExecuteCommand(rootCmd, cmdRun,
+ "--property-file", "file1",
+ "--property-file", "file2",
+ integrationSource)
+ assert.NotNil(t, err)
+}
const TestPropertyFileContent = `
a=b
@@ -155,7 +258,7 @@ d=c\=e
f=g\:h
`
-func TestRunPropertyFileFlag(t *testing.T) {
+func TestAddPropertyFile(t *testing.T) {
var tmpFile *os.File
var err error
if tmpFile, err = ioutil.TempFile("", "camel-k-"); err != nil {
@@ -174,10 +277,85 @@ func TestRunPropertyFileFlag(t *testing.T) {
assert.Equal(t, `f=g\:h`, spec.Configuration[3].Value)
}
+func TestRunPropertyFileFlag(t *testing.T) {
+ var tmpFile *os.File
+ var err error
+ if tmpFile, err = ioutil.TempFile("", "camel-k-*.properties"); err !=
nil {
+ t.Error(err)
+ }
+
+ assert.Nil(t, tmpFile.Close())
+ assert.Nil(t, ioutil.WriteFile(tmpFile.Name(),
[]byte(TestPropertyFileContent), 0644))
+
+ runCmdOptions, rootCmd, _ := initializeRunCmdOptions(t)
+ _, errExecute := test.ExecuteCommand(rootCmd, cmdRun,
+ "--property-file", tmpFile.Name(),
+ integrationSource)
+ assert.Nil(t, errExecute)
+ assert.Len(t, runCmdOptions.PropertyFiles, 1)
+ assert.Equal(t, tmpFile.Name(), runCmdOptions.PropertyFiles[0])
+}
+
+func TestRunResourceFlag(t *testing.T) {
+ runCmdOptions, rootCmd, _ := initializeRunCmdOptions(t)
+ _, err := test.ExecuteCommand(rootCmd, cmdRun,
+ "--resource", "res1",
+ "--resource", "res2",
+ integrationSource)
+ assert.Nil(t, err)
+ assert.Len(t, runCmdOptions.Resources, 2)
+ assert.Equal(t, "res1", runCmdOptions.Resources[0])
+ assert.Equal(t, "res2", runCmdOptions.Resources[1])
+}
+
+func TestRunSaveFlag(t *testing.T) {
+ runCmdOptions, rootCmd, _ := initializeRunCmdOptions(t)
+ _, err := test.ExecuteCommand(rootCmd, cmdRun, "--save",
integrationSource)
+ assert.Nil(t, err)
+ assert.Equal(t, true, runCmdOptions.Save)
+}
+
+func TestRunSecretFlag(t *testing.T) {
+ runCmdOptions, rootCmd, _ := initializeRunCmdOptions(t)
+ _, err := test.ExecuteCommand(rootCmd, cmdRun,
+ "--secret", "secret1",
+ "--secret", "secret2",
+ integrationSource)
+ assert.Nil(t, err)
+ assert.Len(t, runCmdOptions.Secrets, 2)
+ assert.Equal(t, "secret1", runCmdOptions.Secrets[0])
+ assert.Equal(t, "secret2", runCmdOptions.Secrets[1])
+}
+
+func TestRunSourceFlag(t *testing.T) {
+ runCmdOptions, rootCmd, _ := initializeRunCmdOptions(t)
+ _, err := test.ExecuteCommand(rootCmd, cmdRun, "--source", "source1",
integrationSource)
+ assert.Nil(t, err)
+ assert.Len(t, runCmdOptions.Sources, 1)
+ assert.Equal(t, "source1", runCmdOptions.Sources[0])
+}
+
+func TestRunSyncFlag(t *testing.T) {
+ runCmdOptions, rootCmd, _ := initializeRunCmdOptions(t)
+ _, err := test.ExecuteCommand(rootCmd, cmdRun, "--sync",
integrationSource)
+ assert.Nil(t, err)
+ assert.Equal(t, true, runCmdOptions.Sync)
+}
+
+func TestRunTraitFlag(t *testing.T) {
+ runCmdOptions, rootCmd, _ := initializeRunCmdOptions(t)
+ _, err := test.ExecuteCommand(rootCmd, cmdRun,
+ "--trait", "trait1",
+ "--trait", "trait2",
+ integrationSource)
+ assert.Nil(t, err)
+ assert.Len(t, runCmdOptions.Traits, 2)
+ assert.Equal(t, "trait1", runCmdOptions.Traits[0])
+ assert.Equal(t, "trait2", runCmdOptions.Traits[1])
+}
+
func TestConfigureTraits(t *testing.T) {
- options, rootCmd := kamelTestPreAddCommandInit()
- runCmdOptions := addTestRunCmd(options, rootCmd)
- kamelTestPostAddCommandInit(t, rootCmd)
+ runCmdOptions, rootCmd, _ := initializeRunCmdOptions(t)
_, err := test.ExecuteCommand(rootCmd, "run",
"--trait", "affinity.pod-affinity=false",
"--trait", "container.probes-enabled=false",
@@ -209,3 +387,76 @@ func assertTraitConfiguration(t *testing.T, traits
map[string]v1.TraitSpec, trai
assert.Contains(t, traits, trait)
assert.Equal(t, expected,
string(traits[trait].Configuration.RawMessage))
}
+
+func TestRunUseFlowsFlag(t *testing.T) {
+ runCmdOptions, rootCmd, _ := initializeRunCmdOptions(t)
+ _, err := test.ExecuteCommand(rootCmd, cmdRun, "--use-flows=false",
integrationSource)
+ assert.Nil(t, err)
+ assert.Equal(t, false, runCmdOptions.UseFlows)
+}
+
+func TestRunVolumeFlag(t *testing.T) {
+ runCmdOptions, rootCmd, _ := initializeRunCmdOptions(t)
+ _, err := test.ExecuteCommand(rootCmd, cmdRun,
+ "-v", "pvcname:/container1/path",
+ "-v", "pvcname:/container2/path",
+ integrationSource)
+ assert.Nil(t, err)
+ assert.Len(t, runCmdOptions.Volumes, 2)
+ assert.Equal(t, "pvcname:/container1/path", runCmdOptions.Volumes[0])
+ assert.Equal(t, "pvcname:/container2/path", runCmdOptions.Volumes[1])
+}
+
+func TestRunVolumeFlagWrongPVCFormat(t *testing.T) {
+ _, rootCmd, _ := initializeRunCmdOptions(t)
+ _, err := test.ExecuteCommand(rootCmd, cmdRun,
+ "-v", "pvcname",
+ "-v", "pvcname/container2/path",
+ integrationSource)
+ assert.NotNil(t, err)
+}
+
+//
+// This test does work when running as single test but fails
+// otherwise as we are using a global viper instance
+//
+
+/*
+const TestKamelConfigContent = `
+kamel:
+ install:
+ olm: false
+ run:
+ integration:
+ route:
+ sources:
+ - examples/dns.js
+ - examples/Sample.java
+`
+
+func TestRunWithSavedValues(t *testing.T) {
+ dir, err := ioutil.TempDir("", "run-")
+ assert.Nil(t, err)
+
+ defer func() {
+ _ = os.RemoveAll(dir)
+ }()
+
+ assert.Nil(t, os.Setenv("KAMEL_CONFIG_PATH", dir))
+ defer func() {
+ _ = os.Unsetenv("KAMEL_CONFIG_PATH")
+ }()
+
+ assert.Nil(t, ioutil.WriteFile(path.Join(dir, "kamel-config.yaml"),
[]byte(TestKamelConfigContent), 0644))
+
+ options, rootCmd := kamelTestPreAddCommandInit()
+
+ runCmdOptions := addTestRunCmd(options, rootCmd)
+
+ kamelTestPostAddCommandInit(t, rootCmd)
+
+ _, err = test.ExecuteCommand(rootCmd, "run", "route.java")
+
+ assert.Nil(t, err)
+ assert.Len(t, runCmdOptions.Sources, 2)
+}*/
