From 26491cb2ea13653802900525f6f2298a8ecb7c33 Mon Sep 17 00:00:00 2001 From: Pasquale Congiusti Date: Mon, 11 Jan 2021 16:02:59 +0100 Subject: [PATCH] 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 a050a5f3c0..d7ee8d9491 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 0be892b12b..9db419392d 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) +}*/