diff --git a/airflow/airflow.go b/airflow/airflow.go index 3ad80f8f5..8082baa61 100644 --- a/airflow/airflow.go +++ b/airflow/airflow.go @@ -31,9 +31,6 @@ var ( //go:embed include/dockerfile Dockerfile string - //go:embed include/test-conflicts.dockerfile - testConflictsDockerfile string - //go:embed include/dockerignore Dockerignore string @@ -139,18 +136,6 @@ func Init(path, airflowImageName, airflowImageTag, template string) error { return nil } -func initConflictTest(path, airflowImageName, airflowImageTag string) error { - // Map of files to create - files := map[string]string{ - "conflict-check.Dockerfile": fmt.Sprintf(testConflictsDockerfile, airflowImageName, airflowImageTag), - } - // Initialize files - if err := initFiles(path, files); err != nil { - return errors.Wrap(err, "failed to create upgrade check files") - } - return nil -} - // repositoryName creates an airflow repository name func repositoryName(name string) string { return fmt.Sprintf("%s/%s", name, componentName) diff --git a/airflow/airflow_test.go b/airflow/airflow_test.go index 2afd81266..0662d74bf 100644 --- a/airflow/airflow_test.go +++ b/airflow/airflow_test.go @@ -117,21 +117,3 @@ func (s *Suite) TestTemplateInitFail() { err = Init(tmpDir, "astro-runtime", "test", "etl") s.EqualError(err, "failed to set up template-based astro project: error extracting files") } - -func (s *Suite) TestInitConflictTest() { - tmpDir, err := os.MkdirTemp("", "temp") - s.Require().NoError(err) - defer os.RemoveAll(tmpDir) - - err = initConflictTest(tmpDir, "astro-runtime", "test") - s.NoError(err) - - expectedFiles := []string{ - "conflict-check.Dockerfile", - } - for _, file := range expectedFiles { - exist, err := fileutil.Exists(filepath.Join(tmpDir, file), nil) - s.NoError(err) - s.True(exist) - } -} diff --git a/airflow/container.go b/airflow/container.go index 8d958e9bd..1da032f0c 100644 --- a/airflow/container.go +++ b/airflow/container.go @@ -35,7 +35,7 @@ type ContainerHandler interface { ComposeExport(settingsFile, composeFile string) error Pytest(pytestFile, customImageName, deployImageName, pytestArgsString, buildSecretString string) (string, error) Parse(customImageName, deployImageName, buildSecretString string) error - UpgradeTest(runtimeVersion, deploymentID, newImageName, customImageName, buildSecretString string, dependencyTest, versionTest, dagTest bool, astroPlatformCore astroplatformcore.ClientWithResponsesInterface) error + UpgradeTest(runtimeVersion, deploymentID, newImageName, customImageName, buildSecretString string, versionTest, dagTest bool, astroPlatformCore astroplatformcore.ClientWithResponsesInterface) error } // RegistryHandler defines methods require to handle all operations with registry @@ -54,7 +54,6 @@ type ImageHandler interface { TagLocalImage(localImage string) error Run(dagID, envFile, settingsFile, containerName, dagFile, executionDate string, taskLogs bool) error Pytest(pytestFile, airflowHome, envFile, testHomeDirectory string, pytestArgs []string, htmlReport bool, config types.ImageBuildConfig) (string, error) - ConflictTest(workingDirectory, testHomeDirectory string, buildConfig types.ImageBuildConfig) (string, error) CreatePipFreeze(altImageName, pipFreezeFile string) error GetImageRepoSHA(registry string) (string, error) } diff --git a/airflow/docker.go b/airflow/docker.go index cf7d251f4..0e25b2b2e 100644 --- a/airflow/docker.go +++ b/airflow/docker.go @@ -548,7 +548,7 @@ func (d *DockerCompose) Pytest(pytestFile, customImageName, deployImageName, pyt return exitCode, errors.New("something went wrong while Pytesting your DAGs") } -func (d *DockerCompose) UpgradeTest(newAirflowVersion, deploymentID, newImageName, customImage, buildSecretString string, conflictTest, versionTest, dagTest bool, astroPlatformCore astroplatformcore.CoreClient) error { +func (d *DockerCompose) UpgradeTest(newAirflowVersion, deploymentID, newImageName, customImage, buildSecretString string, versionTest, dagTest bool, astroPlatformCore astroplatformcore.CoreClient) error { // figure out which tests to run if !versionTest && !dagTest { versionTest = true @@ -598,13 +598,6 @@ func (d *DockerCompose) UpgradeTest(newAirflowVersion, deploymentID, newImageNam } newDockerFile := destFolder + "/Dockerfile" - // check for dependency conflicts - if conflictTest { - err = d.conflictTest(testHomeDirectory, newImageName, newAirflowVersion) - if err != nil { - return err - } - } if versionTest { err := d.versionTest(testHomeDirectory, currentAirflowVersion, deploymentImage, newDockerFile, newAirflowVersion, customImage, buildSecretString) if err != nil { @@ -620,9 +613,6 @@ func (d *DockerCompose) UpgradeTest(newAirflowVersion, deploymentID, newImageNam } fmt.Println("\nTest Summary:") fmt.Printf("\tUpgrade Test Results Directory: %s\n", testHomeDirectory) - if conflictTest { - fmt.Printf("\tDependency Conflict Test Results file: %s\n", "conflict-test-results.txt") - } if versionTest { fmt.Printf("\tDependency Version Comparison Results file: %s\n", "dependency_compare.txt") } @@ -656,31 +646,6 @@ func (d *DockerCompose) pullImageFromDeployment(deploymentID string, platformCor return nil } -func (d *DockerCompose) conflictTest(testHomeDirectory, newImageName, newAirflowVersion string) error { - fmt.Println("\nChecking your 'requirements.txt' for dependency conflicts with the new version of Airflow") - fmt.Println("\nThis may take a few minutes...") - - // create files needed for conflict test - err := initConflictTest(config.WorkingPath, newImageName, newAirflowVersion) - defer os.Remove("conflict-check.Dockerfile") - if err != nil { - return err - } - - exitCode, conflictErr := d.imageHandler.ConflictTest(d.airflowHome, testHomeDirectory, airflowTypes.ImageBuildConfig{Path: d.airflowHome}) - if conflictErr != nil { - return conflictErr - } - if strings.Contains(exitCode, "0") || exitCode == "" { // if the error code is 0 the pytests passed - fmt.Println("There were no dependency conflicts found") - } else { - fmt.Println("\nSomething went wrong while compiling your dependencies check the logs above for conflicts") - fmt.Println("If there are conflicts remove them from your 'requirments.txt' and rerun this test\nYou will see the best candidate in the 'conflict-test-results.txt' file") - return err - } - return nil -} - func (d *DockerCompose) versionTest(testHomeDirectory, currentAirflowVersion, deploymentImage, newDockerFile, newAirflowVersion, customImage, buildSecretString string) error { fmt.Println("\nComparing dependency versions between current and upgraded environment") // pip freeze old Airflow image diff --git a/airflow/docker_image.go b/airflow/docker_image.go index 100505f01..cce2893e9 100644 --- a/airflow/docker_image.go +++ b/airflow/docker_image.go @@ -11,7 +11,6 @@ import ( "io" "os" "os/exec" - "regexp" "strings" "github.com/astronomer/astro-cli/airflow/runtimes" @@ -30,7 +29,6 @@ import ( ) const ( - EchoCmd = "echo" pushingImagePrompt = "Pushing image to Astronomer registry" astroRunContainer = "astro-run" pullingImagePrompt = "Pulling image from Astronomer registry" @@ -264,82 +262,6 @@ func (d *DockerImage) Pytest(pytestFile, airflowHome, envFile, testHomeDirectory return outb.String(), err } -func (d *DockerImage) ConflictTest(workingDirectory, testHomeDirectory string, buildConfig airflowTypes.ImageBuildConfig) (string, error) { - containerRuntime, err := runtimes.GetContainerRuntimeBinary() - if err != nil { - return "", err - } - // delete container - err = cmdExec(containerRuntime, nil, nil, "rm", "astro-temp-container") - if err != nil { - logger.Debug(err) - } - // Change to location of Dockerfile - err = os.Chdir(buildConfig.Path) - if err != nil { - return "", err - } - args := []string{ - "build", - "-t", - "conflict-check:latest", - "-f", - "conflict-check.Dockerfile", - ".", - } - - // Create a buffer to capture the command output - var stdout, stderr bytes.Buffer - multiStdout := io.MultiWriter(&stdout, os.Stdout) - multiStderr := io.MultiWriter(&stderr, os.Stdout) - - // Start the command execution - err = cmdExec(containerRuntime, multiStdout, multiStderr, args...) - if err != nil { - return "", err - } - // Get the exit code - exitCode := "" - if _, ok := err.(*exec.ExitError); ok { - // The command exited with a non-zero status - exitCode = parseExitCode(stderr.String()) - } else if err != nil { - // An error occurred while running the command - return "", err - } - // Run a temporary container to copy the file from the image - err = cmdExec(containerRuntime, nil, nil, "create", "--name", "astro-temp-container", "conflict-check:latest") - if err != nil { - return exitCode, err - } - // Copy the result.txt file from the container to the destination folder - err1 := cmdExec(containerRuntime, nil, nil, "cp", "astro-temp-container:/usr/local/airflow/conflict-test-results.txt", "./"+testHomeDirectory) - if err1 != nil { - // Remove the temporary container - err = cmdExec(containerRuntime, nil, nil, "rm", "astro-temp-container") - if err != nil { - return exitCode, err - } - return exitCode, err1 - } - - // Remove the temporary container - err = cmdExec(containerRuntime, nil, nil, "rm", "astro-temp-container") - if err != nil { - return exitCode, err - } - return exitCode, nil -} - -func parseExitCode(logs string) string { - re := regexp.MustCompile(`exit code: (\d+)`) - match := re.FindStringSubmatch(logs) - if len(match) > 1 { - return match[1] - } - return "" -} - func (d *DockerImage) CreatePipFreeze(altImageName, pipFreezeFile string) error { containerRuntime, err := runtimes.GetContainerRuntimeBinary() if err != nil { diff --git a/airflow/docker_image_test.go b/airflow/docker_image_test.go index 586f28512..d4a12c6e3 100644 --- a/airflow/docker_image_test.go +++ b/airflow/docker_image_test.go @@ -223,103 +223,6 @@ func (s *Suite) TestDockerImagePytest() { }) } -func (s *Suite) TestDockerImageConflictTest() { - handler := DockerImage{ - imageName: "testing", - } - - cwd, err := os.Getwd() - s.NoError(err) - - dockerIgnoreFile := cwd + "/.dockerignore" - fileutil.WriteStringToFile(dockerIgnoreFile, "") - defer afero.NewOsFs().Remove(dockerIgnoreFile) - - options := airflowTypes.ImageBuildConfig{ - Path: cwd, - TargetPlatforms: []string{"linux/amd64"}, - NoCache: false, - } - - s.Run("conflict test success", func() { - cmdExec = func(cmd string, stdout, stderr io.Writer, args ...string) error { - return nil - } - _, err = handler.ConflictTest("", "", options) - s.NoError(err) - }) - - s.Run("conflict test create error", func() { - options = airflowTypes.ImageBuildConfig{ - Path: cwd, - TargetPlatforms: []string{"linux/amd64"}, - NoCache: false, - } - - cmdExec = func(cmd string, stdout, stderr io.Writer, args ...string) error { - return errMock - } - _, err = handler.ConflictTest("", "", options) - s.Error(err) - }) - - s.Run("conflict test cp error", func() { - options = airflowTypes.ImageBuildConfig{ - Path: cwd, - TargetPlatforms: []string{"linux/amd64"}, - NoCache: false, - } - - cmdExec = func(cmd string, stdout, stderr io.Writer, args ...string) error { - switch { - case args[0] == "cp": - return errMock - default: - return nil - } - } - _, err = handler.ConflictTest("", "", options) - s.Error(err) - }) - - s.Run("conflict test rm error", func() { - options = airflowTypes.ImageBuildConfig{ - Path: cwd, - TargetPlatforms: []string{"linux/amd64"}, - NoCache: false, - } - - cmdExec = func(cmd string, stdout, stderr io.Writer, args ...string) error { - switch { - case args[0] == "rm": - return errMock - default: - return nil - } - } - _, err = handler.ConflictTest("", "", options) - s.Error(err) - }) - s.Run("unable to read file error", func() { - options := airflowTypes.ImageBuildConfig{ - Path: "incorrect-path", - TargetPlatforms: []string{"linux/amd64"}, - NoCache: false, - } - - _, err = handler.ConflictTest("", "", options) - s.Error(err) - }) -} - -func (s *Suite) TestParseExitCode() { - output := "exit code: 1" - s.Run("success", func() { - _ = parseExitCode(output) - _ = parseExitCode("") - }) -} - func (s *Suite) TestDockerCreatePipFreeze() { handler := DockerImage{ imageName: "testing", diff --git a/airflow/docker_test.go b/airflow/docker_test.go index 17196c8e3..19755f18b 100644 --- a/airflow/docker_test.go +++ b/airflow/docker_test.go @@ -1024,14 +1024,13 @@ func (s *Suite) TestDockerComposeUpgradeTest() { imageHandler := new(mocks.ImageHandler) imageHandler.On("Build", mock.Anything, mock.Anything, airflowTypes.ImageBuildConfig{Path: mockDockerCompose.airflowHome, NoCache: false}).Return(nil).Times(3) imageHandler.On("GetLabel", mock.Anything, mock.Anything).Return("old-version", nil) - imageHandler.On("ConflictTest", mock.Anything, mock.Anything, airflowTypes.ImageBuildConfig{Path: mockDockerCompose.airflowHome, NoCache: false}).Return("", nil).Once() imageHandler.On("CreatePipFreeze", mock.Anything, pipFreeze).Return(nil).Once() imageHandler.On("CreatePipFreeze", mock.Anything, pipFreeze2).Return(nil).Once() imageHandler.On("Pytest", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, airflowTypes.ImageBuildConfig{Path: mockDockerCompose.airflowHome, NoCache: false}).Return("0", nil).Once() mockDockerCompose.imageHandler = imageHandler - err := mockDockerCompose.UpgradeTest("new-version", "", "", "", "", true, false, false, nil) + err := mockDockerCompose.UpgradeTest("new-version", "", "", "", "", false, false, nil) s.NoError(err) imageHandler.AssertExpectations(s.T()) @@ -1045,14 +1044,13 @@ func (s *Suite) TestDockerComposeUpgradeTest() { imageHandler.On("Pull", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(nil) imageHandler.On("Build", mock.Anything, mock.Anything, airflowTypes.ImageBuildConfig{Path: mockDockerCompose.airflowHome, NoCache: false}).Return(nil).Times(2) imageHandler.On("GetLabel", mock.Anything, mock.Anything).Return("old-version", nil) - imageHandler.On("ConflictTest", mock.Anything, mock.Anything, airflowTypes.ImageBuildConfig{Path: mockDockerCompose.airflowHome, NoCache: false}).Return("", nil).Once() imageHandler.On("CreatePipFreeze", mock.Anything, pipFreeze).Return(nil).Once() imageHandler.On("CreatePipFreeze", mock.Anything, pipFreeze2).Return(nil).Once() imageHandler.On("Pytest", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, airflowTypes.ImageBuildConfig{Path: mockDockerCompose.airflowHome, NoCache: false}).Return("0", nil).Once() mockDockerCompose.imageHandler = imageHandler - err := mockDockerCompose.UpgradeTest("new-version", "test-deployment-id", "", "", "", true, false, false, mockPlatformCoreClient) + err := mockDockerCompose.UpgradeTest("new-version", "test-deployment-id", "", "", "", false, false, mockPlatformCoreClient) s.NoError(err) imageHandler.AssertExpectations(s.T()) @@ -1064,7 +1062,7 @@ func (s *Suite) TestDockerComposeUpgradeTest() { mockDockerCompose.imageHandler = imageHandler - err = mockDockerCompose.UpgradeTest("new-version", "", "", "", "", true, false, false, nil) + err = mockDockerCompose.UpgradeTest("new-version", "", "", "", "", false, false, nil) s.Error(err) imageHandler.AssertExpectations(s.T()) }) @@ -1076,7 +1074,7 @@ func (s *Suite) TestDockerComposeUpgradeTest() { mockDockerCompose.imageHandler = imageHandler - err = mockDockerCompose.UpgradeTest("new-version", "", "", "", "", true, false, false, nil) + err = mockDockerCompose.UpgradeTest("new-version", "", "", "", "", false, false, nil) s.Error(err) imageHandler.AssertExpectations(s.T()) }) @@ -1088,20 +1086,7 @@ func (s *Suite) TestDockerComposeUpgradeTest() { mockDockerCompose.imageHandler = imageHandler - err = mockDockerCompose.UpgradeTest("new-version", "", "", "", "", true, false, false, nil) - s.Error(err) - imageHandler.AssertExpectations(s.T()) - }) - - s.Run("ConflictTest failure", func() { - imageHandler := new(mocks.ImageHandler) - imageHandler.On("Build", mock.Anything, mock.Anything, airflowTypes.ImageBuildConfig{Path: mockDockerCompose.airflowHome, NoCache: false}).Return(nil).Once() - imageHandler.On("GetLabel", mock.Anything, mock.Anything).Return("old-version", nil) - imageHandler.On("ConflictTest", mock.Anything, mock.Anything, airflowTypes.ImageBuildConfig{Path: mockDockerCompose.airflowHome, NoCache: false}).Return("", errMockDocker).Once() - - mockDockerCompose.imageHandler = imageHandler - - err = mockDockerCompose.UpgradeTest("new-version", "", "", "", "", true, false, false, nil) + err = mockDockerCompose.UpgradeTest("new-version", "", "", "", "", false, false, nil) s.Error(err) imageHandler.AssertExpectations(s.T()) }) @@ -1110,12 +1095,11 @@ func (s *Suite) TestDockerComposeUpgradeTest() { imageHandler := new(mocks.ImageHandler) imageHandler.On("Build", mock.Anything, mock.Anything, airflowTypes.ImageBuildConfig{Path: mockDockerCompose.airflowHome, NoCache: false}).Return(nil).Once() imageHandler.On("GetLabel", mock.Anything, mock.Anything).Return("old-version", nil) - imageHandler.On("ConflictTest", mock.Anything, mock.Anything, airflowTypes.ImageBuildConfig{Path: mockDockerCompose.airflowHome, NoCache: false}).Return("", nil).Once() imageHandler.On("CreatePipFreeze", mock.Anything, pipFreeze).Return(errMockDocker).Once() mockDockerCompose.imageHandler = imageHandler - err = mockDockerCompose.UpgradeTest("new-version", "", "", "", "", true, false, false, nil) + err = mockDockerCompose.UpgradeTest("new-version", "", "", "", "", false, false, nil) s.Error(err) imageHandler.AssertExpectations(s.T()) }) @@ -1124,13 +1108,12 @@ func (s *Suite) TestDockerComposeUpgradeTest() { imageHandler := new(mocks.ImageHandler) imageHandler.On("Build", mock.Anything, mock.Anything, airflowTypes.ImageBuildConfig{Path: mockDockerCompose.airflowHome, NoCache: false}).Return(nil).Once() imageHandler.On("GetLabel", mock.Anything, mock.Anything).Return("old-version", nil) - imageHandler.On("ConflictTest", mock.Anything, mock.Anything, airflowTypes.ImageBuildConfig{Path: mockDockerCompose.airflowHome, NoCache: false}).Return("", nil).Once() imageHandler.On("CreatePipFreeze", mock.Anything, pipFreeze).Return(nil).Once() imageHandler.On("Build", mock.Anything, mock.Anything, airflowTypes.ImageBuildConfig{Path: mockDockerCompose.airflowHome, NoCache: false}).Return(errMockDocker).Once() mockDockerCompose.imageHandler = imageHandler - err = mockDockerCompose.UpgradeTest("new-version", "", "", "", "", true, false, false, nil) + err = mockDockerCompose.UpgradeTest("new-version", "", "", "", "", false, false, nil) s.Error(err) imageHandler.AssertExpectations(s.T()) }) @@ -1139,14 +1122,13 @@ func (s *Suite) TestDockerComposeUpgradeTest() { imageHandler := new(mocks.ImageHandler) imageHandler.On("Build", mock.Anything, mock.Anything, airflowTypes.ImageBuildConfig{Path: mockDockerCompose.airflowHome, NoCache: false}).Return(nil).Times(2) imageHandler.On("GetLabel", mock.Anything, mock.Anything).Return("old-version", nil) - imageHandler.On("ConflictTest", mock.Anything, mock.Anything, airflowTypes.ImageBuildConfig{Path: mockDockerCompose.airflowHome, NoCache: false}).Return("", nil).Once() imageHandler.On("CreatePipFreeze", mock.Anything, pipFreeze).Return(nil).Once() imageHandler.On("CreatePipFreeze", mock.Anything, pipFreeze2).Return(nil).Once() imageHandler.On("Build", mock.Anything, mock.Anything, airflowTypes.ImageBuildConfig{Path: mockDockerCompose.airflowHome, NoCache: false}).Return(errMockDocker).Once() mockDockerCompose.imageHandler = imageHandler - err = mockDockerCompose.UpgradeTest("new-version", "", "", "", "", true, false, false, nil) + err = mockDockerCompose.UpgradeTest("new-version", "", "", "", "", false, false, nil) s.Error(err) imageHandler.AssertExpectations(s.T()) }) @@ -1155,14 +1137,13 @@ func (s *Suite) TestDockerComposeUpgradeTest() { imageHandler := new(mocks.ImageHandler) imageHandler.On("Build", mock.Anything, mock.Anything, airflowTypes.ImageBuildConfig{Path: mockDockerCompose.airflowHome, NoCache: false}).Return(nil).Times(3) imageHandler.On("GetLabel", mock.Anything, mock.Anything).Return("old-version", nil) - imageHandler.On("ConflictTest", mock.Anything, mock.Anything, airflowTypes.ImageBuildConfig{Path: mockDockerCompose.airflowHome, NoCache: false}).Return("", nil).Once() imageHandler.On("CreatePipFreeze", mock.Anything, pipFreeze).Return(nil).Once() imageHandler.On("CreatePipFreeze", mock.Anything, pipFreeze2).Return(nil).Once() imageHandler.On("Pytest", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, airflowTypes.ImageBuildConfig{Path: mockDockerCompose.airflowHome, NoCache: false}).Return("1", errMockDocker).Once() mockDockerCompose.imageHandler = imageHandler - err = mockDockerCompose.UpgradeTest("new-version", "", "", "", "", true, false, false, nil) + err = mockDockerCompose.UpgradeTest("new-version", "", "", "", "", false, false, nil) s.Error(err) imageHandler.AssertExpectations(s.T()) }) @@ -1174,7 +1155,7 @@ func (s *Suite) TestDockerComposeUpgradeTest() { mockPlatformCoreClient.On("GetDeploymentWithResponse", mock.Anything, mock.Anything, mock.Anything).Return(&mockGetDeploymentsResponse, nil).Once() mockDockerCompose.imageHandler = imageHandler - err = mockDockerCompose.UpgradeTest("new-version", "deployment-id", "", "", "", true, false, false, mockPlatformCoreClient) + err = mockDockerCompose.UpgradeTest("new-version", "deployment-id", "", "", "", false, false, mockPlatformCoreClient) s.Error(err) imageHandler.AssertExpectations(s.T()) }) @@ -1188,7 +1169,7 @@ func (s *Suite) TestDockerComposeUpgradeTest() { mockDockerCompose.imageHandler = imageHandler - err = mockDockerCompose.UpgradeTest("new-version", "test-deployment-id", "", "", "", true, false, false, mockPlatformCoreClient) + err = mockDockerCompose.UpgradeTest("new-version", "test-deployment-id", "", "", "", false, false, mockPlatformCoreClient) s.Error(err) imageHandler.AssertExpectations(s.T()) }) @@ -1197,13 +1178,12 @@ func (s *Suite) TestDockerComposeUpgradeTest() { imageHandler := new(mocks.ImageHandler) imageHandler.On("Build", mock.Anything, mock.Anything, airflowTypes.ImageBuildConfig{Path: mockDockerCompose.airflowHome, NoCache: false}).Return(nil).Twice() imageHandler.On("GetLabel", mock.Anything, mock.Anything).Return("old-version", nil) - imageHandler.On("ConflictTest", mock.Anything, mock.Anything, airflowTypes.ImageBuildConfig{Path: mockDockerCompose.airflowHome, NoCache: false}).Return("", nil).Once() imageHandler.On("CreatePipFreeze", mock.Anything, pipFreeze).Return(nil).Once() imageHandler.On("CreatePipFreeze", mock.Anything, pipFreeze2).Return(errMockDocker).Once() mockDockerCompose.imageHandler = imageHandler - err = mockDockerCompose.UpgradeTest("new-version", "", "", "", "", true, false, false, nil) + err = mockDockerCompose.UpgradeTest("new-version", "", "", "", "", false, false, nil) s.Error(err) imageHandler.AssertExpectations(s.T()) }) @@ -1212,7 +1192,7 @@ func (s *Suite) TestDockerComposeUpgradeTest() { err := config.ResetCurrentContext() s.NoError(err) - err = mockDockerCompose.UpgradeTest("new-version", "deployment-id", "", "", "", false, false, false, nil) + err = mockDockerCompose.UpgradeTest("new-version", "deployment-id", "", "", "", false, false, nil) s.Error(err) }) } diff --git a/airflow/include/test-conflicts.dockerfile b/airflow/include/test-conflicts.dockerfile deleted file mode 100644 index b04fcd805..000000000 --- a/airflow/include/test-conflicts.dockerfile +++ /dev/null @@ -1,7 +0,0 @@ -FROM quay.io/astronomer/%s:%s -USER root -RUN pip install pip-tools -RUN pip freeze > req.txt -RUN cat requirements.txt >> req.txt -RUN sed -i '/\.whl/d' req.txt -RUN python -m piptools compile --verbose req.txt -o conflict-test-results.txt diff --git a/airflow/mocks/ContainerHandler.go b/airflow/mocks/ContainerHandler.go index 433db917d..36ce4e8a0 100644 --- a/airflow/mocks/ContainerHandler.go +++ b/airflow/mocks/ContainerHandler.go @@ -267,17 +267,17 @@ func (_m *ContainerHandler) Stop(waitForExit bool) error { return r0 } -// UpgradeTest provides a mock function with given fields: runtimeVersion, deploymentID, newImageName, customImageName, buildSecretString, dependencyTest, versionTest, dagTest, astroPlatformCore -func (_m *ContainerHandler) UpgradeTest(runtimeVersion string, deploymentID string, newImageName string, customImageName string, buildSecretString string, dependencyTest bool, versionTest bool, dagTest bool, astroPlatformCore astroplatformcore.ClientWithResponsesInterface) error { - ret := _m.Called(runtimeVersion, deploymentID, newImageName, customImageName, buildSecretString, dependencyTest, versionTest, dagTest, astroPlatformCore) +// UpgradeTest provides a mock function with given fields: runtimeVersion, deploymentID, newImageName, customImageName, buildSecretString, versionTest, dagTest, astroPlatformCore +func (_m *ContainerHandler) UpgradeTest(runtimeVersion string, deploymentID string, newImageName string, customImageName string, buildSecretString string, versionTest bool, dagTest bool, astroPlatformCore astroplatformcore.ClientWithResponsesInterface) error { + ret := _m.Called(runtimeVersion, deploymentID, newImageName, customImageName, buildSecretString, versionTest, dagTest, astroPlatformCore) if len(ret) == 0 { panic("no return value specified for UpgradeTest") } var r0 error - if rf, ok := ret.Get(0).(func(string, string, string, string, string, bool, bool, bool, astroplatformcore.ClientWithResponsesInterface) error); ok { - r0 = rf(runtimeVersion, deploymentID, newImageName, customImageName, buildSecretString, dependencyTest, versionTest, dagTest, astroPlatformCore) + if rf, ok := ret.Get(0).(func(string, string, string, string, string, bool, bool, astroplatformcore.ClientWithResponsesInterface) error); ok { + r0 = rf(runtimeVersion, deploymentID, newImageName, customImageName, buildSecretString, versionTest, dagTest, astroPlatformCore) } else { r0 = ret.Error(0) } diff --git a/airflow/mocks/ImageHandler.go b/airflow/mocks/ImageHandler.go index 6ab7cf6a7..2b9379e89 100644 --- a/airflow/mocks/ImageHandler.go +++ b/airflow/mocks/ImageHandler.go @@ -30,34 +30,6 @@ func (_m *ImageHandler) Build(dockerfile string, buildSecretString string, confi return r0 } -// ConflictTest provides a mock function with given fields: workingDirectory, testHomeDirectory, buildConfig -func (_m *ImageHandler) ConflictTest(workingDirectory string, testHomeDirectory string, buildConfig types.ImageBuildConfig) (string, error) { - ret := _m.Called(workingDirectory, testHomeDirectory, buildConfig) - - if len(ret) == 0 { - panic("no return value specified for ConflictTest") - } - - var r0 string - var r1 error - if rf, ok := ret.Get(0).(func(string, string, types.ImageBuildConfig) (string, error)); ok { - return rf(workingDirectory, testHomeDirectory, buildConfig) - } - if rf, ok := ret.Get(0).(func(string, string, types.ImageBuildConfig) string); ok { - r0 = rf(workingDirectory, testHomeDirectory, buildConfig) - } else { - r0 = ret.Get(0).(string) - } - - if rf, ok := ret.Get(1).(func(string, string, types.ImageBuildConfig) error); ok { - r1 = rf(workingDirectory, testHomeDirectory, buildConfig) - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} - // CreatePipFreeze provides a mock function with given fields: altImageName, pipFreezeFile func (_m *ImageHandler) CreatePipFreeze(altImageName string, pipFreezeFile string) error { ret := _m.Called(altImageName, pipFreezeFile) @@ -198,9 +170,9 @@ func (_m *ImageHandler) Pull(remoteImage string, username string, token string) return r0 } -// Push provides a mock function with given fields: remoteImage, username, token, getImageSha -func (_m *ImageHandler) Push(remoteImage string, username string, token string, getImageSha bool) (string, error) { - ret := _m.Called(remoteImage, username, token, getImageSha) +// Push provides a mock function with given fields: remoteImage, username, token, getImageRepoSha +func (_m *ImageHandler) Push(remoteImage string, username string, token string, getImageRepoSha bool) (string, error) { + ret := _m.Called(remoteImage, username, token, getImageRepoSha) if len(ret) == 0 { panic("no return value specified for Push") @@ -209,16 +181,16 @@ func (_m *ImageHandler) Push(remoteImage string, username string, token string, var r0 string var r1 error if rf, ok := ret.Get(0).(func(string, string, string, bool) (string, error)); ok { - return rf(remoteImage, username, token, getImageSha) + return rf(remoteImage, username, token, getImageRepoSha) } if rf, ok := ret.Get(0).(func(string, string, string, bool) string); ok { - r0 = rf(remoteImage, username, token, getImageSha) + r0 = rf(remoteImage, username, token, getImageRepoSha) } else { r0 = ret.Get(0).(string) } if rf, ok := ret.Get(1).(func(string, string, string, bool) error); ok { - r1 = rf(remoteImage, username, token, getImageSha) + r1 = rf(remoteImage, username, token, getImageRepoSha) } else { r1 = ret.Error(1) } diff --git a/cmd/airflow.go b/cmd/airflow.go index a4fcdaa68..6a57afbb9 100644 --- a/cmd/airflow.go +++ b/cmd/airflow.go @@ -60,7 +60,6 @@ var ( envExport bool noBrowser bool compose bool - conflictTest bool versionTest bool dagTest bool waitTime time.Duration @@ -658,7 +657,7 @@ func airflowUpgradeTest(cmd *cobra.Command, platformCoreClient astroplatformcore buildSecretString = util.GetbuildSecretString(buildSecrets) - err = containerHandler.UpgradeTest(defaultImageTag, deploymentID, defaultImageName, customImageName, buildSecretString, conflictTest, versionTest, dagTest, platformCoreClient) + err = containerHandler.UpgradeTest(defaultImageTag, deploymentID, defaultImageName, customImageName, buildSecretString, versionTest, dagTest, platformCoreClient) if err != nil { return err } diff --git a/cmd/airflow_test.go b/cmd/airflow_test.go index 898df5a92..0fde216d2 100644 --- a/cmd/airflow_test.go +++ b/cmd/airflow_test.go @@ -657,7 +657,7 @@ func (s *AirflowSuite) TestAirflowUpgradeTest() { mockContainerHandler := new(mocks.ContainerHandler) containerHandlerInit = func(airflowHome, envFile, dockerfile, imageName string) (airflow.ContainerHandler, error) { - mockContainerHandler.On("UpgradeTest", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, false, false, false, nil).Return(nil).Once() + mockContainerHandler.On("UpgradeTest", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, false, false, nil).Return(nil).Once() return mockContainerHandler, nil } @@ -671,7 +671,7 @@ func (s *AirflowSuite) TestAirflowUpgradeTest() { mockContainerHandler := new(mocks.ContainerHandler) containerHandlerInit = func(airflowHome, envFile, dockerfile, imageName string) (airflow.ContainerHandler, error) { - mockContainerHandler.On("UpgradeTest", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, false, false, false, nil).Return(errMock).Once() + mockContainerHandler.On("UpgradeTest", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, false, false, nil).Return(errMock).Once() return mockContainerHandler, nil }