How to Run `podman/newman` in `testcontainers`?

Are you struggling to integrate `podman/newman` with `testcontainers`? Do you want to take your automated testing to the next level by leveraging the power of containerization? Look no further! In this comprehensive guide, we’ll walk you through the step-by-step process of running `podman/newman` in `testcontainers`.

Prerequisites

Before we dive in, make sure you have the following tools installed on your system:

• podman (or Docker) for containerization
• newman for running Postman collections
• testcontainers for container-based testing

What is `podman/newman`?

`podman` and `Docker` are two popular containerization platforms that allow you to package, ship, and run applications in containers. `newman` is a command-line collection runner for Postman that allows you to run and test your API collections programmatically.

In the context of `testcontainers`, we’ll use `podman` as a container runtime to spin up `newman` containers and execute our Postman collections.

What is `testcontainers`?

`testcontainers` is a Java testing library that provides a simple way to create and manage containers for testing purposes. It supports various container runtimes, including `Docker` and `podman`, allowing you to write more efficient and reliable tests.

Why Use `testcontainers` with `podman/newman`?

By combining `testcontainers` with `podman/newman`, you can:

• Isolate your tests and prevent interference from other tests or systems
• Ensure consistent and reproducible test results
• Simplify your testing infrastructure and reduce maintenance costs
• Write more efficient and reliable tests with less overhead

Step 1: Create a `testcontainers` Test Class

Create a new Java class that extends `Testcontainers`’ `ContainerizedTest`:
“`java
import org.testcontainers.containers.GenericContainer;
import org.testcontainers.junit.jupiter.ContainerizedTest;
import org.junit.jupiter.api.Test;

public class NewmanTest extends ContainerizedTest {
// …
}
“`

Step 2: Define the `newman` Container

Create a `GenericContainer` instance that runs the `newman` image:
“`java
private static final GenericContainer CONTAINER = new GenericContainer(“postman/newman:latest”)
.withExposedPorts(5555);
“`

Here, we’re using the official `postman/newman` image and exposing port 5555 for communication.

Step 3: Create a `podman` Container Runtime

Create a `PodmanContainerRuntime` instance that will manage our `newman` container:
“`java
private static final PodmanContainerRuntime RUNTIME = new PodmanContainerRuntime();
“`

Make sure you have `podman` installed on your system and configured correctly.

Step 4: Start the Container and Run the Collection

Here, we’re starting the container and running the `newman` command with the specified collection file.

Step 5: Write Tests Using the Container

In this example, we’re sending a GET request to the API using the `newman` container and asserting the response code.

Advanced Configurations and Tips

Environment Variables

Volume Mounts Custom Container Networking Conclusion

Tool	Version
testcontainers	1.16.3
podman	3.4.4
newman	4.6.0

Frequently Asked Question

Get ready to unleash the power of Podman and Newman in Testcontainers with our expert answers to the most pressing questions!

How do I install Podman and Newman in my Testcontainers environment?

To install Podman and Newman, you’ll need to add the necessary dependencies to your Testcontainers Dockerfile. First, add the Podman installation command: `RUN yum install -y podman` (for RHEL-based images) or `RUN apt-get update && apt-get install -y podman` (for Debian-based images). Then, add the Newman installation command: `RUN npm install -g newman`. Don’t forget to expose the Podman port in your Dockerfile: `EXPOSE 8080`.

What’s the best way to configure Podman and Newman to run my Postman collections?

To configure Podman and Newman, create a `newman.json` file with your collection and environment settings. Then, run the following command: `podman run -p 8080:8080 -v ${PWD}:/etc/newman newman run .ollection.json`. This command maps the local directory to the container’s `/etc/newman` directory, allowing Newman to access your collection files. Make sure to replace `` with the actual name of your Postman collection.

How do I integrate Podman and Newman with my existing Testcontainers test suite?

To integrate Podman and Newman with your Testcontainers test suite, create a custom `Testcontainers` module that spins up a Podman container with Newman installed. Use the `newman` command to run your Postman collections and validate the results in your test code. You can use Testcontainers’ `withContainer` method to start the Podman container and execute Newman commands. For example: `newmanContainer = new PodmanContainer(“newman”).withCommand(“run .collection.json”);`.

What are some common troubleshooting tips for running Podman and Newman in Testcontainers?

When troubleshooting, check the Podman container logs for errors using `podman logs -f `. Verify that your Newman configuration file is correct and that the collection files are accessible within the container. Ensure that you’ve exposed the correct port in your Dockerfile and that there are no port conflicts. If you’re using a CI/CD pipeline, check the pipeline logs for errors and adjust the configuration accordingly.

Can I use Podman and Newman with other testing frameworks besides Testcontainers?

Yes, you can use Podman and Newman with other testing frameworks, such as JUnit, TestNG, or Pytest. Simply create a custom test case that spins up a Podman container with Newman installed and runs your Postman collections. You can then use the testing framework’s assertions to validate the results. For example, in JUnit, you can use `assertEquals` to verify the API response codes or payload.

Share this: