How to use

forClasspathResource

method

in

org.testcontainers.utility.MountableFile

/**
 * Obtains a {@link MountableFile} corresponding to a resource on the classpath (including resources in JAR files)
 *
 * @param resourceName the classpath path to the resource
 * @return a {@link MountableFile} that may be used to obtain a mountable path
 */
public static MountableFile forClasspathResource(@NotNull final String resourceName) {
  return forClasspathResource(resourceName, null);
}

protected void optionallyMapResourceParameterAsVolume(@NotNull String paramName, @NotNull String pathNameInContainer, @NotNull String defaultResource) {
  String resourceName = parameters.getOrDefault(paramName, defaultResource);
  if (resourceName != null) {
    final MountableFile mountableFile = MountableFile.forClasspathResource(resourceName);
    withCopyFileToContainer(mountableFile, pathNameInContainer);
  }
}

  default SELF withFileFromClasspath(String path, String resourcePath) {
    final MountableFile mountableFile = MountableFile.forClasspathResource(resourcePath);

    return ((SELF) this).withFileFromPath(path, Paths.get(mountableFile.getResolvedPath()));
  }
}

/**
 * {@inheritDoc}
 */
@Override
public SELF withClasspathResourceMapping(final String resourcePath, final String containerPath, final BindMode mode, final SelinuxContext selinuxContext) {
  final MountableFile mountableFile = MountableFile.forClasspathResource(resourcePath);
  this.addFileSystemBind(mountableFile.getResolvedPath(), containerPath, mode, selinuxContext);
  return self();
}

@Test
public void forClasspathResource() throws Exception {
  final MountableFile mountableFile = MountableFile.forClasspathResource("mappable-resource/test-resource.txt");
  performChecks(mountableFile);
}

private boolean checkMountableFile() {
  DockerClient dockerClient = client();
  MountableFile mountableFile = MountableFile.forClasspathResource(ResourceReaper.class.getName().replace(".", "/") + ".class");
  Volume volume = new Volume("/dummy");
  try {
    return runInsideDocker(
      createContainerCmd -> createContainerCmd.withBinds(new Bind(mountableFile.getResolvedPath(), volume, AccessMode.ro)),
      (__, containerId) -> {
        try (InputStream stream = dockerClient.copyArchiveFromContainerCmd(containerId, volume.getPath()).exec()) {
          stream.read();
          return true;
        } catch (Exception e) {
          return false;
        }
      }
    );
  } catch (Exception e) {
    log.debug("Failure while checking for mountable file support", e);
    return false;
  }
}

@Test
public void forClasspathResourceWithAbsolutePath() throws Exception {
  final MountableFile mountableFile = MountableFile.forClasspathResource("/mappable-resource/test-resource.txt");
  performChecks(mountableFile);
}

@Test
public void forClasspathResourceFromJar() throws Exception {
  final MountableFile mountableFile = MountableFile.forClasspathResource("META-INF/dummy_unique_name.txt");
  performChecks(mountableFile);
}

@Test
public void forClasspathResourceFromJarWithAbsolutePath() throws Exception {
  final MountableFile mountableFile = MountableFile.forClasspathResource("/META-INF/dummy_unique_name.txt");
  performChecks(mountableFile);
}

@Test
public void forClasspathResourceWithPermission() throws Exception {
  final MountableFile mountableFile = MountableFile.forClasspathResource("mappable-resource/test-resource.txt",
    TEST_FILE_MODE);
  performChecks(mountableFile);
  assertEquals("Valid file mode.", BASE_FILE_MODE | TEST_FILE_MODE, mountableFile.getFileMode());
}

@Test
public void copyFileToContainerFileTest() throws Exception {
  try (
    GenericContainer alpineCopyToContainer = new GenericContainer("alpine:3.2")
      .withCommand("top")
  ) {
    alpineCopyToContainer.start();
    final MountableFile mountableFile = MountableFile.forClasspathResource("test_copy_to_container.txt");
    alpineCopyToContainer.copyFileToContainer(mountableFile, "/test.txt");
    File actualFile = new File(temporaryFolder.getRoot().getAbsolutePath() + "/test_copy_to_container.txt");
    alpineCopyToContainer.copyFileFromContainer("/test.txt", actualFile.getPath());
    File expectedFile = new File(mountableFile.getResolvedPath());
    assertTrue("Files aren't same ", FileUtils.contentEquals(expectedFile, actualFile));
  }
}

@Test
public void copyFileToContainerFolderTest() throws Exception {
  try (
    GenericContainer alpineCopyToContainer = new GenericContainer("alpine:3.2")
      .withCommand("top")
  ) {
    alpineCopyToContainer.start();
    final MountableFile mountableFile = MountableFile.forClasspathResource("test_copy_to_container.txt");
    alpineCopyToContainer.copyFileToContainer(mountableFile, "/home/");
    File actualFile = new File(temporaryFolder.getRoot().getAbsolutePath() + "/test_copy_to_container.txt");
    alpineCopyToContainer.copyFileFromContainer("/home/test_copy_to_container.txt", actualFile.getPath());
    File expectedFile = new File(mountableFile.getResolvedPath());
    assertTrue("Files aren't same ", FileUtils.contentEquals(expectedFile, actualFile));
  }
}

  @Test
  public void shouldCopyFileFromContainerTest() throws IOException {
    try (
      GenericContainer alpineCopyToContainer = new GenericContainer("alpine:3.2")
        .withCommand("top")
    ) {

      alpineCopyToContainer.start();
      final MountableFile mountableFile = MountableFile.forClasspathResource("test_copy_to_container.txt");
      alpineCopyToContainer.copyFileToContainer(mountableFile, "/home/");

      File actualFile = new File(temporaryFolder.getRoot().getAbsolutePath() + "/test_copy_from_container.txt");
      alpineCopyToContainer.copyFileFromContainer("/home/test_copy_to_container.txt", actualFile.getPath());

      File expectedFile = new File(mountableFile.getResolvedPath());
      assertTrue("Files aren't same ", FileUtils.contentEquals(expectedFile, actualFile));
    }
  }
}

@Test
public void copyFolderToContainerFolderTest() throws Exception {
  try (
    GenericContainer alpineCopyToContainer = new GenericContainer("alpine:3.2")
      .withCommand("top")
  ) {
    alpineCopyToContainer.start();
    final MountableFile mountableFile = MountableFile.forClasspathResource("mappable-resource/");
    alpineCopyToContainer.copyFileToContainer(mountableFile, "/home/test/");
    File actualFile = new File(temporaryFolder.getRoot().getAbsolutePath() + "/test_copy_to_container.txt");
    alpineCopyToContainer.copyFileFromContainer("/home/test/test-resource.txt", actualFile.getPath());
    File expectedFile = new File(mountableFile.getResolvedPath() + "/test-resource.txt");
    assertTrue("Files aren't same ", FileUtils.contentEquals(expectedFile, actualFile));
  }
}

  @Test
  public void checkFileCopied() throws IOException, InterruptedException {
    try(
      GenericContainer container = new GenericContainer("alpine:latest")
        .withCommand("sleep","3000")
        .withCopyFileToContainer(MountableFile.forClasspathResource("/mappable-resource/"), containerPath)
    ) {
      container.start();
      String filesList = container.execInContainer("ls","/tmp/mappable-resource").getStdout();
      Assert.assertTrue(filesList.contains(fileName));
    }
  }
}

@Test
public void noTrailingSlashesInTarEntryNames() throws Exception {
  final MountableFile mountableFile = MountableFile.forClasspathResource("mappable-resource/test-resource.txt");
  @Cleanup final TarArchiveInputStream tais = intoTarArchive((taos) -> {
    mountableFile.transferTo(taos, "/some/path.txt");
    mountableFile.transferTo(taos, "/path.txt");
    mountableFile.transferTo(taos, "path.txt");
  });
  ArchiveEntry entry;
  while ((entry = tais.getNextEntry()) != null) {
    assertFalse("no entries should have a trailing slash", entry.getName().endsWith("/"));
  }
}

protected void optionallyMapResourceParameterAsVolume(@NotNull String paramName, @NotNull String pathNameInContainer, @NotNull String defaultResource) {
  String resourceName = parameters.getOrDefault(paramName, defaultResource);
  if (resourceName != null) {
    final MountableFile mountableFile = MountableFile.forClasspathResource(resourceName);
    withCopyFileToContainer(mountableFile, pathNameInContainer);
  }
}

  default SELF withFileFromClasspath(String path, String resourcePath) {
    final MountableFile mountableFile = MountableFile.forClasspathResource(resourcePath);

    return ((SELF) this).withFileFromPath(path, Paths.get(mountableFile.getResolvedPath()));
  }
}

private boolean checkMountableFile() {
  DockerClient dockerClient = client();
  MountableFile mountableFile = MountableFile.forClasspathResource(ResourceReaper.class.getName().replace(".", "/") + ".class");
  Volume volume = new Volume("/dummy");
  try {
    return runInsideDocker(createContainerCmd -> createContainerCmd.withBinds(new Bind(mountableFile.getResolvedPath(), volume, AccessMode.ro)), (__, containerId) -> {
      try (InputStream stream = dockerClient.copyArchiveFromContainerCmd(containerId, volume.getPath()).exec()) {
        stream.read();
        return true;
      } catch (Exception e) {
        return false;
      }
    });
  } catch (Exception e) {
    log.debug("Failure while checking for mountable file support", e);
    return false;
  }
}

@Bean(name = BEAN_NAME_EMBEDDED_MEMSQL, destroyMethod = "stop")
public GenericContainer memsql(ConfigurableEnvironment environment,
                MemSqlProperties properties,
                MemSqlStatusCheck memSqlStatusCheck) {
  log.info("Starting memsql server. Docker image: {}", properties.dockerImage);
  GenericContainer memsql = new GenericContainer<>(properties.dockerImage)
      .withEnv("IGNORE_MIN_REQUIREMENTS", "1")
      .withLogConsumer(containerLogsConsumer(log))
      .withExposedPorts(properties.port)
      .withCopyFileToContainer(MountableFile.forClasspathResource("mem.sql"), "/schema.sql")
      .waitingFor(memSqlStatusCheck)
      .withStartupTimeout(properties.getTimeoutDuration());
  memsql.start();
  registerMemSqlEnvironment(memsql, environment, properties);
  return memsql;
}