Release 1.1.0

Add release notes for v1.1.0

.codespellrc

@@ -0,0 +1,4 @@
+[codespell]
+skip = .git,*.pdf,*.svg,requirements.txt,test-requirements.txt
+# poped - loved variable name
+ignore-words-list = poped

.editorconfig

@@ -0,0 +1,19 @@
+root = true
+
+[*]
+indent_style = space
+indent_size = tab
+tab_width = 4
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+max_line_length = 100
+
+[*.{yml,yaml}]
+indent_style = space
+indent_size = 2
+
+[*.py]
+indent_style = space
+

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,7 @@
+
+## Contributor Checklist:
+
+If this PR adds a new feature that improves compatibility with docker-compose, please add a link
+to the exact part of compose spec that the PR touches.
+
+All changes require additional unit tests.

.github/workflows/codespell.yml

@@ -0,0 +1,20 @@
+---
+name: Codespell
+
+on:
+  push:
+  pull_request:
+
+permissions:
+  contents: read
+
+jobs:
+  codespell:
+    name: Check for spelling errors
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Codespell
+        uses: codespell-project/actions-codespell@v2

.github/workflows/pylint.yml

@@ -1,41 +0,0 @@
-name: Pylint
-
-on:
-- push
-- pull_request
-
-jobs:
-  lint-black:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v3
-    - name: Install psf/black requirements
-      run: |
-        sudo apt-get update
-        sudo apt-get install -y python3 python3-venv
-    - uses: psf/black@stable
-      with:
-        options: "--check --verbose"
-        version: "~= 23.3"
-
-  lint-pylint:
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        python-version: ["3.7", "3.8", "3.9", "3.10", "3.11"]
-    steps:
-    - uses: actions/checkout@v3
-    - name: Set up Python ${{ matrix.python-version }}
-      uses: actions/setup-python@v4
-      with:
-        python-version: ${{ matrix.python-version }}
-    - name: Install dependencies
-      run: |
-        python -m pip install --upgrade pip
-        if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
-        pip install pylint
-    - name: Analysing the code with pylint
-      run: |
-        python -m compileall podman_compose.py
-        pylint podman_compose.py
-        # pylint $(git ls-files '*.py')

.github/workflows/pytest.yml

@@ -1,39 +0,0 @@
-# This workflow will install Python dependencies, run tests and lint with a single version of Python
-# For more information see: https://help.github.com/actions/language-and-framework-guides/using-python-with-github-actions
-
-name: PyTest
-
-on:
-  push:
-    branches: [ devel ]
-  pull_request:
-    branches: [ devel ]
-
-jobs:
-  test:
-    runs-on: ubuntu-latest
-
-    steps:
-    - uses: actions/checkout@v3
-    - name: Set up Python 3.10
-      uses: actions/setup-python@v4
-      with:
-        python-version: "3.10"
-    - name: Install dependencies
-      run: |
-        sudo apt update && apt install podman
-        python -m pip install --upgrade pip
-        if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
-        if [ -f test-requirements.txt ]; then pip install -r test-requirements.txt; fi
-    - name: Lint with flake8
-      run: |
-        # stop the build if there are Python syntax errors or undefined names
-        flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics
-        # exit-zero treats all errors as warnings. The GitHub editor is 127 chars wide
-        flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics
-    - name: Test with pytest
-      run: |
-        coverage run --source podman_compose -m pytest ./pytests
-        python -m pytest ./tests
-        coverage combine
-        coverage report

.github/workflows/static-checks.yml

@@ -0,0 +1,25 @@
+name: Static checks
+
+on:
+- push
+- pull_request
+
+jobs:
+  static-checks:
+    runs-on: ubuntu-latest
+    container:
+      image: docker.io/library/python:3.11-bookworm
+      # cgroupns needed to address the following error:
+      # write /sys/fs/cgroup/cgroup.subtree_control: operation not supported
+      options: --privileged --cgroupns=host
+    steps:
+    - uses: actions/checkout@v4
+    - name: Analysing the code with ruff
+      run: |
+        set -e
+        pip install -r test-requirements.txt
+        ruff format --check
+        ruff check
+    - name: Analysing the code with pylint
+      run: |
+        pylint podman_compose.py

.github/workflows/test.yml

@@ -0,0 +1,40 @@
+name: Tests
+
+on:
+  push:
+  pull_request:
+
+jobs:
+  test:
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: [ '3.8', '3.9', '3.10', '3.11', '3.12' ]
+
+    runs-on: ubuntu-latest
+    container:
+      image: "docker.io/library/python:${{ matrix.python-version }}-bookworm"
+      # cgroupns needed to address the following error:
+      # write /sys/fs/cgroup/cgroup.subtree_control: operation not supported
+      options: --privileged --cgroupns=host
+    steps:
+    - uses: actions/checkout@v4
+    - name: Install dependencies
+      run: |
+        set -e
+        apt update && apt install -y podman
+        python -m pip install --upgrade pip
+        if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
+        if [ -f test-requirements.txt ]; then pip install -r test-requirements.txt; fi
+    - name: Run tests in tests/
+      run: |
+        python -m unittest tests/*.py
+      env:
+        TESTS_DEBUG: 1
+    - name: Run tests in pytests/
+      run: |
+        coverage run --source podman_compose -m unittest pytests/*.py
+    - name: Report coverage
+      run: |
+        coverage combine
+        coverage report --format=markdown | tee -a $GITHUB_STEP_SUMMARY

.gitignore

@@ -47,6 +47,8 @@ coverage.xml
 *.cover
 .hypothesis/
 .pytest_cache/
+test-compose.yaml
+test-compose-?.yaml
 
 # Translations
 *.mo

.pre-commit-config.yaml

@@ -30,3 +30,7 @@ repos:
             "-sn", # Don't display the score
             "--rcfile=.pylintrc", # Link to your config file
           ]
+  - repo: https://github.com/codespell-project/codespell
+    rev: v2.2.5
+    hooks:
+    - id: codespell

CONTRIBUTING.md

@@ -2,69 +2,88 @@
 
 ## Who can contribute?
 
-- Users that found a bug
-- Users that wants to propose new functionalities or enhancements
-- Users that want to help other users to troubleshoot their environments
-- Developers that want to fix bugs
-- Developers that want to implement new functionalities or enhancements
+- Users that found a bug,
+- Users that want to propose new functionalities or enhancements,
+- Users that want to help other users to troubleshoot their environments,
+- Developers that want to fix bugs,
+- Developers that want to implement new functionalities or enhancements.
 
 ## Branches
 
-Please request your PR to be merged into the `devel` branch. 
+Please request your pull request to be merged into the `devel` branch.
 Changes to the `stable` branch are managed by the repository maintainers.
 
 ## Development environment setup
 
 Note: Some steps are OPTIONAL but all are RECOMMENDED.
 
-1. Fork the project repo and clone it
+1. Fork the project repository and clone it:
+
    ```shell
    $ git clone https://github.com/USERNAME/podman-compose.git
    $ cd podman-compose
    ```
-1. (OPTIONAL) Create a python virtual environment. Example using [virtualenv wrapper](https://virtualenvwrapper.readthedocs.io/en/latest/): 
+
+2. (OPTIONAL) Create a Python virtual environment. Example using
+   [virtualenv wrapper](https://virtualenvwrapper.readthedocs.io/en/latest/):
+
     ```shell
-mkvirtualenv podman-compose
+    $ mkvirtualenv podman-compose
     ```
-2. Install the project runtime and development requirements   
+
+3. Install the project runtime and development requirements:
+
    ```shell
    $ pip install '.[devel]'
    ```
-3. (OPTIONAL) Install `pre-commit` git hook scripts (https://pre-commit.com/#3-install-the-git-hook-scripts)
+
+4. (OPTIONAL) Install `pre-commit` git hook scripts
+   (https://pre-commit.com/#3-install-the-git-hook-scripts):
+
    ```shell
    $ pre-commit install
    ```
-4. Create a new branch, develop and add tests when possible
-5. Run linting & testing before commiting code. Ensure all the hooks are passing.
+
+5. Create a new branch, develop and add tests when possible.
+6. Run linting and testing before committing code. Ensure all the hooks are passing.
+
    ```shell
    $ pre-commit run --all-files
    ```
-6. Run code coverage
+
+7. Run code coverage:
+
     ```shell
-coverage run --source podman_compose -m pytest ./pytests
-python -m pytest ./tests
-coverage combine
-coverage report
-coverage html
+    $ coverage run --source podman_compose -m unittest pytests/*.py
+    $ python -m unittest tests/*.py
+    $ coverage combine
+    $ coverage report
+    $ coverage html
     ```
-7. Commit your code to your fork's branch. 
-   - Make sure you include a `Signed-off-by` message in your commits. Read [this guide](https://docs.github.com/en/authentication/managing-commit-signature-verification/signing-commits) to learn how to sign your commits 
-   - In the commit message reference the Issue ID that your code fixes and a brief description of the changes. Example: `Fixes #516: allow empty network`
-7. Open a PR to `containers/podman-compose:devel` and wait for a maintainer to review your work.
+
+8. Commit your code to your fork's branch.
+   - Make sure you include a `Signed-off-by` message in your commits.
+     Read [this guide](https://github.com/containers/common/blob/main/CONTRIBUTING.md#sign-your-prs)
+     to learn how to sign your commits.
+   - In the commit message, reference the Issue ID that your code fixes and a brief description of
+     the changes.
+     Example: `Fixes #516: Allow empty network`
+9. Open a pull request to `containers/podman-compose:devel` and wait for a maintainer to review your
+   work.
 
 ## Adding new commands
 
-To add a command you need to add a function that is decorated
-with `@cmd_run` passing the compose instance, command name and
-description. This function must be declared `async` the wrapped 
-function should accept two arguments the compose instance and 
-the command-specific arguments (resulted from python's `argparse` 
-package) inside that command you can run PodMan like this 
-`await compose.podman.run(['inspect', 'something'])`and inside 
-that function you can access `compose.pods` and `compose.containers` 
-...etc. Here is an example
+To add a command, you need to add a function that is decorated with `@cmd_run`.
 
-```
+The decorated function must be declared `async` and should accept two arguments: The compose
+instance and the command-specific arguments (resulted from the Python's `argparse` package).
+
+In this function, you can run Podman (e.g. `await compose.podman.run(['inspect', 'something'])`),
+access `compose.pods`, `compose.containers` etc.
+
+Here is an example:
+
+```python
 @cmd_run(podman_compose, 'build', 'build images defined in the stack')
 async def compose_build(compose, args):
     await compose.podman.run(['build', 'something'])
@@ -72,31 +91,36 @@ async def compose_build(compose, args):
 
 ## Command arguments parsing
 
-Add a function that accept `parser` which is an instance from `argparse`.
-In side that function you can call `parser.add_argument()`.
-The function decorated with `@cmd_parse` accepting the compose instance,
-and command names (as a list or as a string).
-You can do this multiple times. 
+To add arguments to be parsed by a command, you need to add a function that is decorated with
+`@cmd_parse` which accepts the compose instance and the command's name (as a string list or as a
+single string).
 
-Here is an example
+The decorated function should accept a single argument: An instance of `argparse`.
 
-```
+In this function, you can call `parser.add_argument()` to add a new argument to the command.
+
+Note you can add such a function multiple times.
+
+Here is an example:
+
+```python
 @cmd_parse(podman_compose, 'build')
 def compose_build_parse(parser):
     parser.add_argument("--pull",
         help="attempt to pull a newer version of the image", action='store_true')
     parser.add_argument("--pull-always",
-        help="attempt to pull a newer version of the image, Raise an error even if the image is present locally.", action='store_true')
+        help="Attempt to pull a newer version of the image, "
+             "raise an error even if the image is present locally.",
+        action='store_true')
 ```
 
-NOTE: `@cmd_parse` should be after `@cmd_run`
+NOTE: `@cmd_parse` should be after `@cmd_run`.
 
-## Calling a command from inside another
+## Calling a command from another one
 
-If you need to call `podman-compose down` from inside `podman-compose up`
-do something like:
+If you need to call `podman-compose down` from `podman-compose up`, do something like:
 
-```
+```python
 @cmd_run(podman_compose, 'up', 'up desc')
 async def compose_up(compose, args):
     await compose.commands['down'](compose, args)
@@ -104,19 +128,14 @@ async def compose_up(compose, args):
     await compose.commands['down'](argparse.Namespace(foo=123))
 ```
 
-
 ## Missing Commands (help needed)
+
 ```
   bundle             Generate a Docker bundle from the Compose file
-  config             Validate and view the Compose file
   create             Create services
   events             Receive real time events from containers
   images             List images
-  logs               View output from containers
-  port               Print the public port for a port binding
-  ps                 List containers
   rm                 Remove stopped containers
-  run                Run a one-off command
   scale              Set number of containers for a service
   top                Display the running processes
 ```

README.md

@@ -1,6 +1,5 @@
 # Podman Compose
-## [![Pylint Test: ](https://github.com/containers/podman-compose/actions/workflows/pylint.yml/badge.svg)](https://github.com/containers/podman-compose/actions/workflows/pylint.yml) [![Unit tests  PyTest](https://github.com/containers/podman-compose/actions/workflows/pytest.yml/badge.svg)](https://github.com/containers/podman-compose/actions/workflows/pytest.yml)
-
+## [![Tests](https://github.com/containers/podman-compose/actions/workflows/test.yml/badge.svg)](https://github.com/containers/podman-compose/actions/workflows/test.yml)
 
 An implementation of [Compose Spec](https://compose-spec.io/) with [Podman](https://podman.io/) backend.
 This project focuses on:
@@ -103,11 +102,11 @@ There is also AWX 17.1.0
 Inside `tests/` directory we have many useless docker-compose stacks
 that are meant to test as many cases as we can to make sure we are compatible
 
-### Unit tests with pytest
-run a pytest with following command
+### Unit tests with unittest
+run a unittest with following command
 
 ```shell
-python -m pytest pytests
+python -m unittest pytests/*.py
 ```
 
 # Contributing guide

docs/Changelog-1.1.0.md

@@ -0,0 +1,33 @@
+Version v1.1.0 (2024-04-17)
+===========================
+
+Bug fixes
+---------
+
+- Fixed support for values with equals sign in `-e` argument of `run` and `exec` commands.
+- Fixed duplicate arguments being emitted in `stop` and `restart` commands.
+- Removed extraneous debug output. `--verbose` flag has been added to preserve verbose output.
+- Links aliases are now added to service aliases.
+- Fixed image build process to use defined environmental variables.
+- Empty list is now allowed to be `COMMAND` and `ENTRYPOINT`.
+- Environment files are now resolved relative to current working directory.
+- Exit code of container build is now preserved as return code of `build` command.
+
+New features
+------------
+
+- Added support for `uidmap`, `gidmap`, `http_proxy` and `runtime` service configuration keys.
+- Added support for `enable_ipv6` network configuration key.
+- Added `--parallel` option to support parallel pulling and building of images.
+- Implemented support for maps in `sysctls` container configuration key.
+- Implemented `stats` command.
+- Added `--no-normalize` flag to `config` command.
+- Added support for `include` global configuration key.
+- Added support for `build` command.
+- Added support to start containers with multiple networks.
+- Added support for `profile` argument.
+- Added support for starting podman in existing network namespace.
+- Added IPAM driver support. 
+- Added support for file secrets being passed to `podman build` via `--secret` argument.
+- Added support for multiple networks with separately specified IP and MAC address.
+- Added support for `service.build.ulimits` when building image.

docs/Extensions.md

@@ -0,0 +1,67 @@
+# Podman specific extensions to the docker-compose format
+
+Podman-compose supports the following extension to the docker-compose format.
+
+## Per-network MAC-addresses
+
+Generic docker-compose files support specification of the MAC address on the container level. If the
+container has multiple network interfaces, the specified MAC address is applied to the first
+specified network.
+
+Podman-compose in addition supports the specification of MAC addresses on a per-network basis. This
+is done by adding a `x-podman.mac_address` key to the network configuration in the container. The
+value of the `x-podman.mac_address` key is the MAC address to be used for the network interface.
+
+Specifying a MAC address for the container and for individual networks at the same time is not
+supported.
+
+Example:
+
+```yaml
+---
+version: "3"
+
+networks:
+  net0:
+    driver: "bridge"
+    ipam:
+      config:
+        - subnet: "192.168.0.0/24"
+  net1:
+    driver: "bridge"
+    ipam:
+      config:
+        - subnet: "192.168.1.0/24"
+
+services:
+  webserver
+    image: "busybox"
+    command: ["/bin/busybox", "httpd", "-f", "-h", "/etc", "-p", "8001"]
+    networks:
+      net0:
+        ipv4_address: "192.168.0.10"
+        x-podman.mac_address: "02:aa:aa:aa:aa:aa"
+      net1:
+        ipv4_address: "192.168.1.10"
+        x-podman.mac_address: "02:bb:bb:bb:bb:bb"
+```
+
+## Podman-specific network modes
+
+Generic docker-compose supports the following values for `network-mode` for a container:
+
+- `bridge`
+- `host`
+- `none`
+- `service`
+- `container`
+
+In addition, podman-compose supports the following podman-specific values for `network-mode`:
+
+- `slirp4netns[:<options>,...]`
+- `ns:<options>`
+- `pasta[:<options>,...]`
+- `private`
+
+The options to the network modes are passed to the `--network` option of the `podman create` command
+as-is.

examples/hello-python/app/web.py

@@ -1,7 +1,7 @@
 # pylint: disable=import-error
 # pylint: disable=unused-import
-import os
 import asyncio  # noqa: F401
+import os
 
 import aioredis
 from aiohttp import web

pyproject.toml

@@ -0,0 +1,15 @@
+[tool.ruff]
+line-length = 100
+target-version = "py38"
+
+[tool.ruff.lint]
+select = ["W", "E", "F", "I"]
+ignore = [
+]
+
+[tool.ruff.lint.isort]
+force-single-line = true
+
+[tool.ruff.format]
+preview = true # needed for quote-style
+quote-style = "preserve"

pytests/test_can_merge_build.py

@@ -1,11 +1,19 @@
-import copy
-import os
+# SPDX-License-Identifier: GPL-2.0
+from __future__ import annotations
+
 import argparse
+import os
+import unittest
+
 import yaml
-from podman_compose import normalize_service, PodmanCompose
+from parameterized import parameterized
+
+from podman_compose import PodmanCompose
+from podman_compose import normalize_service
 
 
-test_cases_simple = [
+class TestCanMergeBuild(unittest.TestCase):
+    @parameterized.expand([
         ({"test": "test"}, {"test": "test"}),
         ({"build": "."}, {"build": {"context": "."}}),
         ({"build": "./dir-1"}, {"build": {"context": "./dir-1"}}),
@@ -18,22 +26,11 @@ test_cases_simple = [
             {"build": {"context": "./dir-1", "dockerfile": "dockerfile-1"}},
             {"build": {"context": "./dir-1", "dockerfile": "dockerfile-1"}},
         ),
-]
+    ])
+    def test_simple(self, input, expected):
+        self.assertEqual(normalize_service(input), expected)
 
-
-def test_normalize_service_simple():
-    for test_case, expected in copy.deepcopy(test_cases_simple):
-        test_original = copy.deepcopy(test_case)
-        test_case = normalize_service(test_case)
-        test_result = expected == test_case
-        if not test_result:
-            print("test:     ", test_original)
-            print("expected: ", expected)
-            print("actual:   ", test_case)
-        assert test_result
-
-
-test_cases_sub_dir = [
+    @parameterized.expand([
         ({"test": "test"}, {"test": "test"}),
         ({"build": "."}, {"build": {"context": "./sub_dir/."}}),
         ({"build": "./dir-1"}, {"build": {"context": "./sub_dir/dir-1"}}),
@@ -46,22 +43,11 @@ test_cases_sub_dir = [
             {"build": {"context": "./dir-1", "dockerfile": "dockerfile-1"}},
             {"build": {"context": "./sub_dir/dir-1", "dockerfile": "dockerfile-1"}},
         ),
-]
+    ])
+    def test_normalize_service_with_sub_dir(self, input, expected):
+        self.assertEqual(normalize_service(input, sub_dir="./sub_dir"), expected)
 
-
-def test_normalize_service_with_sub_dir():
-    for test_case, expected in copy.deepcopy(test_cases_sub_dir):
-        test_original = copy.deepcopy(test_case)
-        test_case = normalize_service(test_case, sub_dir="./sub_dir")
-        test_result = expected == test_case
-        if not test_result:
-            print("test:     ", test_original)
-            print("expected: ", expected)
-            print("actual:   ", test_case)
-        assert test_result
-
-
-test_cases_merges = [
+    @parameterized.expand([
         ({}, {}, {}),
         ({}, {"test": "test"}, {"test": "test"}),
         ({"test": "test"}, {}, {"test": "test"}),
@@ -116,13 +102,10 @@ test_cases_merges = [
             {"build": {"dockerfile": "./dockerfile-1", "args": ["ENV2=2"]}},
             {"build": {"dockerfile": "./dockerfile-1", "args": ["ENV1=1", "ENV2=2"]}},
         ),
-]
-
-
-def test__parse_compose_file_when_multiple_composes() -> None:
-    for test_input, test_override, expected_result in copy.deepcopy(test_cases_merges):
-        compose_test_1 = {"services": {"test-service": test_input}}
-        compose_test_2 = {"services": {"test-service": test_override}}
+    ])
+    def test_parse_compose_file_when_multiple_composes(self, input, override, expected):
+        compose_test_1 = {"services": {"test-service": input}}
+        compose_test_2 = {"services": {"test-service": override}}
         dump_yaml(compose_test_1, "test-compose-1.yaml")
         dump_yaml(compose_test_2, "test-compose-2.yaml")
 
@@ -135,15 +118,7 @@ def test__parse_compose_file_when_multiple_composes() -> None:
         if podman_compose.services:
             podman_compose.services["test-service"].pop("_deps")
             actual_compose = podman_compose.services["test-service"]
-        if actual_compose != expected_result:
-            print("compose:   ", test_input)
-            print("override:  ", test_override)
-            print("expected:  ", expected_result)
-            print("actual:    ", actual_compose)
-
-        compose_expected = expected_result
-
-        assert compose_expected == actual_compose
+        self.assertEqual(actual_compose, expected)
 
 
 def set_args(podman_compose: PodmanCompose, file_names: list[str]) -> None:

pytests/test_can_merge_cmd_ent.py

@@ -1,12 +1,22 @@
+# SPDX-License-Identifier: GPL-2.0
+from __future__ import annotations
+
+import argparse
 import copy
 import os
-import argparse
+import unittest
+
 import yaml
-from podman_compose import normalize_service, PodmanCompose
+from parameterized import parameterized
+
+from podman_compose import PodmanCompose
+from podman_compose import normalize_service
 
 test_keys = ["command", "entrypoint"]
 
-test_cases_normalise_pre_merge = [
+
+class TestCanMergeCmdEnt(unittest.TestCase):
+    @parameterized.expand([
         ({"$$$": []}, {"$$$": []}),
         ({"$$$": ["sh"]}, {"$$$": ["sh"]}),
         ({"$$$": ["sh", "-c", "date"]}, {"$$$": ["sh", "-c", "date"]}),
@@ -16,9 +26,15 @@ test_cases_normalise_pre_merge = [
             {"$$$": "bash -c 'sleep infinity'"},
             {"$$$": ["bash", "-c", "sleep infinity"]},
         ),
-]
+    ])
+    def test_normalize_service(self, input_template, expected_template):
+        for key in test_keys:
+            test_input, _, expected = template_to_expression(
+                input_template, {}, expected_template, key
+            )
+            self.assertEqual(normalize_service(test_input), expected)
 
-test_cases_merges = [
+    @parameterized.expand([
         ({}, {"$$$": []}, {"$$$": []}),
         ({"$$$": []}, {}, {"$$$": []}),
         ({"$$$": []}, {"$$$": "sh-2"}, {"$$$": ["sh-2"]}),
@@ -39,40 +55,9 @@ test_cases_merges = [
             {"$$$": "bash -c 'sleep infinity'"},
             {"$$$": ["bash", "-c", "sleep infinity"]},
         ),
-]
-
-
-def template_to_expression(base, override, expected, key):
-    base_copy = copy.deepcopy(base)
-    override_copy = copy.deepcopy(override)
-    expected_copy = copy.deepcopy(expected)
-
-    expected_copy[key] = expected_copy.pop("$$$")
-    if "$$$" in base:
-        base_copy[key] = base_copy.pop("$$$")
-    if "$$$" in override:
-        override_copy[key] = override_copy.pop("$$$")
-    return base_copy, override_copy, expected_copy
-
-
-def test_normalize_service():
-    for test_input_template, expected_template in test_cases_normalise_pre_merge:
-        for key in test_keys:
-            test_input, _, expected = template_to_expression(
-                test_input_template, {}, expected_template, key
-            )
-            test_input = normalize_service(test_input)
-            test_result = expected == test_input
-            if not test_result:
-                print("base_template:     ", test_input_template)
-                print("expected:          ", expected)
-                print("actual:            ", test_input)
-            assert test_result
-
-
-def test__parse_compose_file_when_multiple_composes() -> None:
-    for base_template, override_template, expected_template in copy.deepcopy(
-        test_cases_merges
+    ])
+    def test_parse_compose_file_when_multiple_composes(
+        self, base_template, override_template, expected_template
     ):
         for key in test_keys:
             base, override, expected = template_to_expression(
@@ -92,12 +77,20 @@ def test__parse_compose_file_when_multiple_composes() -> None:
             if podman_compose.services:
                 podman_compose.services["test-service"].pop("_deps")
                 actual = podman_compose.services["test-service"]
-            if actual != expected:
-                print("compose:   ", base)
-                print("override:  ", override)
-                print("result:    ", expected)
+            self.assertEqual(actual, expected)
 
-            assert expected == actual
+
+def template_to_expression(base, override, expected, key):
+    base_copy = copy.deepcopy(base)
+    override_copy = copy.deepcopy(override)
+    expected_copy = copy.deepcopy(expected)
+
+    expected_copy[key] = expected_copy.pop("$$$")
+    if "$$$" in base:
+        base_copy[key] = base_copy.pop("$$$")
+    if "$$$" in override:
+        override_copy[key] = override_copy.pop("$$$")
+    return base_copy, override_copy, expected_copy
 
 
 def set_args(podman_compose: PodmanCompose, file_names: list[str]) -> None:

pytests/test_compose_exec_args.py

@@ -0,0 +1,46 @@
+# SPDX-License-Identifier: GPL-2.0
+
+import argparse
+import unittest
+
+from podman_compose import compose_exec_args
+
+
+class TestComposeExecArgs(unittest.TestCase):
+    def test_minimal(self):
+        cnt = get_minimal_container()
+        args = get_minimal_args()
+
+        result = compose_exec_args(cnt, "container_name", args)
+        expected = ["--interactive", "--tty", "container_name"]
+        self.assertEqual(result, expected)
+
+    def test_additional_env_value_equals(self):
+        cnt = get_minimal_container()
+        args = get_minimal_args()
+        args.env = ["key=valuepart1=valuepart2"]
+
+        result = compose_exec_args(cnt, "container_name", args)
+        expected = [
+            "--interactive",
+            "--tty",
+            "--env",
+            "key=valuepart1=valuepart2",
+            "container_name",
+        ]
+        self.assertEqual(result, expected)
+
+
+def get_minimal_container():
+    return {}
+
+
+def get_minimal_args():
+    return argparse.Namespace(
+        T=None,
+        cnt_command=None,
+        env=None,
+        privileged=None,
+        user=None,
+        workdir=None,
+    )

pytests/test_compose_run_update_container_from_args.py

@@ -0,0 +1,60 @@
+# SPDX-License-Identifier: GPL-2.0
+
+import argparse
+import unittest
+
+from podman_compose import PodmanCompose
+from podman_compose import compose_run_update_container_from_args
+
+
+class TestComposeRunUpdateContainerFromArgs(unittest.TestCase):
+    def test_minimal(self):
+        cnt = get_minimal_container()
+        compose = get_minimal_compose()
+        args = get_minimal_args()
+
+        compose_run_update_container_from_args(compose, cnt, args)
+
+        expected_cnt = {"name": "default_name", "tty": True}
+        self.assertEqual(cnt, expected_cnt)
+
+    def test_additional_env_value_equals(self):
+        cnt = get_minimal_container()
+        compose = get_minimal_compose()
+        args = get_minimal_args()
+        args.env = ["key=valuepart1=valuepart2"]
+
+        compose_run_update_container_from_args(compose, cnt, args)
+
+        expected_cnt = {
+            "environment": {
+                "key": "valuepart1=valuepart2",
+            },
+            "name": "default_name",
+            "tty": True,
+        }
+        self.assertEqual(cnt, expected_cnt)
+
+
+def get_minimal_container():
+    return {}
+
+
+def get_minimal_compose():
+    return PodmanCompose()
+
+
+def get_minimal_args():
+    return argparse.Namespace(
+        T=None,
+        cnt_command=None,
+        entrypoint=None,
+        env=None,
+        name="default_name",
+        rm=None,
+        service=None,
+        service_ports=None,
+        user=None,
+        volume=None,
+        workdir=None,
+    )

pytests/test_container_to_args.py

@@ -0,0 +1,163 @@
+# SPDX-License-Identifier: GPL-2.0
+
+import unittest
+from unittest import mock
+
+from podman_compose import container_to_args
+
+
+def create_compose_mock(project_name="test_project_name"):
+    compose = mock.Mock()
+    compose.project_name = project_name
+    compose.dirname = "test_dirname"
+    compose.container_names_by_service.get = mock.Mock(return_value=None)
+    compose.prefer_volume_over_mount = False
+    compose.default_net = None
+    compose.networks = {}
+    return compose
+
+
+def get_minimal_container():
+    return {
+        "name": "project_name_service_name1",
+        "service_name": "service_name",
+        "image": "busybox",
+    }
+
+
+class TestContainerToArgs(unittest.IsolatedAsyncioTestCase):
+    async def test_minimal(self):
+        c = create_compose_mock()
+
+        cnt = get_minimal_container()
+
+        args = await container_to_args(c, cnt)
+        self.assertEqual(
+            args,
+            [
+                "--name=project_name_service_name1",
+                "-d",
+                "--network=bridge",
+                "--network-alias=service_name",
+                "busybox",
+            ],
+        )
+
+    async def test_runtime(self):
+        c = create_compose_mock()
+
+        cnt = get_minimal_container()
+        cnt["runtime"] = "runsc"
+
+        args = await container_to_args(c, cnt)
+        self.assertEqual(
+            args,
+            [
+                "--name=project_name_service_name1",
+                "-d",
+                "--network=bridge",
+                "--network-alias=service_name",
+                "--runtime",
+                "runsc",
+                "busybox",
+            ],
+        )
+
+    async def test_sysctl_list(self):
+        c = create_compose_mock()
+
+        cnt = get_minimal_container()
+        cnt["sysctls"] = [
+            "net.core.somaxconn=1024",
+            "net.ipv4.tcp_syncookies=0",
+        ]
+
+        args = await container_to_args(c, cnt)
+        self.assertEqual(
+            args,
+            [
+                "--name=project_name_service_name1",
+                "-d",
+                "--network=bridge",
+                "--network-alias=service_name",
+                "--sysctl",
+                "net.core.somaxconn=1024",
+                "--sysctl",
+                "net.ipv4.tcp_syncookies=0",
+                "busybox",
+            ],
+        )
+
+    async def test_sysctl_map(self):
+        c = create_compose_mock()
+
+        cnt = get_minimal_container()
+        cnt["sysctls"] = {
+            "net.core.somaxconn": 1024,
+            "net.ipv4.tcp_syncookies": 0,
+        }
+
+        args = await container_to_args(c, cnt)
+        self.assertEqual(
+            args,
+            [
+                "--name=project_name_service_name1",
+                "-d",
+                "--network=bridge",
+                "--network-alias=service_name",
+                "--sysctl",
+                "net.core.somaxconn=1024",
+                "--sysctl",
+                "net.ipv4.tcp_syncookies=0",
+                "busybox",
+            ],
+        )
+
+    async def test_sysctl_wrong_type(self):
+        c = create_compose_mock()
+        cnt = get_minimal_container()
+
+        # check whether wrong types are correctly rejected
+        for wrong_type in [True, 0, 0.0, "wrong", ()]:
+            with self.assertRaises(TypeError):
+                cnt["sysctls"] = wrong_type
+                await container_to_args(c, cnt)
+
+    async def test_pid(self):
+        c = create_compose_mock()
+        cnt = get_minimal_container()
+
+        cnt["pid"] = "host"
+
+        args = await container_to_args(c, cnt)
+        self.assertEqual(
+            args,
+            [
+                "--name=project_name_service_name1",
+                "-d",
+                "--network=bridge",
+                "--network-alias=service_name",
+                "--pid",
+                "host",
+                "busybox",
+            ],
+        )
+
+    async def test_http_proxy(self):
+        c = create_compose_mock()
+
+        cnt = get_minimal_container()
+        cnt["http_proxy"] = False
+
+        args = await container_to_args(c, cnt)
+        self.assertEqual(
+            args,
+            [
+                "--name=project_name_service_name1",
+                "-d",
+                "--http-proxy=false",
+                "--network=bridge",
+                "--network-alias=service_name",
+                "busybox",
+            ],
+        )

pytests/test_get_net_args.py

@@ -0,0 +1,298 @@
+import unittest
+
+from parameterized import parameterized
+
+from podman_compose import get_net_args
+
+from .test_container_to_args import create_compose_mock
+
+PROJECT_NAME = "test_project_name"
+SERVICE_NAME = "service_name"
+CONTAINER_NAME = f"{PROJECT_NAME}_{SERVICE_NAME}_1"
+
+
+def get_networked_compose(num_networks=1):
+    compose = create_compose_mock(PROJECT_NAME)
+    for network in range(num_networks):
+        compose.networks[f"net{network}"] = {
+            "driver": "bridge",
+            "ipam": {
+                "config": [
+                    {"subnet": f"192.168.{network}.0/24"},
+                    {"subnet": f"fd00:{network}::/64"},
+                ]
+            },
+            "enable_ipv6": True,
+        }
+
+    return compose
+
+
+def get_minimal_container():
+    return {
+        "name": CONTAINER_NAME,
+        "service_name": SERVICE_NAME,
+        "image": "busybox",
+    }
+
+
+class TestGetNetArgs(unittest.TestCase):
+    def test_minimal(self):
+        compose = get_networked_compose()
+        container = get_minimal_container()
+
+        expected_args = [
+            "--network=bridge",
+            f"--network-alias={SERVICE_NAME}",
+        ]
+        args = get_net_args(compose, container)
+        self.assertListEqual(expected_args, args)
+
+    def test_one_net(self):
+        compose = get_networked_compose()
+        container = get_minimal_container()
+        container["networks"] = {"net0": {}}
+
+        expected_args = [
+            f"--network={PROJECT_NAME}_net0",
+            f"--network-alias={SERVICE_NAME}",
+        ]
+        args = get_net_args(compose, container)
+        self.assertListEqual(expected_args, args)
+
+    def test_alias(self):
+        compose = get_networked_compose()
+        container = get_minimal_container()
+        container["networks"] = {"net0": {}}
+        container["_aliases"] = ["alias1", "alias2"]
+
+        expected_args = [
+            f"--network={PROJECT_NAME}_net0",
+            f"--network-alias={SERVICE_NAME}",
+            "--network-alias=alias1",
+            "--network-alias=alias2",
+        ]
+        args = get_net_args(compose, container)
+        self.assertListEqual(expected_args, args)
+
+    def test_one_ipv4(self):
+        ip = "192.168.0.42"
+        compose = get_networked_compose()
+        container = get_minimal_container()
+        container["networks"] = {"net0": {"ipv4_address": ip}}
+
+        expected_args = [
+            f"--network={PROJECT_NAME}_net0",
+            f"--ip={ip}",
+            f"--network-alias={SERVICE_NAME}",
+        ]
+        args = get_net_args(compose, container)
+        self.assertEqual(expected_args, args)
+
+    def test_one_ipv6(self):
+        ipv6_address = "fd00:0::42"
+        compose = get_networked_compose()
+        container = get_minimal_container()
+        container["networks"] = {"net0": {"ipv6_address": ipv6_address}}
+
+        expected_args = [
+            f"--network={PROJECT_NAME}_net0",
+            f"--ip6={ipv6_address}",
+            f"--network-alias={SERVICE_NAME}",
+        ]
+        args = get_net_args(compose, container)
+        self.assertListEqual(expected_args, args)
+
+    def test_one_mac(self):
+        mac = "00:11:22:33:44:55"
+        compose = get_networked_compose()
+        container = get_minimal_container()
+        container["networks"] = {"net0": {}}
+        container["mac_address"] = mac
+
+        expected_args = [
+            f"--network={PROJECT_NAME}_net0",
+            f"--mac-address={mac}",
+            f"--network-alias={SERVICE_NAME}",
+        ]
+        args = get_net_args(compose, container)
+        self.assertListEqual(expected_args, args)
+
+    def test_one_mac_two_nets(self):
+        mac = "00:11:22:33:44:55"
+        compose = get_networked_compose(num_networks=6)
+        container = get_minimal_container()
+        container["networks"] = {"net0": {}, "net1": {}}
+        container["mac_address"] = mac
+
+        expected_args = [
+            f"--network={PROJECT_NAME}_net0:mac={mac}",
+            f"--network={PROJECT_NAME}_net1",
+            f"--network-alias={SERVICE_NAME}",
+        ]
+        args = get_net_args(compose, container)
+        self.assertListEqual(expected_args, args)
+
+    def test_two_nets_as_dict(self):
+        compose = get_networked_compose(num_networks=2)
+        container = get_minimal_container()
+        container["networks"] = {"net0": {}, "net1": {}}
+
+        expected_args = [
+            f"--network={PROJECT_NAME}_net0",
+            f"--network={PROJECT_NAME}_net1",
+            f"--network-alias={SERVICE_NAME}",
+        ]
+        args = get_net_args(compose, container)
+        self.assertListEqual(expected_args, args)
+
+    def test_two_nets_as_list(self):
+        compose = get_networked_compose(num_networks=2)
+        container = get_minimal_container()
+        container["networks"] = ["net0", "net1"]
+
+        expected_args = [
+            f"--network={PROJECT_NAME}_net0",
+            f"--network={PROJECT_NAME}_net1",
+            f"--network-alias={SERVICE_NAME}",
+        ]
+        args = get_net_args(compose, container)
+        self.assertListEqual(expected_args, args)
+
+    def test_two_ipv4(self):
+        ip0 = "192.168.0.42"
+        ip1 = "192.168.1.42"
+        compose = get_networked_compose(num_networks=2)
+        container = get_minimal_container()
+        container["networks"] = {"net0": {"ipv4_address": ip0}, "net1": {"ipv4_address": ip1}}
+
+        expected_args = [
+            f"--network={PROJECT_NAME}_net0:ip={ip0}",
+            f"--network={PROJECT_NAME}_net1:ip={ip1}",
+            f"--network-alias={SERVICE_NAME}",
+        ]
+        args = get_net_args(compose, container)
+        self.assertListEqual(expected_args, args)
+
+    def test_two_ipv6(self):
+        ip0 = "fd00:0::42"
+        ip1 = "fd00:1::42"
+        compose = get_networked_compose(num_networks=2)
+        container = get_minimal_container()
+        container["networks"] = {"net0": {"ipv6_address": ip0}, "net1": {"ipv6_address": ip1}}
+
+        expected_args = [
+            f"--network={PROJECT_NAME}_net0:ip={ip0}",
+            f"--network={PROJECT_NAME}_net1:ip={ip1}",
+            f"--network-alias={SERVICE_NAME}",
+        ]
+        args = get_net_args(compose, container)
+        self.assertListEqual(expected_args, args)
+
+    # custom extension; not supported by docker-compose
+    def test_two_mac(self):
+        mac0 = "00:00:00:00:00:01"
+        mac1 = "00:00:00:00:00:02"
+        compose = get_networked_compose(num_networks=2)
+        container = get_minimal_container()
+        container["networks"] = {
+            "net0": {"x-podman.mac_address": mac0},
+            "net1": {"x-podman.mac_address": mac1},
+        }
+
+        expected_args = [
+            f"--network={PROJECT_NAME}_net0:mac={mac0}",
+            f"--network={PROJECT_NAME}_net1:mac={mac1}",
+            f"--network-alias={SERVICE_NAME}",
+        ]
+        args = get_net_args(compose, container)
+        self.assertListEqual(expected_args, args)
+
+    def test_mixed_mac(self):
+        ip4_0 = "192.168.0.42"
+        ip4_1 = "192.168.1.42"
+        ip4_2 = "192.168.2.42"
+        mac_0 = "00:00:00:00:00:01"
+        mac_1 = "00:00:00:00:00:02"
+
+        compose = get_networked_compose(num_networks=3)
+        container = get_minimal_container()
+        container["networks"] = {
+            "net0": {"ipv4_address": ip4_0},
+            "net1": {"ipv4_address": ip4_1, "x-podman.mac_address": mac_0},
+            "net2": {"ipv4_address": ip4_2},
+        }
+        container["mac_address"] = mac_1
+
+        expected_exception = (
+            r"specifying mac_address on both container and network level " r"is not supported"
+        )
+        self.assertRaisesRegex(RuntimeError, expected_exception, get_net_args, compose, container)
+
+    def test_mixed_config(self):
+        ip4_0 = "192.168.0.42"
+        ip4_1 = "192.168.1.42"
+        ip6_0 = "fd00:0::42"
+        ip6_2 = "fd00:2::42"
+        mac = "00:11:22:33:44:55"
+        compose = get_networked_compose(num_networks=4)
+        container = get_minimal_container()
+        container["networks"] = {
+            "net0": {"ipv4_address": ip4_0, "ipv6_address": ip6_0},
+            "net1": {"ipv4_address": ip4_1},
+            "net2": {"ipv6_address": ip6_2},
+            "net3": {},
+        }
+        container["mac_address"] = mac
+
+        expected_args = [
+            f"--network={PROJECT_NAME}_net0:ip={ip4_0},ip={ip6_0},mac={mac}",
+            f"--network={PROJECT_NAME}_net1:ip={ip4_1}",
+            f"--network={PROJECT_NAME}_net2:ip={ip6_2}",
+            f"--network={PROJECT_NAME}_net3",
+            f"--network-alias={SERVICE_NAME}",
+        ]
+        args = get_net_args(compose, container)
+        self.assertListEqual(expected_args, args)
+
+    @parameterized.expand([
+        ("bridge", ["--network=bridge", f"--network-alias={SERVICE_NAME}"]),
+        ("host", ["--network=host"]),
+        ("none", []),
+        ("slirp4netns", ["--network=slirp4netns"]),
+        ("slirp4netns:cidr=10.42.0.0/24", ["--network=slirp4netns:cidr=10.42.0.0/24"]),
+        ("private", ["--network=private"]),
+        ("pasta", ["--network=pasta"]),
+        ("pasta:--ipv4-only,-a,10.0.2.0", ["--network=pasta:--ipv4-only,-a,10.0.2.0"]),
+        ("ns:my_namespace", ["--network=ns:my_namespace"]),
+        ("container:my_container", ["--network=container:my_container"]),
+    ])
+    def test_network_modes(self, network_mode, expected_args):
+        compose = get_networked_compose()
+        container = get_minimal_container()
+        container["network_mode"] = network_mode
+
+        args = get_net_args(compose, container)
+        self.assertListEqual(expected_args, args)
+
+    def test_network_mode_invalid(self):
+        compose = get_networked_compose()
+        container = get_minimal_container()
+        container["network_mode"] = "invalid_mode"
+
+        with self.assertRaises(SystemExit):
+            get_net_args(compose, container)
+
+    def test_network__mode_service(self):
+        compose = get_networked_compose()
+        compose.container_names_by_service = {
+            "service_1": ["container_1"],
+            "service_2": ["container_2"],
+        }
+
+        container = get_minimal_container()
+        container["network_mode"] = "service:service_2"
+
+        expected_args = ["--network=container:container_2"]
+        args = get_net_args(compose, container)
+        self.assertListEqual(expected_args, args)

pytests/test_get_network_create_args.py

@@ -0,0 +1,167 @@
+import unittest
+
+from podman_compose import get_network_create_args
+
+
+class TestGetNetworkCreateArgs(unittest.TestCase):
+    def test_minimal(self):
+        net_desc = {
+            "labels": [],
+            "internal": False,
+            "driver": None,
+            "driver_opts": {},
+            "ipam": {"config": []},
+            "enable_ipv6": False,
+        }
+        proj_name = "test_project"
+        net_name = "test_network"
+        expected_args = [
+            "create",
+            "--label",
+            f"io.podman.compose.project={proj_name}",
+            "--label",
+            f"com.docker.compose.project={proj_name}",
+            net_name,
+        ]
+        args = get_network_create_args(net_desc, proj_name, net_name)
+        self.assertEqual(args, expected_args)
+
+    def test_ipv6(self):
+        net_desc = {
+            "labels": [],
+            "internal": False,
+            "driver": None,
+            "driver_opts": {},
+            "ipam": {"config": []},
+            "enable_ipv6": True,
+        }
+        proj_name = "test_project"
+        net_name = "test_network"
+        expected_args = [
+            "create",
+            "--label",
+            f"io.podman.compose.project={proj_name}",
+            "--label",
+            f"com.docker.compose.project={proj_name}",
+            "--ipv6",
+            net_name,
+        ]
+        args = get_network_create_args(net_desc, proj_name, net_name)
+        self.assertEqual(args, expected_args)
+
+    def test_bridge(self):
+        net_desc = {
+            "labels": [],
+            "internal": False,
+            "driver": "bridge",
+            "driver_opts": {"opt1": "value1", "opt2": "value2"},
+            "ipam": {"config": []},
+            "enable_ipv6": False,
+        }
+        proj_name = "test_project"
+        net_name = "test_network"
+        expected_args = [
+            "create",
+            "--label",
+            f"io.podman.compose.project={proj_name}",
+            "--label",
+            f"com.docker.compose.project={proj_name}",
+            "--driver",
+            "bridge",
+            "--opt",
+            "opt1=value1",
+            "--opt",
+            "opt2=value2",
+            net_name,
+        ]
+        args = get_network_create_args(net_desc, proj_name, net_name)
+        self.assertEqual(args, expected_args)
+
+    def test_ipam_driver(self):
+        net_desc = {
+            "labels": [],
+            "internal": False,
+            "driver": None,
+            "driver_opts": {},
+            "ipam": {
+                "driver": "default",
+                "config": [
+                    {
+                        "subnet": "192.168.0.0/24",
+                        "ip_range": "192.168.0.2/24",
+                        "gateway": "192.168.0.1",
+                    }
+                ],
+            },
+        }
+        proj_name = "test_project"
+        net_name = "test_network"
+        expected_args = [
+            "create",
+            "--label",
+            f"io.podman.compose.project={proj_name}",
+            "--label",
+            f"com.docker.compose.project={proj_name}",
+            "--ipam-driver",
+            "default",
+            "--subnet",
+            "192.168.0.0/24",
+            "--ip-range",
+            "192.168.0.2/24",
+            "--gateway",
+            "192.168.0.1",
+            net_name,
+        ]
+        args = get_network_create_args(net_desc, proj_name, net_name)
+        self.assertEqual(args, expected_args)
+
+    def test_complete(self):
+        net_desc = {
+            "labels": ["label1", "label2"],
+            "internal": True,
+            "driver": "bridge",
+            "driver_opts": {"opt1": "value1", "opt2": "value2"},
+            "ipam": {
+                "driver": "default",
+                "config": [
+                    {
+                        "subnet": "192.168.0.0/24",
+                        "ip_range": "192.168.0.2/24",
+                        "gateway": "192.168.0.1",
+                    }
+                ],
+            },
+            "enable_ipv6": True,
+        }
+        proj_name = "test_project"
+        net_name = "test_network"
+        expected_args = [
+            "create",
+            "--label",
+            f"io.podman.compose.project={proj_name}",
+            "--label",
+            f"com.docker.compose.project={proj_name}",
+            "--label",
+            "label1",
+            "--label",
+            "label2",
+            "--internal",
+            "--driver",
+            "bridge",
+            "--opt",
+            "opt1=value1",
+            "--opt",
+            "opt2=value2",
+            "--ipam-driver",
+            "default",
+            "--ipv6",
+            "--subnet",
+            "192.168.0.0/24",
+            "--ip-range",
+            "192.168.0.2/24",
+            "--gateway",
+            "192.168.0.1",
+            net_name,
+        ]
+        args = get_network_create_args(net_desc, proj_name, net_name)
+        self.assertEqual(args, expected_args)

pytests/test_normalize_final_build.py

@@ -1,19 +1,23 @@
+# SPDX-License-Identifier: GPL-2.0
 # pylint: disable=protected-access
+from __future__ import annotations
 
 import argparse
-import copy
 import os
+import unittest
+
 import yaml
-from podman_compose import (
-    normalize_service,
-    normalize,
-    normalize_final,
-    normalize_service_final,
-    PodmanCompose,
-)
+from parameterized import parameterized
+
+from podman_compose import PodmanCompose
+from podman_compose import normalize_final
+from podman_compose import normalize_service_final
 
 cwd = os.path.abspath(".")
-test_cases_simple_normalization = [
+
+
+class TestNormalizeFinalBuild(unittest.TestCase):
+    cases_simple_normalization = [
         ({"image": "test-image"}, {"image": "test-image"}),
         (
             {"build": "."},
@@ -98,32 +102,22 @@ test_cases_simple_normalization = [
         ),
     ]
 
-
-#
-# [service.build] is normalised after merges
-#
-def test_normalize_service_final_returns_absolute_path_in_context() -> None:
+    @parameterized.expand(cases_simple_normalization)
+    def test_normalize_service_final_returns_absolute_path_in_context(self, input, expected):
+        # Tests that [service.build] is normalized after merges
         project_dir = cwd
-    for test_input, expected_service in copy.deepcopy(test_cases_simple_normalization):
-        actual_service = normalize_service_final(test_input, project_dir)
-        assert expected_service == actual_service
+        self.assertEqual(normalize_service_final(input, project_dir), expected)
 
-
-def test_normalize_returns_absolute_path_in_context() -> None:
+    @parameterized.expand(cases_simple_normalization)
+    def test_normalize_returns_absolute_path_in_context(self, input, expected):
         project_dir = cwd
-    for test_input, expected_result in copy.deepcopy(test_cases_simple_normalization):
-        compose_test = {"services": {"test-service": test_input}}
-        compose_expected = {"services": {"test-service": expected_result}}
-        actual_compose = normalize_final(compose_test, project_dir)
-        assert compose_expected == actual_compose
+        compose_test = {"services": {"test-service": input}}
+        compose_expected = {"services": {"test-service": expected}}
+        self.assertEqual(normalize_final(compose_test, project_dir), compose_expected)
 
-
-#
-# running full parse over single compose files
-#
-def test__parse_compose_file_when_single_compose() -> None:
-    for test_input, expected_result in copy.deepcopy(test_cases_simple_normalization):
-        compose_test = {"services": {"test-service": test_input}}
+    @parameterized.expand(cases_simple_normalization)
+    def test_parse_compose_file_when_single_compose(self, input, expected):
+        compose_test = {"services": {"test-service": input}}
         dump_yaml(compose_test, "test-compose.yaml")
 
         podman_compose = PodmanCompose()
@@ -135,14 +129,9 @@ def test__parse_compose_file_when_single_compose() -> None:
         if podman_compose.services:
             podman_compose.services["test-service"].pop("_deps")
             actual_compose = podman_compose.services["test-service"]
-        if actual_compose != expected_result:
-            print("compose:   ", test_input)
-            print("result:    ", expected_result)
+        self.assertEqual(actual_compose, expected)
 
-        assert expected_result == actual_compose
-
-
-test_cases_with_merges = [
+    @parameterized.expand([
         (
             {},
             {"build": "."},
@@ -236,18 +225,10 @@ test_cases_with_merges = [
                 }
             },
         ),
-]
-
-
-#
-# running full parse over merged
-#
-def test__parse_compose_file_when_multiple_composes() -> None:
-    for test_input, test_override, expected_result in copy.deepcopy(
-        test_cases_with_merges
-    ):
-        compose_test_1 = {"services": {"test-service": test_input}}
-        compose_test_2 = {"services": {"test-service": test_override}}
+    ])
+    def test_parse_when_multiple_composes(self, input, override, expected):
+        compose_test_1 = {"services": {"test-service": input}}
+        compose_test_2 = {"services": {"test-service": override}}
         dump_yaml(compose_test_1, "test-compose-1.yaml")
         dump_yaml(compose_test_2, "test-compose-2.yaml")
 
@@ -264,18 +245,10 @@ def test__parse_compose_file_when_multiple_composes() -> None:
         if podman_compose.services:
             podman_compose.services["test-service"].pop("_deps")
             actual_compose = podman_compose.services["test-service"]
-        if actual_compose != expected_result:
-            print("compose:   ", test_input)
-            print("override:  ", test_override)
-            print("result:    ", expected_result)
-        compose_expected = expected_result
-
-        assert compose_expected == actual_compose
+        self.assertEqual(actual_compose, expected)
 
 
-def set_args(
-    podman_compose: PodmanCompose, file_names: list[str], no_normalize: bool
-) -> None:
+def set_args(podman_compose: PodmanCompose, file_names: list[str], no_normalize: bool) -> None:
     podman_compose.global_args = argparse.Namespace()
     podman_compose.global_args.file = file_names
     podman_compose.global_args.project_name = None

pytests/test_volumes.py

@@ -1,21 +1,20 @@
+# SPDX-License-Identifier: GPL-2.0
 # pylint: disable=redefined-outer-name
-import pytest
+import unittest
 
 from podman_compose import parse_short_mount
 
 
-@pytest.fixture
-def multi_propagation_mount_str():
-    return "/foo/bar:/baz:U,Z"
-
-
-def test_parse_short_mount_multi_propagation(multi_propagation_mount_str):
-    expected = {
+class ParseShortMountTests(unittest.TestCase):
+    def test_multi_propagation(self):
+        self.assertEqual(
+            parse_short_mount("/foo/bar:/baz:U,Z", "/"),
+            {
                 "type": "bind",
                 "source": "/foo/bar",
                 "target": "/baz",
                 "bind": {
                     "propagation": "U,Z",
                 },
-    }
-    assert parse_short_mount(multi_propagation_mount_str, "/") == expected
+            },
+        )

setup.py

@@ -1,10 +1,11 @@
+# SPDX-License-Identifier: GPL-2.0
+
 import os
+
 from setuptools import setup
 
 try:
-    README = open(
-        os.path.join(os.path.dirname(__file__), "README.md"), encoding="utf-8"
-    ).read()
+    README = open(os.path.join(os.path.dirname(__file__), "README.md"), encoding="utf-8").read()
 except:  # noqa: E722 # pylint: disable=bare-except
     README = ""
 
@@ -39,20 +40,10 @@ setup(
         "pyyaml",
         "python-dotenv",
     ],
-    extras_require={
-        "devel": [
-            "flake8",
-            "black",
-            "pylint",
-            "pre-commit",
-            "coverage"
-        ]
-    }
+    extras_require={"devel": ["ruff", "pre-commit", "coverage", "parameterized"]},
     # test_suite='tests',
     # tests_require=[
     #     'coverage',
-    #     'pytest-cov',
-    #     'pytest',
     #     'tox',
     # ]
 )

test-requirements.txt

@@ -1,9 +1,33 @@
-# The order of packages is significant, because pip processes them in the order
-# of appearance. Changing the order has an impact on the overall integration
-# process, which may cause wedges in the gate later.
+-e .
+coverage==7.4.3
+parameterized==0.9.0
+pytest==8.0.2
+tox==4.13.0
+ruff==0.3.1
+pylint==3.1.0
 
-coverage
-pytest
-tox
-black
-flake8
+# The packages below are transitive dependencies of the packages above and are included here
+# to make testing reproducible.
+# To refresh, create a new virtualenv and do:
+#  pip install -r requirements.txt -r test-requirements.txt
+#  pip freeze > test-requirements.txt
+# and edit test-requirements.txt to add this comment
+
+astroid==3.1.0
+cachetools==5.3.3
+chardet==5.2.0
+colorama==0.4.6
+dill==0.3.8
+distlib==0.3.8
+filelock==3.13.1
+iniconfig==2.0.0
+isort==5.13.2
+mccabe==0.7.0
+packaging==23.2
+platformdirs==4.2.0
+pluggy==1.4.0
+pyproject-api==1.6.1
+python-dotenv==1.0.1
+PyYAML==6.0.1
+tomlkit==0.12.4
+virtualenv==20.25.1

tests/__init__.py

@@ -0,0 +1,12 @@
+import os
+import subprocess
+
+
+def create_base_test_image():
+    subprocess.check_call(
+        ['podman', 'build', '-t', 'nopush/podman-compose-test', '.'],
+        cwd=os.path.join(os.path.dirname(__file__), "base_image"),
+    )
+
+
+create_base_test_image()

tests/base_image/Dockerfile

@@ -0,0 +1,6 @@
+FROM docker.io/library/debian:bookworm-slim
+RUN apt-get update \
+    && apt-get install -y \
+        dumb-init \
+        busybox \
+        wget

tests/build_secrets/Dockerfile

@@ -0,0 +1,9 @@
+FROM busybox
+
+RUN --mount=type=secret,required=true,id=build_secret \
+    ls -l /run/secrets/ && cat /run/secrets/build_secret
+
+RUN --mount=type=secret,required=true,id=build_secret,target=/tmp/secret \
+    ls -l /run/secrets/ /tmp/ && cat /tmp/secret
+
+CMD [ 'echo', 'nothing here' ]

tests/build_secrets/docker-compose.yaml

@@ -0,0 +1,22 @@
+version: "3.8"
+
+services:
+  test:
+    image: test
+    secrets:
+      - run_secret                  # implicitly mount to /run/secrets/run_secret
+      - source: run_secret
+        target: /tmp/run_secret2    # explicit mount point
+
+    build:
+      context: .
+      secrets:
+        - build_secret              # can be mounted in Dockerfile with "RUN --mount=type=secret,id=build_secret"
+        - source: build_secret
+          target: build_secret2     # rename to build_secret2
+
+secrets:
+  build_secret:
+    file: ./my_secret
+  run_secret:
+    file: ./my_secret

tests/build_secrets/docker-compose.yaml.invalid

@@ -0,0 +1,18 @@
+version: "3.8"
+
+services:
+  test:
+    image: test
+    build:
+      context: .
+      secrets:
+        # invalid target argument
+        #
+        # According to https://github.com/compose-spec/compose-spec/blob/master/build.md, target is
+        # supposed to be the "name of a *file* to be mounted in /run/secrets/". Not a path.
+        - source: build_secret
+          target: /build_secret
+
+secrets:
+  build_secret:
+    file: ./my_secret

tests/build_secrets/my_secret

@@ -0,0 +1 @@
+important-secret-is-important

tests/conftest.py

@@ -1,26 +0,0 @@
-"""conftest.py
-
-Defines global pytest fixtures available to all tests.
-"""
-# pylint: disable=redefined-outer-name
-from pathlib import Path
-import os
-import pytest
-
-
-@pytest.fixture
-def base_path():
-    """Returns the base path for the project"""
-    return Path(__file__).parent.parent
-
-
-@pytest.fixture
-def test_path(base_path):
-    """Returns the path to the tests directory"""
-    return os.path.join(base_path, "tests")
-
-
-@pytest.fixture
-def podman_compose_path(base_path):
-    """Returns the path to the podman compose script"""
-    return os.path.join(base_path, "podman_compose.py")

tests/deps/docker-compose.yaml

@@ -1,22 +1,22 @@
 version: "3.7"
 services:
     web:
-      image: busybox
-      command: ["/bin/busybox", "httpd", "-f", "-h", "/etc/", "-p", "8000"]
+      image: nopush/podman-compose-test
+      command: ["dumb-init", "/bin/busybox", "httpd", "-f", "-h", "/etc/", "-p", "8000"]
       tmpfs:
         - /run
         - /tmp
     sleep:
-      image: busybox
-      command: ["/bin/busybox", "sh", "-c", "sleep 3600"]
+      image: nopush/podman-compose-test
+      command: ["dumb-init", "/bin/busybox", "sh", "-c", "sleep 3600"]
       depends_on:
         - "web"
       tmpfs:
         - /run
         - /tmp
     sleep2:
-      image: busybox
-      command: ["/bin/busybox", "sh", "-c", "sleep 3600"]
+      image: nopush/podman-compose-test
+      command: ["dumb-init", "/bin/busybox", "sh", "-c", "sleep 3600"]
       depends_on:
       - sleep
       tmpfs:

tests/exit-from/docker-compose.yaml

@@ -1,20 +1,20 @@
 version: "3"
 services:
     too_long:
-      image: busybox
-      command: ["/bin/busybox", "sh", "-c", "sleep 3600; exit 0"]
+      image: nopush/podman-compose-test
+      command: ["dumb-init", "/bin/busybox", "sh", "-c", "sleep 3600; exit 0"]
       tmpfs:
         - /run
         - /tmp
     sh1:
-      image: busybox
-      command: ["/bin/busybox", "sh", "-c", "sleep 5; exit 1"]
+      image: nopush/podman-compose-test
+      command: ["dumb-init", "/bin/busybox", "sh", "-c", "sleep 1; exit 1"]
       tmpfs:
         - /run
         - /tmp
     sh2:
-      image: busybox
-      command: ["/bin/busybox", "sh", "-c", "sleep 5; exit 2"]
+      image: nopush/podman-compose-test
+      command: ["dumb-init", "/bin/busybox", "sh", "-c", "sleep 1; exit 2"]
       tmpfs:
         - /run
         - /tmp

tests/extends_w_empty_service/common-services.yml

@@ -2,6 +2,6 @@ services:
   webapp_default:
 
   webapp_special:
-    image: busybox
+    image: nopush/podman-compose-test
     volumes:
       - "/data"

tests/extends_w_empty_service/docker-compose.yml

@@ -1,7 +1,7 @@
 version: "3"
 services:
   web:
-    image: busybox
+    image: nopush/podman-compose-test
     extends:
       file: common-services.yml
       service: webapp_default

tests/extends_w_file_subdir/sub/docker/example/Dockerfile

@@ -1 +1 @@
-FROM busybox as base
+FROM nopush/podman-compose-test as base

tests/include/docker-compose.base.yaml

@@ -2,6 +2,6 @@ version: '3.6'
 
 services:
   web:
-    image: busybox
-    command: ["/bin/busybox", "httpd", "-f", "-h", ".", "-p", "8003"]
+    image: nopush/podman-compose-test
+    command: ["dumb-init", "/bin/busybox", "httpd", "-f", "-h", ".", "-p", "8003"]
 

tests/nets_test_ip/docker-compose.yml

@@ -0,0 +1,61 @@
+version: "3"
+networks:
+    shared-network:
+        driver: bridge
+        ipam:
+            config:
+              - subnet: "172.19.1.0/24"
+    internal-network:
+        driver: bridge
+        ipam:
+            config:
+              - subnet: "172.19.2.0/24"
+
+services:
+    web1:
+        image: busybox
+        hostname: web1
+        command: ["/bin/busybox", "httpd", "-f", "-h", "/var/www/html", "-p", "8001"]
+        working_dir: /var/www/html
+        networks:
+            shared-network:
+                ipv4_address: "172.19.1.10"
+                x-podman.mac_address: "02:01:01:00:01:01"
+            internal-network:
+                ipv4_address: "172.19.2.10"
+                x-podman.mac_address: "02:01:01:00:02:01"
+        volumes:
+            - ./test1.txt:/var/www/html/index.txt:ro,z
+    web2:
+        image: busybox
+        hostname: web2
+        command: ["/bin/busybox", "httpd", "-f", "-h", "/var/www/html", "-p", "8001"]
+        working_dir: /var/www/html
+        mac_address: "02:01:01:00:02:02"
+        networks:
+            internal-network:
+                ipv4_address: "172.19.2.11"
+        volumes:
+          - ./test2.txt:/var/www/html/index.txt:ro,z
+
+    web3:
+        image: busybox
+        hostname: web2
+        command: ["/bin/busybox", "httpd", "-f", "-h", "/var/www/html", "-p", "8001"]
+        working_dir: /var/www/html
+        networks:
+            internal-network:
+        volumes:
+          - ./test3.txt:/var/www/html/index.txt:ro,z
+
+    web4:
+        image: busybox
+        hostname: web2
+        command: ["/bin/busybox", "httpd", "-f", "-h", "/var/www/html", "-p", "8001"]
+        working_dir: /var/www/html
+        networks:
+            internal-network:
+            shared-network:
+                ipv4_address: "172.19.1.13"
+        volumes:
+          - ./test4.txt:/var/www/html/index.txt:ro,z

tests/nets_test_ip/test1.txt

@@ -0,0 +1 @@
+test1

tests/nets_test_ip/test2.txt

@@ -0,0 +1 @@
+test2

tests/nets_test_ip/test3.txt

@@ -0,0 +1 @@
+test3

tests/nets_test_ip/test4.txt

@@ -0,0 +1 @@
+test4

tests/pid/docker-compose.yml

@@ -0,0 +1,6 @@
+version: "3"
+services:
+  serv:
+    image: busybox
+    pid: host
+    command: sh -c "ps all"

tests/ports/docker-compose.yml

@@ -1,18 +1,18 @@
 version: "3"
 services:
     web1:
-      image: busybox
+      image: nopush/podman-compose-test
       hostname: web1
-      command: ["/bin/busybox", "httpd", "-f", "-h", "/var/www/html", "-p", "8001"]
+      command: ["dumb-init", "/bin/busybox", "httpd", "-f", "-h", "/var/www/html", "-p", "8001"]
       working_dir: /var/www/html
       ports:
         - 8001:8001
       volumes:
         - ./test1.txt:/var/www/html/index.txt:ro,z
     web2:
-      image: busybox
+      image: nopush/podman-compose-test
       hostname: web2
-      command: ["/bin/busybox", "httpd", "-f", "-h", "/var/www/html", "-p", "8002"]
+      command: ["dumb-init", "/bin/busybox", "httpd", "-f", "-h", "/var/www/html", "-p", "8002"]
       working_dir: /var/www/html
       ports:
         - 8002:8002

tests/profile/docker-compose.yml

@@ -1,22 +1,22 @@
 version: "3"
 services:
     default-service:
-      image: busybox
-      command: ["/bin/busybox", "httpd", "-f", "-h", "/etc/", "-p", "8000"]
+      image: nopush/podman-compose-test
+      command: ["dumb-init", "/bin/busybox", "httpd", "-f", "-h", "/etc/", "-p", "8000"]
       tmpfs:
         - /run
         - /tmp
     service-1:
-      image: busybox
-      command: ["/bin/busybox", "httpd", "-f", "-h", "/etc/", "-p", "8000"]
+      image: nopush/podman-compose-test
+      command: ["dumb-init", "/bin/busybox", "httpd", "-f", "-h", "/etc/", "-p", "8000"]
       tmpfs:
         - /run
         - /tmp
       profiles:
         - profile-1
     service-2:
-      image: busybox
-      command: ["/bin/busybox", "httpd", "-f", "-h", "/etc/", "-p", "8000"]
+      image: nopush/podman-compose-test
+      command: ["dumb-init", "/bin/busybox", "httpd", "-f", "-h", "/etc/", "-p", "8000"]
       tmpfs:
         - /run
         - /tmp

tests/test_podman_compose.py

@@ -1,18 +1,29 @@
+# SPDX-License-Identifier: GPL-2.0
+
+import os
+import unittest
 from pathlib import Path
-import subprocess
+
+from .test_utils import RunSubprocessMixin
 
 
-def capture(command):
-    proc = subprocess.Popen(
-        command,
-        stdout=subprocess.PIPE,
-        stderr=subprocess.PIPE,
-    )
-    out, err = proc.communicate()
-    return out, err, proc.returncode
+def base_path():
+    """Returns the base path for the project"""
+    return Path(__file__).parent.parent
 
 
-def test_podman_compose_extends_w_file_subdir():
+def test_path():
+    """Returns the path to the tests directory"""
+    return os.path.join(base_path(), "tests")
+
+
+def podman_compose_path():
+    """Returns the path to the podman compose script"""
+    return os.path.join(base_path(), "podman_compose.py")
+
+
+class TestPodmanCompose(unittest.TestCase, RunSubprocessMixin):
+    def test_extends_w_file_subdir(self):
         """
         Test that podman-compose can execute podman-compose -f <file> up with extended File which
         includes a build context
@@ -41,35 +52,34 @@ def test_podman_compose_extends_w_file_subdir():
             '{{.Image}}',
         ]
 
-    command_down = [
+        self.run_subprocess_assert_returncode(command_up)
+        # check container was created and exists
+        out, _ = self.run_subprocess_assert_returncode(command_check_container)
+        self.assertEqual(out, b'localhost/subdir_test:me\n')
+        # cleanup test image(tags)
+        self.run_subprocess_assert_returncode([
+            str(main_path.joinpath("podman_compose.py")),
+            "-f",
+            str(main_path.joinpath("tests", "extends_w_file_subdir", "docker-compose.yml")),
+            "down",
+        ])
+
+        self.run_subprocess_assert_returncode([
             "podman",
             "rmi",
             "--force",
             "localhost/subdir_test:me",
-        "docker.io/library/busybox",
-    ]
+        ])
 
-    out, _, returncode = capture(command_up)
-    assert 0 == returncode
-    # check container was created and exists
-    out, err, returncode = capture(command_check_container)
-    assert 0 == returncode
-    assert b'localhost/subdir_test:me\n' == out
-    out, _, returncode = capture(command_down)
-    # cleanup test image(tags)
-    assert 0 == returncode
-    print('ok')
         # check container did not exists anymore
-    out, _, returncode = capture(command_check_container)
-    assert 0 == returncode
-    assert b'' == out
+        out, _ = self.run_subprocess_assert_returncode(command_check_container)
+        self.assertEqual(out, b'')
 
-
-def test_podman_compose_extends_w_empty_service():
+    def test_extends_w_empty_service(self):
         """
         Test that podman-compose can execute podman-compose -f <file> up with extended File which
-    includes an empty service. (e.g. if the file is used as placeholder for more complex configurations.)
-    :return:
+        includes an empty service. (e.g. if the file is used as placeholder for more complex
+        configurations.)
         """
         main_path = Path(__file__).parent.parent
 
@@ -77,12 +87,9 @@ def test_podman_compose_extends_w_empty_service():
             "python3",
             str(main_path.joinpath("podman_compose.py")),
             "-f",
-        str(
-            main_path.joinpath("tests", "extends_w_empty_service", "docker-compose.yml")
-        ),
+            str(main_path.joinpath("tests", "extends_w_empty_service", "docker-compose.yml")),
             "up",
             "-d",
         ]
 
-    _, _, returncode = capture(command_up)
-    assert 0 == returncode
+        self.run_subprocess_assert_returncode(command_up)

tests/test_podman_compose_build_secrets.py

@@ -0,0 +1,90 @@
+# SPDX-License-Identifier: GPL-2.0
+
+
+"""Test how secrets in files are passed to podman."""
+
+import os
+import subprocess
+import unittest
+
+from .test_podman_compose import podman_compose_path
+from .test_podman_compose import test_path
+
+
+def compose_yaml_path():
+    """ "Returns the path to the compose file used for this test module"""
+    return os.path.join(test_path(), "build_secrets")
+
+
+class TestComposeBuildSecrets(unittest.TestCase):
+    def test_run_secret(self):
+        """podman run should receive file secrets as --volume
+
+        See build_secrets/docker-compose.yaml for secret names and mount points (aka targets)
+
+        """
+        cmd = (
+            "coverage",
+            "run",
+            podman_compose_path(),
+            "--dry-run",
+            "--verbose",
+            "-f",
+            os.path.join(compose_yaml_path(), "docker-compose.yaml"),
+            "run",
+            "test",
+        )
+        p = subprocess.run(
+            cmd, stdout=subprocess.PIPE, check=False, stderr=subprocess.STDOUT, text=True
+        )
+        self.assertEqual(p.returncode, 0)
+        secret_path = os.path.join(compose_yaml_path(), "my_secret")
+        self.assertIn(f"--volume {secret_path}:/run/secrets/run_secret:ro,rprivate,rbind", p.stdout)
+        self.assertIn(f"--volume {secret_path}:/tmp/run_secret2:ro,rprivate,rbind", p.stdout)
+
+    def test_build_secret(self):
+        """podman build should receive secrets as --secret, so that they can be used inside the
+        Dockerfile in "RUN --mount=type=secret ..." commands.
+
+        """
+        cmd = (
+            "coverage",
+            "run",
+            podman_compose_path(),
+            "--dry-run",
+            "--verbose",
+            "-f",
+            os.path.join(compose_yaml_path(), "docker-compose.yaml"),
+            "build",
+        )
+        p = subprocess.run(
+            cmd, stdout=subprocess.PIPE, check=False, stderr=subprocess.STDOUT, text=True
+        )
+        self.assertEqual(p.returncode, 0)
+        secret_path = os.path.join(compose_yaml_path(), "my_secret")
+        self.assertIn(f"--secret id=build_secret,src={secret_path}", p.stdout)
+        self.assertIn(f"--secret id=build_secret2,src={secret_path}", p.stdout)
+
+    def test_invalid_build_secret(self):
+        """build secrets in docker-compose file can only have a target argument without directory
+        component
+
+        """
+        cmd = (
+            "coverage",
+            "run",
+            podman_compose_path(),
+            "--dry-run",
+            "--verbose",
+            "-f",
+            os.path.join(compose_yaml_path(), "docker-compose.yaml.invalid"),
+            "build",
+        )
+        p = subprocess.run(
+            cmd, stdout=subprocess.PIPE, check=False, stderr=subprocess.STDOUT, text=True
+        )
+        self.assertNotEqual(p.returncode, 0)
+        self.assertIn(
+            'ValueError: ERROR: Build secret "build_secret" has invalid target "/build_secret"',
+            p.stdout,
+        )

tests/test_podman_compose_build_ulimits.py

@@ -0,0 +1,93 @@
+# SPDX-License-Identifier: GPL-2.0
+
+
+"""Test how ulimits are applied in podman-compose build."""
+
+import os
+import subprocess
+import unittest
+
+from .test_podman_compose import podman_compose_path
+from .test_podman_compose import test_path
+
+
+def compose_yaml_path():
+    """ "Returns the path to the compose file used for this test module"""
+    return os.path.join(test_path(), "ulimit_build")
+
+
+class TestComposeBuildUlimits(unittest.TestCase):
+    def test_build_ulimits_ulimit1(self):
+        """podman build should receive and apply limits when building service ulimit1"""
+
+        cmd = (
+            "coverage",
+            "run",
+            podman_compose_path(),
+            "--verbose",
+            "-f",
+            os.path.join(compose_yaml_path(), "docker-compose.yaml"),
+            "build",
+            "--no-cache",
+            "ulimit1",
+        )
+        p = subprocess.run(
+            cmd, stdout=subprocess.PIPE, check=False, stderr=subprocess.STDOUT, text=True
+        )
+
+        self.assertEqual(p.returncode, 0)
+        self.assertIn("--ulimit nofile=1001", p.stdout)
+        self.assertIn("soft nofile limit: 1001", p.stdout)
+        self.assertIn("hard nofile limit: 1001", p.stdout)
+
+    def test_build_ulimits_ulimit2(self):
+        """podman build should receive and apply limits when building service ulimit2"""
+
+        cmd = (
+            "coverage",
+            "run",
+            podman_compose_path(),
+            "--verbose",
+            "-f",
+            os.path.join(compose_yaml_path(), "docker-compose.yaml"),
+            "build",
+            "--no-cache",
+            "ulimit2",
+        )
+        p = subprocess.run(
+            cmd, stdout=subprocess.PIPE, check=False, stderr=subprocess.STDOUT, text=True
+        )
+
+        self.assertEqual(p.returncode, 0)
+        self.assertIn("--ulimit nofile=1002", p.stdout)
+        self.assertIn("--ulimit nproc=1002:2002", p.stdout)
+        self.assertIn("soft process limit: 1002", p.stdout)
+        self.assertIn("hard process limit: 2002", p.stdout)
+        self.assertIn("soft nofile limit: 1002", p.stdout)
+        self.assertIn("hard nofile limit: 1002", p.stdout)
+
+    def test_build_ulimits_ulimit3(self):
+        """podman build should receive and apply limits when building service ulimit3"""
+
+        cmd = (
+            "coverage",
+            "run",
+            podman_compose_path(),
+            "--verbose",
+            "-f",
+            os.path.join(compose_yaml_path(), "docker-compose.yaml"),
+            "build",
+            "--no-cache",
+            "ulimit3",
+        )
+        p = subprocess.run(
+            cmd, stdout=subprocess.PIPE, check=False, stderr=subprocess.STDOUT, text=True
+        )
+
+        self.assertEqual(p.returncode, 0)
+        self.assertIn("--ulimit nofile=1003", p.stdout)
+        self.assertIn("--ulimit nproc=1003:2003", p.stdout)
+        self.assertIn("soft process limit: 1003", p.stdout)
+        self.assertIn("hard process limit: 2003", p.stdout)
+        self.assertIn("soft nofile limit: 1003", p.stdout)
+        self.assertIn("hard nofile limit: 1003", p.stdout)

tests/test_podman_compose_config.py

@@ -1,40 +1,49 @@
+# SPDX-License-Identifier: GPL-2.0
+
 """
 test_podman_compose_config.py
 
 Tests the podman-compose config command which is used to return defined compose services.
 """
+
 # pylint: disable=redefined-outer-name
 import os
-from test_podman_compose import capture
-import pytest
+import unittest
+
+from parameterized import parameterized
+
+from .test_podman_compose import podman_compose_path
+from .test_podman_compose import test_path
+from .test_utils import RunSubprocessMixin
 
 
-@pytest.fixture
-def profile_compose_file(test_path):
+def profile_compose_file():
     """ "Returns the path to the `profile` compose file used for this test module"""
-    return os.path.join(test_path, "profile", "docker-compose.yml")
+    return os.path.join(test_path(), "profile", "docker-compose.yml")
 
 
-def test_config_no_profiles(podman_compose_path, profile_compose_file):
+class TestComposeConfig(unittest.TestCase, RunSubprocessMixin):
+    def test_config_no_profiles(self):
         """
         Tests podman-compose config command without profile enablement.
-
-    :param podman_compose_path: The fixture used to specify the path to the podman compose file.
-    :param profile_compose_file: The fixtued used to specify the path to the "profile" compose used in the test.
         """
-    config_cmd = ["coverage", "run", podman_compose_path, "-f", profile_compose_file, "config"]
+        config_cmd = [
+            "coverage",
+            "run",
+            podman_compose_path(),
+            "-f",
+            profile_compose_file(),
+            "config",
+        ]
 
-    out, _, return_code = capture(config_cmd)
-    assert return_code == 0
+        out, _ = self.run_subprocess_assert_returncode(config_cmd)
 
         string_output = out.decode("utf-8")
-    assert "default-service" in string_output
-    assert "service-1" not in string_output
-    assert "service-2" not in string_output
+        self.assertIn("default-service", string_output)
+        self.assertNotIn("service-1", string_output)
+        self.assertNotIn("service-2", string_output)
 
-
-@pytest.mark.parametrize(
-    "profiles, expected_services",
+    @parameterized.expand(
         [
             (
                 ["--profile", "profile-1", "config"],
@@ -50,29 +59,24 @@ def test_config_no_profiles(podman_compose_path, profile_compose_file):
             ),
         ],
     )
-def test_config_profiles(
-    podman_compose_path, profile_compose_file, profiles, expected_services
-):
+    def test_config_profiles(self, profiles, expected_services):
         """
         Tests podman-compose
-    :param podman_compose_path: The fixture used to specify the path to the podman compose file.
-    :param profile_compose_file: The fixtued used to specify the path to the "profile" compose used in the test.
         :param profiles: The enabled profiles for the parameterized test.
-    :param expected_services: Dictionary used to model the expected "enabled" services in the profile.
-        Key = service name, Value = True if the service is enabled, otherwise False.
+        :param expected_services: Dictionary used to model the expected "enabled" services in the
+            profile. Key = service name, Value = True if the service is enabled, otherwise False.
         """
-    config_cmd = ["coverage", "run", podman_compose_path, "-f", profile_compose_file]
+        config_cmd = ["coverage", "run", podman_compose_path(), "-f", profile_compose_file()]
         config_cmd.extend(profiles)
 
-    out, _, return_code = capture(config_cmd)
-    assert return_code == 0
+        out, _ = self.run_subprocess_assert_returncode(config_cmd)
 
         actual_output = out.decode("utf-8")
 
-    assert len(expected_services) == 3
+        self.assertEqual(len(expected_services), 3)
 
         actual_services = {}
         for service, _ in expected_services.items():
             actual_services[service] = service in actual_output
 
-    assert expected_services == actual_services
+        self.assertEqual(expected_services, actual_services)

tests/test_podman_compose_include.py

@@ -1,18 +1,13 @@
+# SPDX-License-Identifier: GPL-2.0
+
+import unittest
 from pathlib import Path
-import subprocess
+
+from .test_utils import RunSubprocessMixin
 
 
-def capture(command):
-    proc = subprocess.Popen(
-        command,
-        stdout=subprocess.PIPE,
-        stderr=subprocess.PIPE,
-    )
-    out, err = proc.communicate()
-    return out, err, proc.returncode
-
-
-def test_podman_compose_include():
+class TestPodmanComposeInclude(unittest.TestCase, RunSubprocessMixin):
+    def test_podman_compose_include(self):
         """
         Test that podman-compose can execute podman-compose -f <file> up with include
         :return:
@@ -51,22 +46,17 @@ def test_podman_compose_include():
 
         command_down = ["podman", "rm", "--force", "CONTAINER_ID"]
 
-    out, _, returncode = capture(command_up)
-    assert 0 == returncode
-    out, _, returncode = capture(command_check_container)
-    assert 0 == returncode
-    assert out == b'"docker.io/library/busybox:latest"\n'
+        self.run_subprocess_assert_returncode(command_up)
+        out, _ = self.run_subprocess_assert_returncode(command_check_container)
+        self.assertEqual(out, b'"localhost/nopush/podman-compose-test:latest"\n')
         # Get container ID to remove it
-    out, _, returncode = capture(command_container_id)
-    assert 0 == returncode
-    assert out != b""
+        out, _ = self.run_subprocess_assert_returncode(command_container_id)
+        self.assertNotEqual(out, b"")
         container_id = out.decode().strip().replace('"', "")
         command_down[3] = container_id
-    out, _, returncode = capture(command_down)
+        out, _ = self.run_subprocess_assert_returncode(command_down)
         # cleanup test image(tags)
-    assert 0 == returncode
-    assert out != b""
+        self.assertNotEqual(out, b"")
         # check container did not exists anymore
-    out, _, returncode = capture(command_check_container)
-    assert 0 == returncode
-    assert out == b""
+        out, _ = self.run_subprocess_assert_returncode(command_check_container)
+        self.assertEqual(out, b"")

tests/test_podman_compose_networks.py

@@ -0,0 +1,116 @@
+# SPDX-License-Identifier: GPL-2.0
+
+"""
+test_podman_compose_networks.py
+
+Tests the podman networking parameters
+"""
+
+# pylint: disable=redefined-outer-name
+import os
+import unittest
+
+from .test_podman_compose import podman_compose_path
+from .test_podman_compose import test_path
+from .test_utils import RunSubprocessMixin
+
+
+class TestPodmanComposeNetwork(RunSubprocessMixin, unittest.TestCase):
+    @staticmethod
+    def compose_file():
+        """Returns the path to the compose file used for this test module"""
+        return os.path.join(test_path(), "nets_test_ip", "docker-compose.yml")
+
+    def teardown(self):
+        """
+        Ensures that the services within the "profile compose file" are removed between
+        each test case.
+        """
+        # run the test case
+        yield
+
+        down_cmd = [
+            "coverage",
+            "run",
+            podman_compose_path(),
+            "-f",
+            self.compose_file(),
+            "kill",
+            "-a",
+        ]
+        self.run_subprocess(down_cmd)
+
+    def test_networks(self):
+        up_cmd = [
+            "coverage",
+            "run",
+            podman_compose_path(),
+            "-f",
+            self.compose_file(),
+            "up",
+            "-d",
+            "--force-recreate",
+        ]
+
+        self.run_subprocess_assert_returncode(up_cmd)
+
+        check_cmd = [
+            podman_compose_path(),
+            "-f",
+            self.compose_file(),
+            "ps",
+            "--format",
+            '"{{.Names}}"',
+        ]
+        out, _ = self.run_subprocess_assert_returncode(check_cmd)
+        self.assertIn(b"nets_test_ip_web1_1", out)
+        self.assertIn(b"nets_test_ip_web2_1", out)
+
+        expected_wget = {
+            "172.19.1.10": "test1",
+            "172.19.2.10": "test1",
+            "172.19.2.11": "test2",
+            "web3": "test3",
+            "172.19.1.13": "test4",
+        }
+
+        for service in ("web1", "web2"):
+            for ip, expect in expected_wget.items():
+                wget_cmd = [
+                    podman_compose_path(),
+                    "-f",
+                    self.compose_file(),
+                    "exec",
+                    service,
+                    "wget",
+                    "-q",
+                    "-O-",
+                    f"http://{ip}:8001/index.txt",
+                ]
+                out, _ = self.run_subprocess_assert_returncode(wget_cmd)
+                self.assertEqual(f"{expect}\r\n", out.decode('utf-8'))
+
+        expected_macip = {
+            "web1": {
+                "eth0": ["172.19.1.10", "02:01:01:00:01:01"],
+                "eth1": ["172.19.2.10", "02:01:01:00:02:01"],
+            },
+            "web2": {"eth0": ["172.19.2.11", "02:01:01:00:02:02"]},
+        }
+
+        for service, interfaces in expected_macip.items():
+            ip_cmd = [
+                podman_compose_path(),
+                "-f",
+                self.compose_file(),
+                "exec",
+                service,
+                "ip",
+                "addr",
+                "show",
+            ]
+            out, _ = self.run_subprocess_assert_returncode(ip_cmd)
+            for interface, values in interfaces.items():
+                ip, mac = values
+                self.assertIn(f"ether {mac}", out.decode('utf-8'))
+                self.assertIn(f"inet {ip}/", out.decode('utf-8'))

tests/test_podman_compose_tests.py

@@ -1,180 +1,189 @@
+# SPDX-License-Identifier: GPL-2.0
+
 """
 test_podman_compose_up_down.py
 
 Tests the podman compose up and down commands used to create and remove services.
 """
+
 # pylint: disable=redefined-outer-name
 import os
-import time
+import unittest
 
-from test_podman_compose import capture
+from .test_podman_compose import podman_compose_path
+from .test_podman_compose import test_path
+from .test_utils import RunSubprocessMixin
 
 
-def test_exit_from(podman_compose_path, test_path):
+class TestPodmanCompose(unittest.TestCase, RunSubprocessMixin):
+    def test_exit_from(self):
         up_cmd = [
             "coverage",
             "run",
-        podman_compose_path,
+            podman_compose_path(),
             "-f",
-        os.path.join(test_path, "exit-from", "docker-compose.yaml"),
-        "up"
+            os.path.join(test_path(), "exit-from", "docker-compose.yaml"),
+            "up",
         ]
 
-    out, _, return_code = capture(up_cmd + ["--exit-code-from", "sh1"])
-    assert return_code == 1
+        self.run_subprocess_assert_returncode(up_cmd + ["--exit-code-from", "sh1"], 1)
+        self.run_subprocess_assert_returncode(up_cmd + ["--exit-code-from", "sh2"], 2)
 
-    out, _, return_code = capture(up_cmd + ["--exit-code-from", "sh2"])
-    assert return_code == 2
-
-
-def test_run(podman_compose_path, test_path):
+    def test_run(self):
         """
         This will test depends_on as well
         """
         run_cmd = [
             "coverage",
             "run",
-        podman_compose_path,
+            podman_compose_path(),
             "-f",
-        os.path.join(test_path, "deps", "docker-compose.yaml"),
+            os.path.join(test_path(), "deps", "docker-compose.yaml"),
             "run",
             "--rm",
             "sleep",
             "/bin/sh",
             "-c",
-        "wget -q -O - http://web:8000/hosts"
+            "wget -q -O - http://web:8000/hosts",
         ]
 
-    out, _, return_code = capture(run_cmd)
-    assert b'127.0.0.1\tlocalhost' in out
+        out, _ = self.run_subprocess_assert_returncode(run_cmd)
+        self.assertIn(b'127.0.0.1\tlocalhost', out)
 
-    # Run it again to make sure we can run it twice. I saw an issue where a second run, with the container left up,
-    # would fail
+        # Run it again to make sure we can run it twice. I saw an issue where a second run, with
+        # the container left up, would fail
         run_cmd = [
             "coverage",
             "run",
-        podman_compose_path,
+            podman_compose_path(),
             "-f",
-        os.path.join(test_path, "deps", "docker-compose.yaml"),
+            os.path.join(test_path(), "deps", "docker-compose.yaml"),
             "run",
             "--rm",
             "sleep",
             "/bin/sh",
             "-c",
-        "wget -q -O - http://web:8000/hosts"
+            "wget -q -O - http://web:8000/hosts",
         ]
 
-    out, _, return_code = capture(run_cmd)
-    assert b'127.0.0.1\tlocalhost' in out
-    assert return_code == 0
+        out, _ = self.run_subprocess_assert_returncode(run_cmd)
+        self.assertIn(b'127.0.0.1\tlocalhost', out)
 
         # This leaves a container running. Not sure it's intended, but it matches docker-compose
         down_cmd = [
             "coverage",
             "run",
-        podman_compose_path,
+            podman_compose_path(),
             "-f",
-        os.path.join(test_path, "deps", "docker-compose.yaml"),
+            os.path.join(test_path(), "deps", "docker-compose.yaml"),
             "down",
         ]
 
-    out, _, return_code = capture(run_cmd)
-    assert return_code == 0
-
-
-def test_up_with_ports(podman_compose_path, test_path):
-
+        self.run_subprocess_assert_returncode(down_cmd)
 
+    def test_up_with_ports(self):
         up_cmd = [
             "coverage",
             "run",
-        podman_compose_path,
+            podman_compose_path(),
             "-f",
-        os.path.join(test_path, "ports", "docker-compose.yml"),
+            os.path.join(test_path(), "ports", "docker-compose.yml"),
             "up",
             "-d",
-        "--force-recreate"
+            "--force-recreate",
         ]
 
         down_cmd = [
             "coverage",
             "run",
-        podman_compose_path,
+            podman_compose_path(),
             "-f",
-        os.path.join(test_path, "ports", "docker-compose.yml"),
+            os.path.join(test_path(), "ports", "docker-compose.yml"),
             "down",
-        "--volumes"
+            "--volumes",
         ]
 
         try:
-        out, _, return_code = capture(up_cmd)
-        assert return_code == 0
-
+            self.run_subprocess_assert_returncode(up_cmd)
 
         finally:
-        out, _, return_code = capture(down_cmd)
-        assert return_code == 0
-
-
-def test_down_with_vols(podman_compose_path, test_path):
+            self.run_subprocess_assert_returncode(down_cmd)
 
+    def test_down_with_vols(self):
         up_cmd = [
             "coverage",
             "run",
-        podman_compose_path,
+            podman_compose_path(),
             "-f",
-        os.path.join(test_path, "vol", "docker-compose.yaml"),
+            os.path.join(test_path(), "vol", "docker-compose.yaml"),
             "up",
-        "-d"
+            "-d",
         ]
 
         down_cmd = [
             "coverage",
             "run",
-        podman_compose_path,
+            podman_compose_path(),
             "-f",
-        os.path.join(test_path, "vol", "docker-compose.yaml"),
+            os.path.join(test_path(), "vol", "docker-compose.yaml"),
             "down",
-        "--volumes"
+            "--volumes",
         ]
 
         try:
-        out, _, return_code = capture(["podman", "volume", "create", "my-app-data"])
-        assert return_code == 0
-        out, _, return_code = capture(["podman", "volume", "create", "actual-name-of-volume"])
-        assert return_code == 0
+            self.run_subprocess_assert_returncode(["podman", "volume", "create", "my-app-data"])
+            self.run_subprocess_assert_returncode([
+                "podman",
+                "volume",
+                "create",
+                "actual-name-of-volume",
+            ])
 
-        out, _, return_code = capture(up_cmd)
-        assert return_code == 0
-
-        capture(["podman", "inspect", "volume", ""])
+            self.run_subprocess_assert_returncode(up_cmd)
+            self.run_subprocess(["podman", "inspect", "volume", ""])
 
         finally:
-        out, _, return_code = capture(down_cmd)
-        capture(["podman", "volume", "rm", "my-app-data"])
-        capture(["podman", "volume", "rm", "actual-name-of-volume"])
-        assert return_code == 0
+            out, _, return_code = self.run_subprocess(down_cmd)
+            self.run_subprocess(["podman", "volume", "rm", "my-app-data"])
+            self.run_subprocess(["podman", "volume", "rm", "actual-name-of-volume"])
+            self.assertEqual(return_code, 0)
 
-
-def test_down_with_orphans(podman_compose_path, test_path):
-
-    container_id, _ , return_code = capture(["podman", "run", "--rm", "-d", "busybox", "/bin/busybox", "httpd", "-f", "-h", "/etc/", "-p", "8000"])
+    def test_down_with_orphans(self):
+        container_id, _ = self.run_subprocess_assert_returncode([
+            "podman",
+            "run",
+            "--rm",
+            "-d",
+            "nopush/podman-compose-test",
+            "dumb-init",
+            "/bin/busybox",
+            "httpd",
+            "-f",
+            "-h",
+            "/etc/",
+            "-p",
+            "8000",
+        ])
 
         down_cmd = [
             "coverage",
             "run",
-        podman_compose_path,
+            podman_compose_path(),
             "-f",
-        os.path.join(test_path, "ports", "docker-compose.yml"),
+            os.path.join(test_path(), "ports", "docker-compose.yml"),
             "down",
             "--volumes",
-        "--remove-orphans"
+            "--remove-orphans",
         ]
 
-    out, _, return_code = capture(down_cmd)
-    assert return_code == 0
-
-    _, _, exists = capture(["podman", "container", "exists", container_id.decode("utf-8")])
-
-    assert exists == 1
+        self.run_subprocess_assert_returncode(down_cmd)
 
+        self.run_subprocess_assert_returncode(
+            [
+                "podman",
+                "container",
+                "exists",
+                container_id.decode("utf-8"),
+            ],
+            1,
+        )

tests/test_podman_compose_up_down.py

@@ -1,48 +1,50 @@
+# SPDX-License-Identifier: GPL-2.0
+
 """
 test_podman_compose_up_down.py
 
 Tests the podman compose up and down commands used to create and remove services.
 """
+
 # pylint: disable=redefined-outer-name
 import os
-from test_podman_compose import capture
-import pytest
+import unittest
+
+from parameterized import parameterized
+
+from .test_podman_compose import podman_compose_path
+from .test_podman_compose import test_path
+from .test_utils import RunSubprocessMixin
 
 
-@pytest.fixture
-def profile_compose_file(test_path):
+def profile_compose_file():
     """ "Returns the path to the `profile` compose file used for this test module"""
-    return os.path.join(test_path, "profile", "docker-compose.yml")
+    return os.path.join(test_path(), "profile", "docker-compose.yml")
 
 
-@pytest.fixture(autouse=True)
-def teardown(podman_compose_path, profile_compose_file):
+class TestUpDown(unittest.TestCase, RunSubprocessMixin):
+    def tearDown(self):
         """
-    Ensures that the services within the "profile compose file" are removed between each test case.
-
-    :param podman_compose_path: The path to the podman compose script.
-    :param profile_compose_file: The path to the compose file used for this test module.
+        Ensures that the services within the "profile compose file" are removed between each test
+        case.
         """
         # run the test case
-    yield
 
         down_cmd = [
             "coverage",
             "run",
-        podman_compose_path,
+            podman_compose_path(),
             "--profile",
             "profile-1",
             "--profile",
             "profile-2",
             "-f",
-        profile_compose_file,
+            profile_compose_file(),
             "down",
         ]
-    capture(down_cmd)
+        self.run_subprocess(down_cmd)
 
-
-@pytest.mark.parametrize(
-    "profiles, expected_services",
+    @parameterized.expand(
         [
             (
                 ["--profile", "profile-1", "up", "-d"],
@@ -58,18 +60,17 @@ def teardown(podman_compose_path, profile_compose_file):
             ),
         ],
     )
-def test_up(podman_compose_path, profile_compose_file, profiles, expected_services):
+    def test_up(self, profiles, expected_services):
         up_cmd = [
             "coverage",
             "run",
-        podman_compose_path,
+            podman_compose_path(),
             "-f",
-        profile_compose_file,
+            profile_compose_file(),
         ]
         up_cmd.extend(profiles)
 
-    out, _, return_code = capture(up_cmd)
-    assert return_code == 0
+        self.run_subprocess_assert_returncode(up_cmd)
 
         check_cmd = [
             "podman",
@@ -78,14 +79,13 @@ def test_up(podman_compose_path, profile_compose_file, profiles, expected_servic
             "--format",
             '"{{.Names}}"',
         ]
-    out, _, return_code = capture(check_cmd)
-    assert return_code == 0
+        out, _ = self.run_subprocess_assert_returncode(check_cmd)
 
-    assert len(expected_services) == 3
+        self.assertEqual(len(expected_services), 3)
         actual_output = out.decode("utf-8")
 
         actual_services = {}
         for service, _ in expected_services.items():
             actual_services[service] = service in actual_output
 
-    assert expected_services == actual_services
+        self.assertEqual(expected_services, actual_services)

tests/test_utils.py

@@ -0,0 +1,38 @@
+# SPDX-License-Identifier: GPL-2.0
+
+import os
+import subprocess
+import time
+
+
+class RunSubprocessMixin:
+    def is_debug_enabled(self):
+        return "TESTS_DEBUG" in os.environ
+
+    def run_subprocess(self, args):
+        begin = time.time()
+        if self.is_debug_enabled():
+            print("TEST_CALL", args)
+        proc = subprocess.Popen(
+            args,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+        )
+        out, err = proc.communicate()
+        if self.is_debug_enabled():
+            print("TEST_CALL completed", time.time() - begin)
+            print("STDOUT:", out.decode('utf-8'))
+            print("STDERR:", err.decode('utf-8'))
+        return out, err, proc.returncode
+
+    def run_subprocess_assert_returncode(self, args, expected_returncode=0):
+        out, err, returncode = self.run_subprocess(args)
+        decoded_out = out.decode('utf-8')
+        decoded_err = err.decode('utf-8')
+        self.assertEqual(
+            returncode,
+            expected_returncode,
+            f"Invalid return code of process {returncode} != {expected_returncode}\n"
+            f"stdout: {decoded_out}\nstderr: {decoded_err}\n",
+        )
+        return out, err

tests/ulimit_build/Dockerfile

@@ -0,0 +1,5 @@
+FROM busybox
+
+COPY ./ulimit.sh /bin/ulimit.sh
+
+RUN /bin/ulimit.sh

tests/ulimit_build/docker-compose.yaml

@@ -0,0 +1,26 @@
+version: "3"
+services:
+  ulimit1:
+    image: ulimit_build_test
+    build:
+      context: ./
+      dockerfile: Dockerfile
+      ulimits: nofile=1001
+  ulimit2:
+    image: ulimit_build_test
+    build:
+      context: ./
+      dockerfile: Dockerfile
+      ulimits:
+        - nproc=1002:2002
+        - nofile=1002
+  ulimit3:
+    image: ulimit_build_test
+    build:
+      context: ./
+      dockerfile: Dockerfile
+      ulimits:
+        nofile: 1003
+        nproc:
+          soft: 1003
+          hard: 2003

tests/ulimit_build/ulimit.sh

@@ -0,0 +1,6 @@
+#!/bin/sh
+
+echo "soft process limit:" $(ulimit -S -u)
+echo "hard process limit:" $(ulimit -H -u)
+echo "soft nofile limit:" $(ulimit -S -n)
+echo "hard nofile limit:" $(ulimit -H -n)

tests/vol/docker-compose.yaml

@@ -1,8 +1,8 @@
 version: "3"
 services:
     web:
-      image: busybox
-      command: ["/bin/busybox", "httpd", "-f", "-h", "/var/www/html", "-p", "8000"]
+      image: nopush/podman-compose-test
+      command: ["dumb-init", "/bin/busybox", "httpd", "-f", "-h", "/var/www/html", "-p", "8000"]
       working_dir: /var/www/html
       restart: always
       volumes:
@@ -11,21 +11,21 @@ services:
         - /run
         - /tmp
     web1:
-      image: busybox
-      command: ["/bin/busybox", "httpd", "-f", "-h", "/var/www/html", "-p", "8001"]
+      image: nopush/podman-compose-test
+      command: ["dumb-init", "/bin/busybox", "httpd", "-f", "-h", "/var/www/html", "-p", "8001"]
       restart: unless-stopped
       working_dir: /var/www/html
       volumes:
         - myvol1:/var/www/html:ro,z
     web2:
-      image: busybox
-      command: ["/bin/busybox", "httpd", "-f", "-h", "/var/www/html", "-p", "8002"]
+      image: nopush/podman-compose-test
+      command: ["dumb-init", "/bin/busybox", "httpd", "-f", "-h", "/var/www/html", "-p", "8002"]
       working_dir: /var/www/html
       volumes:
         - myvol2:/var/www/html:ro
     web3:
-      image: busybox
-      command: ["/bin/busybox", "httpd", "-f", "-h", "/var/www/html", "-p", "8003"]
+      image: nopush/podman-compose-test
+      command: ["dumb-init", "/bin/busybox", "httpd", "-f", "-h", "/var/www/html", "-p", "8003"]
       working_dir: /var/www/html
       volumes:
         - myvol2:/var/www/html