public void buildLocalImportAndLocalScanFromStaticImage()

in plugins/docker/component-image/src/integrationTest/java/co/elastic/gradle/dockercomponent/DockerComponentPluginIT.java [51:172]
104 lines of code
3 McCabe index (conditional complexity)

    public void buildLocalImportAndLocalScanFromStaticImage() throws IOException, InterruptedException {
        helper.settings("""
                     rootProject.name = "just-a-test"
                """);
        Files.copy(Objects.requireNonNull(getClass().getResourceAsStream("/test_created_image.sh")), helper.projectDir().resolve("test_created_image.sh"));
        helper.buildScript("""
                import kotlin.random.Random
                                
                plugins {
                       id("co.elastic.docker-component")
                       id("co.elastic.vault")
                }
                vault {
                          address.set("https://vault-ci-prod.elastic.dev")
                          auth {
                            ghTokenFile()
                            ghTokenEnv()
                            tokenEnv()
                            roleAndSecretEnv()
                          }
                }
                cli {
                     val credentials = vault.readAndCacheSecret("secret/ci/elastic-gradle-plugins/artifactory_creds").get()
                     snyk {                         
                           username.set(credentials["username"])
                           password.set(credentials["plaintext"])
                     }
                     manifestTool {                         
                           username.set(credentials["username"])
                           password.set(credentials["plaintext"])
                     }
                }
                tasks.withType<co.elastic.gradle.snyk.SnykCLIExecTask> {
                       environment(
                            "SNYK_TOKEN",
                            vault.readAndCacheSecret("secret/ci/elastic-gradle-plugins/snyk_api_key").get()["apikey"].toString()
                        )
                }
                dockerComponentImage {
                    buildAll {
                        from("ubuntu", "20.04")
                        maintainer("Jon Doe", "jon.doe@email.com")
                        copySpec("1000:1000") {
                            from(fileTree(projectDir)) {
                                include("build.gradle.kts")
                            }
                            into("home")
                        }
                        copySpec {
                           from("build.gradle.kts") {
                              into("home/${architecture.toString().toLowerCase()}")
                           }
                        }
                        copySpec {
                           from("test_created_image.sh")
                        }
                        entryPoint(listOf("/test_created_image.sh"))
                        cmd(listOf("foo", "bar"))
                        env("MY_FOO" to "BAR")
                        workDir("/home")
                        exposeTcp(80)
                        exposeUdp(80)
                        label("foo" to "bar")
                        changingLabel("random" to Random.nextInt(0, 10000).toString())
                    }
                }
                    """);
        Files.setPosixFilePermissions(helper.projectDir().resolve("test_created_image.sh"), PosixFilePermissions.fromString("r-xr-xr-x"));

        Files.copy(Objects.requireNonNull(getClass().getResourceAsStream("/docker-component-image.lock")), helper.projectDir().resolve("docker-component-image.lock"));

        final BuildResult pullResult = runGradleTask("dockerComponentPull");
        assertContains(pullResult.getOutput(), "Pulling base layers for ubuntu:20.04@sha256:a51c8bb81605567ea27d627425adf94a613d675a664bf473d43a55a8a26416b8 into the jib cache");
        assertContains(pullResult.getOutput(), "Pulling base layers for ubuntu:20.04@sha256:31cd7bbfd36421dfd338bceb36d803b3663c1bfa87dfe6af7ba764b5bf34de05 into the jib cache");

        Assert.assertTrue(Files.exists(Paths.get(System.getProperty("user.home")).resolve(".gradle-jib/cache")), "Job cache dir does not exist");

        Files.delete(helper.projectDir().resolve("docker-component-image.lock"));

        runGradleTask("dockerComponentLockFile");
        Assertions.assertTrue(Files.exists(helper.projectDir().resolve("docker-component-image.lock")));

        runGradleTask("dockerComponentImageBuild");
        Assertions.assertTrue(Files.exists(helper.projectDir().resolve("build/dockerComponentImageBuild/image-X86_64.tar.zstd")), "Image archive was not created at \"build/dockerComponentImageBuild/image-X86_64.tar.zstd\"");
        Assertions.assertTrue(Files.exists(helper.projectDir().resolve("build/dockerComponentImageBuild/image-AARCH64.tar.zstd")), "Image archive was not created at \"build/dockerComponentImageBuild/image-AARCH64.tar.zstd\"");


        final BuildResult result = runGradleTask("dockerComponentImageLocalImport");
        assertContains(result.getOutput(), "local/gradle-docker-component/just-a-test:latest");
        Assertions.assertTrue(getImagesInDaemon().contains("local/gradle-docker-component/just-a-test:latest"), "Expected image local/gradle-docker-component/just-a-test:latest to be available in the docker " + "daemon but it was not");

        final BuildResult secondResult = runGradleTask("dockerComponentImageLocalImport");
        Assert.assertEquals(TaskOutcome.UP_TO_DATE, Objects.requireNonNull(secondResult.task(":dockerComponentImageLocalImport")).getOutcome());

        final Process process = new ProcessBuilder().redirectOutput(ProcessBuilder.Redirect.PIPE).redirectError(ProcessBuilder.Redirect.PIPE).directory(helper.projectDir().toFile()).command("docker", "run", "--rm", "-t", "local/gradle-docker-component/just-a-test:latest").start();

        do {
            IOUtils.copy(process.getInputStream(), System.out);
            IOUtils.copy(process.getErrorStream(), System.err);
        } while (process.isAlive());


        final int exitCode = process.waitFor();
        if (exitCode != 0) {
            Assertions.fail("Verification script failed with exit code: " + exitCode);
        }
        System.out.println("Verification script completed successfully...");

        BuildResult scanResult = gradleRunner.withArguments("--warning-mode", "fail", "-s", "dockerComponentImageScanLocal").buildAndFail();

        assertContains(scanResult.getOutput(), "Docker image:");
        assertContains(scanResult.getOutput(), "local/gradle-docker-component/just-a-test:latest");

        runGradleTask("dockerComponentImageClean");

        Set<String> imagesInDaemonAfterClean = getImagesInDaemon();
        Assertions.assertFalse(
                getImagesInDaemon().contains("local/gradle-docker-component/just-a-test:latest"),
                "Expected image local/gradle-docker-component/just-a-test:latest to be cleaned from the docker " +
                        "daemon but it was not"
        );
    }