testcontainers-mockserver 7.1.0__tar.gz

testcontainers_mockserver-7.1.0/PKG-INFO

@@ -0,0 +1,101 @@
+Metadata-Version: 2.4
+Name: testcontainers-mockserver
+Version: 7.1.0
+Summary: Testcontainers module for MockServer
+Author-email: James D Bloom <jamesdbloom@gmail.com>
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://www.mock-server.com
+Project-URL: Repository, https://github.com/mock-server/mockserver
+Project-URL: Documentation, https://www.mock-server.com/mock_server/mockserver_testcontainers.html
+Keywords: testing,docker,mockserver,testcontainers,mocking
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: testcontainers>=4.0.0
+Provides-Extra: test
+Requires-Dist: pytest>=7.0; extra == "test"
+Requires-Dist: requests>=2.20; extra == "test"
+
+# testcontainers-mockserver
+
+A [Testcontainers](https://testcontainers.com) module for [MockServer](https://www.mock-server.com) in Python.
+
+Starts a `mockserver/mockserver` Docker container, waits for readiness, and provides
+convenient accessors for the mapped host, port, and URL.
+
+## Installation
+
+```bash
+pip install testcontainers-mockserver
+```
+
+## Usage
+
+```python
+from testcontainers_mockserver import MockServerContainer
+import requests
+
+with MockServerContainer() as mockserver:
+    url = mockserver.get_url()  # e.g. "http://localhost:49152"
+
+    # Create an expectation
+    requests.put(f"{url}/mockserver/expectation", json={
+        "httpRequest": {"method": "GET", "path": "/hello"},
+        "httpResponse": {"statusCode": 200, "body": "world"},
+    })
+
+    # Match it
+    resp = requests.get(f"{url}/hello")
+    assert resp.text == "world"
+```
+
+## API
+
+### `MockServerContainer(image=..., port=1080)`
+
+- `image` — Docker image to use. Defaults to `mockserver/mockserver:mockserver-7.1.0`.
+- `port` — Container port MockServer listens on. Defaults to `1080`.
+
+### Methods
+
+| Method | Returns | Description |
+|--------|---------|-------------|
+| `get_url()` | `str` | HTTP base URL (e.g. `http://localhost:49152`) |
+| `get_secure_url()` | `str` | HTTPS base URL (same port, `https://` scheme) |
+| `get_host()` | `str` | Mapped host IP |
+| `get_port()` | `int` | Mapped host port |
+| `with_server_port(port)` | `self` | Override the listen port |
+| `with_log_level(level)` | `self` | Set `MOCKSERVER_LOG_LEVEL` |
+| `with_property(key, value)` | `self` | Set any MockServer env var |
+| `with_initialization_json(path)` | `self` | Point to a startup expectations JSON file |
+
+## Building and Testing
+
+```bash
+# Install in editable mode with test dependencies
+pip install -e .[test]
+
+# Run unit tests (no Docker needed)
+pytest tests/test_container_config.py
+
+# Run all tests including integration (requires Docker)
+pytest
+
+# Skip Docker-dependent tests
+pytest -m "not docker"
+```
+
+## Requirements
+
+- Python >= 3.9
+- Docker (for integration tests and actual usage)
+- `testcontainers` >= 4.0.0

testcontainers_mockserver-7.1.0/README.md

@@ -0,0 +1,74 @@
+# testcontainers-mockserver
+
+A [Testcontainers](https://testcontainers.com) module for [MockServer](https://www.mock-server.com) in Python.
+
+Starts a `mockserver/mockserver` Docker container, waits for readiness, and provides
+convenient accessors for the mapped host, port, and URL.
+
+## Installation
+
+```bash
+pip install testcontainers-mockserver
+```
+
+## Usage
+
+```python
+from testcontainers_mockserver import MockServerContainer
+import requests
+
+with MockServerContainer() as mockserver:
+    url = mockserver.get_url()  # e.g. "http://localhost:49152"
+
+    # Create an expectation
+    requests.put(f"{url}/mockserver/expectation", json={
+        "httpRequest": {"method": "GET", "path": "/hello"},
+        "httpResponse": {"statusCode": 200, "body": "world"},
+    })
+
+    # Match it
+    resp = requests.get(f"{url}/hello")
+    assert resp.text == "world"
+```
+
+## API
+
+### `MockServerContainer(image=..., port=1080)`
+
+- `image` — Docker image to use. Defaults to `mockserver/mockserver:mockserver-7.1.0`.
+- `port` — Container port MockServer listens on. Defaults to `1080`.
+
+### Methods
+
+| Method | Returns | Description |
+|--------|---------|-------------|
+| `get_url()` | `str` | HTTP base URL (e.g. `http://localhost:49152`) |
+| `get_secure_url()` | `str` | HTTPS base URL (same port, `https://` scheme) |
+| `get_host()` | `str` | Mapped host IP |
+| `get_port()` | `int` | Mapped host port |
+| `with_server_port(port)` | `self` | Override the listen port |
+| `with_log_level(level)` | `self` | Set `MOCKSERVER_LOG_LEVEL` |
+| `with_property(key, value)` | `self` | Set any MockServer env var |
+| `with_initialization_json(path)` | `self` | Point to a startup expectations JSON file |
+
+## Building and Testing
+
+```bash
+# Install in editable mode with test dependencies
+pip install -e .[test]
+
+# Run unit tests (no Docker needed)
+pytest tests/test_container_config.py
+
+# Run all tests including integration (requires Docker)
+pytest
+
+# Skip Docker-dependent tests
+pytest -m "not docker"
+```
+
+## Requirements
+
+- Python >= 3.9
+- Docker (for integration tests and actual usage)
+- `testcontainers` >= 4.0.0

testcontainers_mockserver-7.1.0/pyproject.toml

@@ -0,0 +1,50 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "testcontainers-mockserver"
+version = "7.1.0"
+description = "Testcontainers module for MockServer"
+readme = "README.md"
+license = "Apache-2.0"
+requires-python = ">=3.9"
+authors = [
+    { name = "James D Bloom", email = "jamesdbloom@gmail.com" },
+]
+keywords = ["testing", "docker", "mockserver", "testcontainers", "mocking"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Topic :: Software Development :: Testing",
+]
+dependencies = [
+    "testcontainers>=4.0.0",
+]
+
+[project.optional-dependencies]
+test = [
+    "pytest>=7.0",
+    "requests>=2.20",
+]
+
+[project.urls]
+Homepage = "https://www.mock-server.com"
+Repository = "https://github.com/mock-server/mockserver"
+Documentation = "https://www.mock-server.com/mock_server/mockserver_testcontainers.html"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+markers = [
+    "docker: marks tests that require a running Docker daemon (deselect with '-m \"not docker\"')",
+]

testcontainers_mockserver-7.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

testcontainers_mockserver-7.1.0/src/testcontainers_mockserver/__init__.py

@@ -0,0 +1,20 @@
+"""Testcontainers module for MockServer.
+
+Provides a ``MockServerContainer`` that starts a ``mockserver/mockserver`` Docker
+image, waits for readiness, and exposes convenience accessors for the mapped
+host, port, and base URL.
+
+Example::
+
+    from testcontainers_mockserver import MockServerContainer
+
+    with MockServerContainer() as mockserver:
+        url = mockserver.get_url()
+        # url is e.g. "http://localhost:49152"
+        # Use requests or any HTTP client to interact with MockServer at this URL.
+"""
+
+from testcontainers_mockserver.container import MockServerContainer
+
+__all__ = ["MockServerContainer"]
+__version__ = "7.0.0"

testcontainers_mockserver-7.1.0/src/testcontainers_mockserver/container.py

@@ -0,0 +1,139 @@
+"""MockServerContainer — Testcontainers module for MockServer.
+
+This module provides a thin wrapper around testcontainers' ``DockerContainer`` that
+starts a ``mockserver/mockserver`` image, waits for readiness via the
+``/mockserver/status`` HTTP endpoint (PUT, returns 200), and exposes convenience
+methods for the mapped host, port, and URL.
+"""
+
+from __future__ import annotations
+
+from typing import Optional
+
+from testcontainers.core.container import DockerContainer
+from testcontainers.core.wait_strategies import HttpWaitStrategy
+
+#: Default port MockServer listens on inside the container (HTTP, HTTPS, SOCKS,
+#: and HTTP CONNECT all served on this single unified port).
+MOCKSERVER_PORT = 1080
+
+#: Default Docker image name for MockServer.
+_IMAGE_NAME = "mockserver/mockserver"
+
+#: Default image tag, pinned to the current MockServer release version.
+_DEFAULT_TAG = "mockserver-7.0.0"
+
+
+class MockServerContainer(DockerContainer):
+    """A Testcontainers wrapper that starts a MockServer Docker container.
+
+    The container starts the ``mockserver/mockserver`` image on port 1080 and waits
+    for the ``PUT /mockserver/status`` endpoint to return HTTP 200 before yielding
+    control.
+
+    Parameters
+    ----------
+    image : str, optional
+        Full Docker image reference. Defaults to
+        ``mockserver/mockserver:mockserver-7.0.0``.
+    port : int, optional
+        The port MockServer listens on inside the container. Defaults to 1080.
+
+    Example
+    -------
+    ::
+
+        from testcontainers_mockserver import MockServerContainer
+
+        with MockServerContainer() as server:
+            url = server.get_url()
+            # e.g. "http://localhost:49152"
+    """
+
+    def __init__(
+        self,
+        image: str = f"{_IMAGE_NAME}:{_DEFAULT_TAG}",
+        port: int = MOCKSERVER_PORT,
+        **kwargs,
+    ) -> None:
+        super().__init__(image=image, **kwargs)
+        self._port = port
+        self.with_exposed_ports(self._port)
+        self.with_env("SERVER_PORT", str(self._port))
+
+    def _build_wait_strategy(self) -> HttpWaitStrategy:
+        """Build the readiness wait strategy.
+
+        MockServer's ``/mockserver/status`` endpoint requires a PUT request and
+        returns HTTP 200 with a JSON body containing ``{ "ports": [...] }`` when
+        the server is ready.
+        """
+        return (
+            HttpWaitStrategy(self._port, "/mockserver/status")
+            .with_method("PUT")
+            .with_startup_timeout(60)
+        )
+
+    def start(self) -> "MockServerContainer":
+        """Start the container and wait for MockServer to become ready."""
+        super().start()
+        self._build_wait_strategy().wait_until_ready(self)
+        return self
+
+    # ------------------------------------------------------------------
+    # Convenience accessors
+    # ------------------------------------------------------------------
+
+    def get_host(self) -> str:
+        """Return the host IP to connect to MockServer from the test process."""
+        return self.get_container_host_ip()
+
+    def get_port(self) -> int:
+        """Return the mapped host port for MockServer's container port."""
+        return int(self.get_exposed_port(self._port))
+
+    def get_url(self) -> str:
+        """Return the HTTP base URL for MockServer (e.g. ``http://localhost:49152``)."""
+        return f"http://{self.get_host()}:{self.get_port()}"
+
+    def get_secure_url(self) -> str:
+        """Return the HTTPS base URL for MockServer (same port, different scheme)."""
+        return f"https://{self.get_host()}:{self.get_port()}"
+
+    # ------------------------------------------------------------------
+    # Configuration helpers (fluent)
+    # ------------------------------------------------------------------
+
+    def with_server_port(self, port: int) -> "MockServerContainer":
+        """Override the MockServer listen port inside the container.
+
+        This replaces the exposed port so the wait strategy targets the correct port.
+        """
+        self._port = port
+        # Reset exposed ports to only the new port
+        self.ports = {}
+        self.with_exposed_ports(port)
+        self.with_env("SERVER_PORT", str(port))
+        return self
+
+    def with_log_level(self, level: str) -> "MockServerContainer":
+        """Set the MockServer log level (e.g. INFO, DEBUG, WARN, ERROR, TRACE)."""
+        self.with_env("MOCKSERVER_LOG_LEVEL", level)
+        return self
+
+    def with_property(self, key: str, value: str) -> "MockServerContainer":
+        """Set a MockServer configuration property as an environment variable.
+
+        The key must be in MockServer env-var form (e.g. ``MOCKSERVER_LOG_LEVEL``).
+        """
+        self.with_env(key, value)
+        return self
+
+    def with_initialization_json(self, container_path: str) -> "MockServerContainer":
+        """Configure MockServer to load expectations from a JSON file at startup.
+
+        The file must already be mounted/copied into the container at *container_path*.
+        This sets the ``MOCKSERVER_INITIALIZATION_JSON_PATH`` environment variable.
+        """
+        self.with_env("MOCKSERVER_INITIALIZATION_JSON_PATH", container_path)
+        return self

testcontainers_mockserver-7.1.0/src/testcontainers_mockserver.egg-info/PKG-INFO

@@ -0,0 +1,101 @@
+Metadata-Version: 2.4
+Name: testcontainers-mockserver
+Version: 7.1.0
+Summary: Testcontainers module for MockServer
+Author-email: James D Bloom <jamesdbloom@gmail.com>
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://www.mock-server.com
+Project-URL: Repository, https://github.com/mock-server/mockserver
+Project-URL: Documentation, https://www.mock-server.com/mock_server/mockserver_testcontainers.html
+Keywords: testing,docker,mockserver,testcontainers,mocking
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: testcontainers>=4.0.0
+Provides-Extra: test
+Requires-Dist: pytest>=7.0; extra == "test"
+Requires-Dist: requests>=2.20; extra == "test"
+
+# testcontainers-mockserver
+
+A [Testcontainers](https://testcontainers.com) module for [MockServer](https://www.mock-server.com) in Python.
+
+Starts a `mockserver/mockserver` Docker container, waits for readiness, and provides
+convenient accessors for the mapped host, port, and URL.
+
+## Installation
+
+```bash
+pip install testcontainers-mockserver
+```
+
+## Usage
+
+```python
+from testcontainers_mockserver import MockServerContainer
+import requests
+
+with MockServerContainer() as mockserver:
+    url = mockserver.get_url()  # e.g. "http://localhost:49152"
+
+    # Create an expectation
+    requests.put(f"{url}/mockserver/expectation", json={
+        "httpRequest": {"method": "GET", "path": "/hello"},
+        "httpResponse": {"statusCode": 200, "body": "world"},
+    })
+
+    # Match it
+    resp = requests.get(f"{url}/hello")
+    assert resp.text == "world"
+```
+
+## API
+
+### `MockServerContainer(image=..., port=1080)`
+
+- `image` — Docker image to use. Defaults to `mockserver/mockserver:mockserver-7.1.0`.
+- `port` — Container port MockServer listens on. Defaults to `1080`.
+
+### Methods
+
+| Method | Returns | Description |
+|--------|---------|-------------|
+| `get_url()` | `str` | HTTP base URL (e.g. `http://localhost:49152`) |
+| `get_secure_url()` | `str` | HTTPS base URL (same port, `https://` scheme) |
+| `get_host()` | `str` | Mapped host IP |
+| `get_port()` | `int` | Mapped host port |
+| `with_server_port(port)` | `self` | Override the listen port |
+| `with_log_level(level)` | `self` | Set `MOCKSERVER_LOG_LEVEL` |
+| `with_property(key, value)` | `self` | Set any MockServer env var |
+| `with_initialization_json(path)` | `self` | Point to a startup expectations JSON file |
+
+## Building and Testing
+
+```bash
+# Install in editable mode with test dependencies
+pip install -e .[test]
+
+# Run unit tests (no Docker needed)
+pytest tests/test_container_config.py
+
+# Run all tests including integration (requires Docker)
+pytest
+
+# Skip Docker-dependent tests
+pytest -m "not docker"
+```
+
+## Requirements
+
+- Python >= 3.9
+- Docker (for integration tests and actual usage)
+- `testcontainers` >= 4.0.0

testcontainers_mockserver-7.1.0/src/testcontainers_mockserver.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+README.md
+pyproject.toml
+src/testcontainers_mockserver/__init__.py
+src/testcontainers_mockserver/container.py
+src/testcontainers_mockserver.egg-info/PKG-INFO
+src/testcontainers_mockserver.egg-info/SOURCES.txt
+src/testcontainers_mockserver.egg-info/dependency_links.txt
+src/testcontainers_mockserver.egg-info/requires.txt
+src/testcontainers_mockserver.egg-info/top_level.txt
+tests/test_container_config.py
+tests/test_integration.py

testcontainers_mockserver-7.1.0/src/testcontainers_mockserver.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

testcontainers_mockserver-7.1.0/src/testcontainers_mockserver.egg-info/requires.txt

@@ -0,0 +1,5 @@
+testcontainers>=4.0.0
+
+[test]
+pytest>=7.0
+requests>=2.20

testcontainers_mockserver-7.1.0/src/testcontainers_mockserver.egg-info/top_level.txt

@@ -0,0 +1 @@
+testcontainers_mockserver

testcontainers_mockserver-7.1.0/tests/test_container_config.py

@@ -0,0 +1,188 @@
+"""Unit tests for MockServerContainer configuration.
+
+These tests verify container configuration WITHOUT starting Docker.
+They test URL shaping, environment variable setup, and port configuration.
+"""
+
+import pytest
+
+from testcontainers_mockserver import MockServerContainer
+from testcontainers_mockserver.container import MOCKSERVER_PORT, _DEFAULT_TAG, _IMAGE_NAME
+
+
+class TestDefaultConfiguration:
+    """Tests for default container configuration (no Docker needed)."""
+
+    def test_default_image(self):
+        container = MockServerContainer()
+        assert container.image == f"{_IMAGE_NAME}:{_DEFAULT_TAG}"
+
+    def test_default_port_constant(self):
+        assert MOCKSERVER_PORT == 1080
+
+    def test_default_exposes_port_1080(self):
+        container = MockServerContainer()
+        # The ports dict keys are the container ports
+        assert MOCKSERVER_PORT in container.ports
+
+    def test_default_sets_server_port_env(self):
+        container = MockServerContainer()
+        assert container.env["SERVER_PORT"] == "1080"
+
+    def test_custom_image(self):
+        container = MockServerContainer(image="mockserver/mockserver:latest")
+        assert container.image == "mockserver/mockserver:latest"
+
+    def test_custom_port(self):
+        container = MockServerContainer(port=9090)
+        assert 9090 in container.ports
+        assert container.env["SERVER_PORT"] == "9090"
+
+
+class TestWithServerPort:
+    """Tests for with_server_port fluent method."""
+
+    def test_sets_env_and_port(self):
+        container = MockServerContainer()
+        result = container.with_server_port(9090)
+
+        assert result is container  # fluent return
+        assert container.env["SERVER_PORT"] == "9090"
+        assert 9090 in container.ports
+
+    def test_replaces_default_port(self):
+        container = MockServerContainer()
+        container.with_server_port(9090)
+
+        # Default port 1080 should no longer be exposed
+        assert MOCKSERVER_PORT not in container.ports
+        assert 9090 in container.ports
+
+
+class TestWithLogLevel:
+    """Tests for with_log_level fluent method."""
+
+    def test_sets_log_level_env(self):
+        container = MockServerContainer()
+        result = container.with_log_level("DEBUG")
+
+        assert result is container
+        assert container.env["MOCKSERVER_LOG_LEVEL"] == "DEBUG"
+
+
+class TestWithProperty:
+    """Tests for with_property fluent method."""
+
+    def test_sets_arbitrary_env(self):
+        container = MockServerContainer()
+        result = container.with_property("MOCKSERVER_MAX_EXPECTATIONS", "500")
+
+        assert result is container
+        assert container.env["MOCKSERVER_MAX_EXPECTATIONS"] == "500"
+
+
+class TestWithInitializationJson:
+    """Tests for with_initialization_json fluent method."""
+
+    def test_sets_initialization_json_path_env(self):
+        container = MockServerContainer()
+        result = container.with_initialization_json("/config/init.json")
+
+        assert result is container
+        assert container.env["MOCKSERVER_INITIALIZATION_JSON_PATH"] == "/config/init.json"
+
+
+class TestFluentChaining:
+    """Tests for method chaining across multiple fluent helpers."""
+
+    def test_chain_multiple_methods(self):
+        container = MockServerContainer()
+        result = (
+            container
+            .with_log_level("WARN")
+            .with_server_port(8080)
+            .with_property("MOCKSERVER_MAX_EXPECTATIONS", "100")
+        )
+
+        assert result is container
+        assert container.env["MOCKSERVER_LOG_LEVEL"] == "WARN"
+        assert container.env["SERVER_PORT"] == "8080"
+        assert container.env["MOCKSERVER_MAX_EXPECTATIONS"] == "100"
+        assert 8080 in container.ports
+
+
+class TestUrlShaping:
+    """Tests for URL/host/port accessors.
+
+    These test the URL construction logic by mocking the underlying testcontainers
+    methods that require a running container.
+    """
+
+    def test_get_url_format(self):
+        """Verify get_url produces the correct format when host and port are known."""
+        container = MockServerContainer()
+        # Monkey-patch the methods that need Docker
+        container.get_container_host_ip = lambda: "127.0.0.1"
+        container.get_exposed_port = lambda port: 49152
+
+        url = container.get_url()
+        assert url == "http://127.0.0.1:49152"
+
+    def test_get_secure_url_format(self):
+        """Verify get_secure_url uses https scheme."""
+        container = MockServerContainer()
+        container.get_container_host_ip = lambda: "localhost"
+        container.get_exposed_port = lambda port: 55000
+
+        url = container.get_secure_url()
+        assert url == "https://localhost:55000"
+
+    def test_get_host_delegates(self):
+        """Verify get_host delegates to get_container_host_ip."""
+        container = MockServerContainer()
+        container.get_container_host_ip = lambda: "192.168.1.100"
+
+        assert container.get_host() == "192.168.1.100"
+
+    def test_get_port_delegates(self):
+        """Verify get_port delegates to get_exposed_port with the configured port."""
+        container = MockServerContainer()
+        container.get_exposed_port = lambda port: 32768
+
+        assert container.get_port() == 32768
+
+    def test_get_port_respects_custom_port(self):
+        """Verify get_port uses the custom server port when configured."""
+        container = MockServerContainer(port=9090)
+
+        called_with = []
+        container.get_exposed_port = lambda port: (called_with.append(port), 32768)[1]
+
+        container.get_port()
+        assert called_with == [9090]
+
+    def test_get_url_with_custom_port(self):
+        """Verify get_url works correctly after with_server_port."""
+        container = MockServerContainer()
+        container.with_server_port(9090)
+        container.get_container_host_ip = lambda: "localhost"
+
+        called_with = []
+        container.get_exposed_port = lambda port: (called_with.append(port), 45000)[1]
+
+        url = container.get_url()
+        assert url == "http://localhost:45000"
+        assert called_with == [9090]
+
+
+class TestVersionPinning:
+    """Tests that verify the version is correctly pinned."""
+
+    def test_default_tag_matches_release_version(self):
+        """The default tag must match the current MockServer release."""
+        assert _DEFAULT_TAG == "mockserver-7.0.0"
+
+    def test_module_version(self):
+        """The package version must match the MockServer release."""
+        import testcontainers_mockserver
+        assert testcontainers_mockserver.__version__ == "7.0.0"

testcontainers_mockserver-7.1.0/tests/test_integration.py

@@ -0,0 +1,105 @@
+"""Integration tests for MockServerContainer.
+
+These tests require a running Docker daemon. They are skipped when Docker is
+unavailable, mirroring the Java repo's assumeTrue(isDockerAvailable()) convention.
+"""
+
+import pytest
+
+docker_available = False
+try:
+    import docker
+
+    client = docker.from_env()
+    client.ping()
+    docker_available = True
+except Exception:
+    pass
+
+pytestmark = pytest.mark.docker
+
+
+@pytest.fixture(scope="module")
+def mockserver():
+    """Start a MockServer container for the module's integration tests."""
+    if not docker_available:
+        pytest.skip("Docker is not available")
+
+    from testcontainers_mockserver import MockServerContainer
+
+    with MockServerContainer() as container:
+        yield container
+
+
+def test_container_starts_and_is_reachable(mockserver):
+    """Verify the container starts and the /mockserver/status endpoint responds."""
+    import requests
+
+    url = mockserver.get_url()
+    assert url.startswith("http://")
+
+    # MockServer's status endpoint is PUT-only
+    response = requests.put(f"{url}/mockserver/status")
+    assert response.status_code == 200
+
+    body = response.json()
+    assert "ports" in body
+
+
+def test_get_host_returns_non_empty(mockserver):
+    """Verify get_host returns a non-empty string."""
+    host = mockserver.get_host()
+    assert host
+    assert isinstance(host, str)
+
+
+def test_get_port_returns_positive_int(mockserver):
+    """Verify get_port returns a positive integer."""
+    port = mockserver.get_port()
+    assert isinstance(port, int)
+    assert port > 0
+
+
+def test_expectation_lifecycle(mockserver):
+    """Verify a basic create-expectation/match/verify lifecycle."""
+    import json
+
+    import requests
+
+    url = mockserver.get_url()
+
+    # Create an expectation
+    expectation = {
+        "httpRequest": {
+            "method": "GET",
+            "path": "/hello",
+        },
+        "httpResponse": {
+            "statusCode": 200,
+            "body": "world",
+        },
+    }
+    resp = requests.put(f"{url}/mockserver/expectation", json=expectation)
+    assert resp.status_code == 201
+
+    # Match the expectation
+    resp = requests.get(f"{url}/hello")
+    assert resp.status_code == 200
+    assert resp.text == "world"
+
+    # Verify the request was received
+    verify_body = {
+        "httpRequest": {
+            "method": "GET",
+            "path": "/hello",
+        },
+        "times": {
+            "atLeast": 1,
+        },
+    }
+    resp = requests.put(f"{url}/mockserver/verify", json=verify_body)
+    assert resp.status_code == 202
+
+    # Reset
+    resp = requests.put(f"{url}/mockserver/reset")
+    assert resp.status_code == 200