refactor: redirect integration tests to use monaco.runWithFs instead …

…of manually composing and executing cobra command

cmd/monaco/integrationtest/account/all_resources_integration_test.go

@@ -20,6 +20,10 @@ package account
 
 import (
 	"context"
+	"net/http"
+	"slices"
+	"testing"
+
 	"github.com/dynatrace/dynatrace-configuration-as-code-core/api/clients/accounts"
 	accountmanagement "github.com/dynatrace/dynatrace-configuration-as-code-core/gen/account_management"
 	"github.com/dynatrace/dynatrace-configuration-as-code/v2/cmd/monaco/runner"
@@ -28,9 +32,6 @@ import (
 	"github.com/dynatrace/dynatrace-configuration-as-code/v2/pkg/persistence/account/writer"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
-	"net/http"
-	"slices"
-	"testing"
 )
 
 func TestDeployAndDelete_AllResources(t *testing.T) {

cmd/monaco/integrationtest/account/deploy-download_test.go

@@ -35,7 +35,7 @@ import (
 func TestIdempotenceOfDeployment(t *testing.T) {
 
 	deploy := func(project string, fs afero.Fs) *account.Resources {
-		err := monaco.RunWithFsf(fs, "monaco account deploy --project %s --verbose", project)
+		err := monaco.RunWithFSf(fs, "monaco account deploy --project %s --verbose", project)
 
 		require.NoError(t, err)
 
@@ -45,7 +45,7 @@ func TestIdempotenceOfDeployment(t *testing.T) {
 		return r
 	}
 	download := func(project string, fs afero.Fs) *account.Resources {
-		err := monaco.RunWithFsf(fs, "monaco account download --project %s --output-folder output --verbose", project)
+		err := monaco.RunWithFSf(fs, "monaco account download --project %s --output-folder output --verbose", project)
 		require.NoError(t, err)
 
 		r, err := loader.Load(fs, fmt.Sprintf("%s/%s/%s", "output", project, "test-account"))
@@ -93,6 +93,6 @@ func TestIdempotenceOfDeployment(t *testing.T) {
 		assert.Equal(t, deploy1st.Groups[g.ID], deploy2nd.Groups[g.ID])
 	}
 
-	err := monaco.RunWithFsf(baseFs, "monaco account delete --manifest manifest.yaml --file delete.yaml")
+	err := monaco.RunWithFSf(baseFs, "monaco account delete --manifest manifest.yaml --file delete.yaml")
 	require.NoError(t, err)
 }

cmd/monaco/integrationtest/account/utils_test.go

@@ -19,12 +19,13 @@ package account
 import (
 	"bytes"
 	"fmt"
+	"strings"
+	"testing"
+
 	"github.com/dynatrace/dynatrace-configuration-as-code/v2/cmd/monaco/runner"
 	"github.com/dynatrace/dynatrace-configuration-as-code/v2/internal/files"
 	"github.com/spf13/afero"
 	"github.com/stretchr/testify/require"
-	"strings"
-	"testing"
 )
 
 func createMZone(t *testing.T) {

cmd/monaco/integrationtest/cleanup.go

@@ -42,15 +42,15 @@ func CleanupIntegrationTest(t *testing.T, fs afero.Fs, manifestPath string, envi
 	absManifestPath, err := filepath.Abs(manifestPath)
 	require.NoError(t, err)
 
-	err = monaco.RunWithFsf(fs, "monaco generate deletefile %s --file %s --exclude-types builtin:networkzones %s", absManifestPath, deleteFile, env)
+	err = monaco.RunWithFSf(fs, "monaco generate deletefile %s --file %s --exclude-types builtin:networkzones %s", absManifestPath, deleteFile, env)
 	require.NoError(t, err)
 	if df, err := filepath.Abs(deleteFile); err == nil {
 		if b, err := afero.ReadFile(fs, df); err == nil {
 			fmt.Println(string(b[:]))
 		}
 	}
 
-	err = monaco.RunWithFsf(fs, "monaco delete --manifest %s --file %s %s", manifestPath, deleteFile, env)
+	err = monaco.RunWithFSf(fs, "monaco delete --manifest %s --file %s %s", manifestPath, deleteFile, env)
 	if err != nil {
 		t.Log(err)
 		t.Log("Failed to cleanup all test configurations, manual/nightly cleanup needed.")

cmd/monaco/integrationtest/utils/monaco/cmd.go

@@ -35,12 +35,12 @@ func Run(command string) error {
 }
 
 func Runf(command string, args ...any) error {
-	return RunWithFsf(newFs(), command, args...)
+	return RunWithFSf(newFs(), command, args...)
 }
 
 func newFs() afero.Fs { return afero.NewCopyOnWriteFs(afero.NewOsFs(), afero.NewMemMapFs()) }
 
-func RunWithFsf(fs afero.Fs, command string, args ...any) error {
+func RunWithFSf(fs afero.Fs, command string, args ...any) error {
 	return RunWithFs(fs, fmt.Sprintf(command, args...))
 }
 

cmd/monaco/integrationtest/v1/all_configs_integration_test.go

@@ -35,11 +35,11 @@ func TestIntegrationAllConfigs(t *testing.T) {
 
 	RunLegacyIntegrationWithCleanup(t, allConfigsFolder, allConfigsEnvironmentsFile, "AllConfigs", func(fs afero.Fs, manifest string) {
 		// This causes a POST for all configs:
-		err := monaco.RunWithFsf(fs, "monaco deploy %s --verbose", manifest)
+		err := monaco.RunWithFSf(fs, "monaco deploy %s --verbose", manifest)
 		assert.NoError(t, err)
 
 		// This causes a PUT for all configs:
-		err = monaco.RunWithFsf(fs, "monaco deploy %s --verbose", manifest)
+		err = monaco.RunWithFSf(fs, "monaco deploy %s --verbose", manifest)
 		assert.NoError(t, err)
 	})
 }

cmd/monaco/integrationtest/v1/continue_deployment_on_error_integration_test.go

@@ -19,13 +19,13 @@
 package v1
 
 import (
-	"github.com/dynatrace/dynatrace-configuration-as-code/v2/cmd/monaco/runner"
+	"path/filepath"
+	"testing"
+
+	"github.com/dynatrace/dynatrace-configuration-as-code/v2/cmd/monaco/integrationtest/utils/monaco"
 	"github.com/dynatrace/dynatrace-configuration-as-code/v2/pkg/config/coordinate"
 	"github.com/spf13/afero"
 	"github.com/stretchr/testify/assert"
-
-	"path/filepath"
-	"testing"
 )
 
 // tests all configs for a single environment
@@ -35,14 +35,7 @@ func TestIntegrationContinueDeploymentOnError(t *testing.T) {
 	allConfigsEnvironmentsFile := filepath.Join(allConfigsFolder, "environments.yaml")
 
 	RunLegacyIntegrationWithCleanup(t, allConfigsFolder, allConfigsEnvironmentsFile, "AllConfigs", func(fs afero.Fs, manifest string) {
-		cmd := runner.BuildCmd(fs)
-		cmd.SetArgs([]string{
-			"deploy",
-			"--verbose",
-			manifest,
-			"--continue-on-error",
-		})
-		err := cmd.Execute()
+		err := monaco.RunWithFSf(fs, "monaco deploy %s --verbose --continue-on-error", manifest)
 		// deployment should fail
 		assert.Error(t, err, "deployment should fail")
 

cmd/monaco/integrationtest/v1/integration_test_utils.go

@@ -28,7 +28,7 @@ import (
 	"time"
 
 	"github.com/dynatrace/dynatrace-configuration-as-code/v2/cmd/monaco/integrationtest"
-	"github.com/dynatrace/dynatrace-configuration-as-code/v2/cmd/monaco/runner"
+	"github.com/dynatrace/dynatrace-configuration-as-code/v2/cmd/monaco/integrationtest/utils/monaco"
 	"github.com/dynatrace/dynatrace-configuration-as-code/v2/internal/log"
 	"github.com/dynatrace/dynatrace-configuration-as-code/v2/internal/testutils"
 	"github.com/dynatrace/dynatrace-configuration-as-code/v2/pkg/api"
@@ -194,16 +194,7 @@ func runLegacyIntegration(t *testing.T, configFolder, envFile, suffixTest string
 	manifestPath := path.Join(targetDir, "manifest.yaml")
 
 	t.Log("Converting monaco-v1 to monaco-v2")
-	cmd := runner.BuildCmd(fs)
-	cmd.SetArgs([]string{
-		"convert",
-		"--verbose",
-		envFile,
-		configFolder,
-		"-o",
-		targetDir,
-	})
-	err = cmd.Execute()
+	err = monaco.RunWithFSf(fs, "monaco convert %s %s --output-folder=%s --verbose", envFile, configFolder, targetDir)
 	assert.NoError(t, err, "Conversion should had happened without errors")
 
 	exists, err := afero.Exists(fs, manifestPath)

cmd/monaco/integrationtest/v1/multi_project_integration_test.go

@@ -36,7 +36,7 @@ var multiProjectEnvironmentsFile = filepath.Join(multiProjectFolder, "environmen
 // Tests all environments with all projects
 func TestIntegrationMultiProject(t *testing.T) {
 	RunLegacyIntegrationWithCleanup(t, multiProjectFolder, multiProjectEnvironmentsFile, "MultiProject", func(fs afero.Fs, manifest string) {
-		err := monaco.RunWithFsf(fs, "monaco deploy %s --verbose", manifest)
+		err := monaco.RunWithFSf(fs, "monaco deploy %s --verbose", manifest)
 		assert.NoError(t, err)
 
 		integrationtest.AssertAllConfigsAvailability(t, fs, manifest, []string{}, "", true)
@@ -46,15 +46,15 @@ func TestIntegrationMultiProject(t *testing.T) {
 // Tests a dry run (validation)
 func TestIntegrationValidationMultiProject(t *testing.T) {
 	RunLegacyIntegrationWithoutCleanup(t, multiProjectFolder, multiProjectEnvironmentsFile, "validMultiProj", func(fs afero.Fs, manifest string) {
-		err := monaco.RunWithFsf(fs, "monaco deploy %s --verbose --dry-run", manifest)
+		err := monaco.RunWithFSf(fs, "monaco deploy %s --verbose --dry-run", manifest)
 		assert.NoError(t, err)
 	})
 }
 
 // Tests a dry run (validation)
 func TestIntegrationValidationMultiProjectWithoutEndingSlashInPath(t *testing.T) {
 	RunLegacyIntegrationWithoutCleanup(t, multiProjectFolderWithoutSlash, multiProjectEnvironmentsFile, "validMultiProj", func(fs afero.Fs, manifest string) {
-		err := monaco.RunWithFsf(fs, "monaco deploy %s --verbose --dry-run", manifest)
+		err := monaco.RunWithFSf(fs, "monaco deploy %s --verbose --dry-run", manifest)
 		assert.NoError(t, err)
 	})
 
@@ -63,7 +63,7 @@ func TestIntegrationValidationMultiProjectWithoutEndingSlashInPath(t *testing.T)
 // tests a single project with dependencies
 func TestIntegrationMultiProjectSingleProject(t *testing.T) {
 	RunLegacyIntegrationWithCleanup(t, multiProjectFolder, multiProjectEnvironmentsFile, "MultiProjectSingleProject", func(fs afero.Fs, manifestFile string) {
-		err := monaco.RunWithFsf(fs, "monaco deploy %s --project=star-trek --verbose", manifestFile)
+		err := monaco.RunWithFSf(fs, "monaco deploy %s --project=star-trek --verbose", manifestFile)
 		assert.NoError(t, err)
 
 		t.Log("Asserting available configs")

cmd/monaco/integrationtest/v1/multi_tenant_integration_test.go

@@ -34,7 +34,7 @@ var environmentsFile = filepath.Join(folder, "environments.yaml")
 // Tests all environments with all projects
 func TestIntegrationMultiEnvironment(t *testing.T) {
 	RunLegacyIntegrationWithCleanup(t, folder, environmentsFile, "MultiEnvironment", func(fs afero.Fs, manifest string) {
-		err := monaco.RunWithFsf(fs, "monaco deploy --verbose %s", manifest)
+		err := monaco.RunWithFSf(fs, "monaco deploy --verbose %s", manifest)
 		assert.NoError(t, err)
 
 		integrationtest.AssertAllConfigsAvailability(t, fs, manifest, []string{}, "", true)
@@ -44,15 +44,15 @@ func TestIntegrationMultiEnvironment(t *testing.T) {
 // Tests a dry run (validation)
 func TestIntegrationValidationMultiEnvironment(t *testing.T) {
 	RunLegacyIntegrationWithoutCleanup(t, folder, environmentsFile, "validationMultiEnv", func(fs afero.Fs, manifest string) {
-		err := monaco.RunWithFsf(fs, "monaco deploy %s --verbose --dry-run", manifest)
+		err := monaco.RunWithFSf(fs, "monaco deploy %s --verbose --dry-run", manifest)
 		assert.NoError(t, err)
 	})
 }
 
 // tests a single project
 func TestIntegrationMultiEnvironmentSingleProject(t *testing.T) {
 	RunLegacyIntegrationWithCleanup(t, folder, environmentsFile, "MultiEnvironmentSingleProject", func(fs afero.Fs, manifestFile string) {
-		err := monaco.RunWithFsf(fs, "monaco deploy %s --verbose --project=cinema-infrastructure", manifestFile)
+		err := monaco.RunWithFSf(fs, "monaco deploy %s --verbose --project=cinema-infrastructure", manifestFile)
 		assert.NoError(t, err)
 
 		integrationtest.AssertAllConfigsAvailability(t, fs, manifestFile, []string{"cinema-infrastructure"}, "", true)
@@ -62,7 +62,7 @@ func TestIntegrationMultiEnvironmentSingleProject(t *testing.T) {
 // Tests a single project with dependency
 func TestIntegrationMultiEnvironmentSingleProjectWithDependency(t *testing.T) {
 	RunLegacyIntegrationWithCleanup(t, folder, environmentsFile, "MultiEnvironmentSingleProjectWithDependency", func(fs afero.Fs, manifestFile string) {
-		err := monaco.RunWithFsf(fs, "monaco deploy %s --project=star-trek --verbose", manifestFile)
+		err := monaco.RunWithFSf(fs, "monaco deploy %s --project=star-trek --verbose", manifestFile)
 		assert.NoError(t, err)
 
 		integrationtest.AssertAllConfigsAvailability(t, fs, manifestFile, []string{"star-trek"}, "", true)
@@ -72,7 +72,7 @@ func TestIntegrationMultiEnvironmentSingleProjectWithDependency(t *testing.T) {
 // tests a single environment
 func TestIntegrationMultiEnvironmentSingleEnvironment(t *testing.T) {
 	RunLegacyIntegrationWithCleanup(t, folder, environmentsFile, "MultiEnvironmentSingleEnvironment", func(fs afero.Fs, manifestFile string) {
-		err := monaco.RunWithFsf(fs, "monaco deploy %s --environment=environment2 --verbose", manifestFile)
+		err := monaco.RunWithFSf(fs, "monaco deploy %s --environment=environment2 --verbose", manifestFile)
 		assert.NoError(t, err)
 
 		integrationtest.AssertAllConfigsAvailability(t, fs, manifestFile, []string{"star-trek"}, "environment2", true)

cmd/monaco/integrationtest/v1/skip_deployment_validation_test.go

@@ -19,13 +19,13 @@
 package v1
 
 import (
-	"github.com/spf13/afero"
-	"github.com/stretchr/testify/assert"
-
 	"strings"
 	"testing"
 
+	"github.com/dynatrace/dynatrace-configuration-as-code/v2/cmd/monaco/integrationtest/utils/monaco"
 	"github.com/dynatrace/dynatrace-configuration-as-code/v2/cmd/monaco/runner"
+	"github.com/spf13/afero"
+	"github.com/stretchr/testify/assert"
 )
 
 var skipDeploymentFolder = AbsOrPanicFromSlash("test-resources/skip-deployment-project/")
@@ -35,15 +35,7 @@ func TestValidationSkipDeployment(t *testing.T) {
 	t.Setenv("TEST_TOKEN", "mock test token")
 
 	RunLegacyIntegrationWithoutCleanup(t, skipDeploymentFolder, skipDeploymentEnvironmentsFile, t.Name(), func(fs afero.Fs, manifest string) {
-		cmd := runner.BuildCmd(fs)
-		cmd.SetArgs([]string{
-			"deploy",
-			"--verbose",
-			"--dry-run",
-			manifest,
-			"--project", "projectA",
-		})
-		err := cmd.Execute()
+		err := monaco.RunWithFSf(fs, "monaco deploy %s --project=projectA --dry-run --verbose", manifest)
 		assert.NoError(t, err)
 	})
 
@@ -75,16 +67,7 @@ func TestValidationSkipDeploymentWithOverridingDependency(t *testing.T) {
 	t.Setenv("TEST_TOKEN", "mock test token")
 
 	RunLegacyIntegrationWithoutCleanup(t, skipDeploymentFolder, skipDeploymentEnvironmentsFile, t.Name(), func(fs afero.Fs, manifest string) {
-		cmd := runner.BuildCmd(fs)
-		cmd.SetArgs([]string{
-			"deploy",
-			"--verbose",
-			manifest,
-			"--dry-run",
-			"--project", "projectC",
-		})
-		err := cmd.Execute()
-
+		err := monaco.RunWithFSf(fs, "monaco deploy %s --project=projectC --dry-run --verbose", manifest)
 		assert.NoError(t, err)
 	})
 }
@@ -93,16 +76,7 @@ func TestValidationSkipDeploymentWithOverridingFlagValue(t *testing.T) {
 	t.Setenv("TEST_TOKEN", "mock test token")
 
 	RunLegacyIntegrationWithoutCleanup(t, skipDeploymentFolder, skipDeploymentEnvironmentsFile, t.Name(), func(fs afero.Fs, manifest string) {
-		cmd := runner.BuildCmd(fs)
-		cmd.SetArgs([]string{
-			"deploy",
-			"--verbose",
-			manifest,
-			"--dry-run",
-			"--project", "projectE",
-		})
-		err := cmd.Execute()
-
+		err := monaco.RunWithFSf(fs, "monaco deploy %s --project=projectE --dry-run --verbose", manifest)
 		assert.NoError(t, err)
 	})
 }

cmd/monaco/integrationtest/v1/special_character_in_config_integration_test.go

@@ -23,7 +23,7 @@ import (
 	"testing"
 
 	"github.com/dynatrace/dynatrace-configuration-as-code/v2/cmd/monaco/integrationtest"
-	"github.com/dynatrace/dynatrace-configuration-as-code/v2/cmd/monaco/runner"
+	"github.com/dynatrace/dynatrace-configuration-as-code/v2/cmd/monaco/integrationtest/utils/monaco"
 	"github.com/spf13/afero"
 	"github.com/stretchr/testify/assert"
 )
@@ -34,14 +34,7 @@ func TestSpecialCharactersAreCorrectlyEscapedWhereNeeded(t *testing.T) {
 	specialCharEnvironmentsFile := filepath.Join(specialCharConfigFolder, "environments.yaml")
 
 	RunLegacyIntegrationWithCleanup(t, specialCharConfigFolder, specialCharEnvironmentsFile, "SpecialCharacterInConfig", func(fs afero.Fs, manifest string) {
-
-		cmd := runner.BuildCmd(fs)
-		cmd.SetArgs([]string{
-			"deploy",
-			"--verbose",
-			manifest,
-		})
-		err := cmd.Execute()
+		err := monaco.RunWithFSf(fs, "monaco deploy %s --verbose", manifest)
 		assert.NoError(t, err)
 
 		integrationtest.AssertAllConfigsAvailability(t, fs, manifest, []string{}, "", true)

cmd/monaco/integrationtest/v2/all_configs_integration_test.go

@@ -21,9 +21,8 @@ package v2
 import (
 	"testing"
 
-	"github.com/dynatrace/dynatrace-configuration-as-code/v2/cmd/monaco/runner"
+	"github.com/dynatrace/dynatrace-configuration-as-code/v2/cmd/monaco/integrationtest/utils/monaco"
 	"github.com/dynatrace/dynatrace-configuration-as-code/v2/internal/featureflags"
-	"github.com/dynatrace/dynatrace-configuration-as-code/v2/internal/testutils"
 	"github.com/spf13/afero"
 	"github.com/stretchr/testify/assert"
 )
@@ -51,20 +50,12 @@ func runAllConfigsTest(t *testing.T, specificEnvironment string) {
 	}
 
 	RunIntegrationWithCleanupGivenEnvs(t, configFolder, manifest, specificEnvironment, "AllConfigs", envVars, func(fs afero.Fs, _ TestContext) {
-
 		// This causes a POST for all configs:
-
-		cmd := runner.BuildCmd(fs)
-		cmd.SetArgs([]string{"deploy", "--verbose", manifest, "--environment", specificEnvironment})
-		err := cmd.Execute()
-
+		err := monaco.RunWithFSf(fs, "monaco deploy %s --environment=%s --verbose", manifest, specificEnvironment)
 		assert.NoError(t, err)
 
 		// This causes a PUT for all configs:
-
-		cmd = runner.BuildCmd(fs)
-		cmd.SetArgs([]string{"deploy", "--verbose", manifest, "--environment", specificEnvironment})
-		err = cmd.Execute()
+		err = monaco.RunWithFSf(fs, "monaco deploy %s --environment=%s --verbose", manifest, specificEnvironment)
 		assert.NoError(t, err)
 
 	})
@@ -76,12 +67,6 @@ func TestIntegrationValidationAllConfigs(t *testing.T) {
 	t.Setenv("UNIQUE_TEST_SUFFIX", "can-be-nonunique-for-validation")
 	t.Setenv(featureflags.Temporary[featureflags.OpenPipeline].EnvName(), "true")
 
-	configFolder := "test-resources/integration-all-configs/"
-	manifest := configFolder + "manifest.yaml"
-
-	cmd := runner.BuildCmd(testutils.CreateTestFileSystem())
-	cmd.SetArgs([]string{"deploy", "--verbose", "--dry-run", manifest})
-	err := cmd.Execute()
-
+	err := monaco.Runf("monaco deploy %s --dry-run --verbose", "test-resources/integration-all-configs/manifest.yaml")
 	assert.NoError(t, err)
 }