Merge branch 'main' into enhanced-wait-strategies-v2

Author: alexanderankin

core/testcontainers/compose/compose.py

@@ -173,7 +173,7 @@ class DockerCompose:
             Wait for the services to be healthy
             (as per healthcheck definitions in the docker compose configuration)
         env_file:
-            Path to an '.env' file containing environment variables
+            Path(s) to an '.env' file containing environment variables
             to pass to docker compose.
         services:
             The list of services to use from this DockerCompose.
@@ -210,7 +210,7 @@ class DockerCompose:
     build: bool = False
     wait: bool = True
     keep_volumes: bool = False
-    env_file: Optional[str] = None
+    env_file: Optional[Union[str, list[str]]] = None
     services: Optional[list[str]] = None
     docker_command_path: Optional[str] = None
     profiles: Optional[list[str]] = None
@@ -219,6 +219,8 @@ class DockerCompose:
     def __post_init__(self) -> None:
         if isinstance(self.compose_file_name, str):
             self.compose_file_name = [self.compose_file_name]
+        if isinstance(self.env_file, str):
+            self.env_file = [self.env_file]
 
     def __enter__(self) -> "DockerCompose":
         self.start()
@@ -247,7 +249,8 @@ def compose_command_property(self) -> list[str]:
         if self.profiles:
             docker_compose_cmd += [item for profile in self.profiles for item in ["--profile", profile]]
         if self.env_file:
-            docker_compose_cmd += ["--env-file", self.env_file]
+            for env_file in self.env_file:
+                docker_compose_cmd += ["--env-file", env_file]
         return docker_compose_cmd
 
     def waiting_for(self, strategies: dict[str, WaitStrategy]) -> "DockerCompose":

core/testcontainers/core/config.py

@@ -11,6 +11,8 @@
 
 import docker
 
+ENABLE_FLAGS = ("yes", "true", "t", "y", "1")
+
 
 class ConnectionMode(Enum):
     bridge_ip = "bridge_ip"
@@ -45,16 +47,6 @@ def get_docker_socket() -> str:
         return "/var/run/docker.sock"
 
 
-def get_bool_env(name: str) -> bool:
-    """
-    Get environment variable named `name` and convert it to bool.
-
-    Defaults to False.
-    """
-    value = environ.get(name, "")
-    return value.lower() in ("yes", "true", "t", "y", "1")
-
-
 TC_FILE = ".testcontainers.properties"
 TC_GLOBAL = Path.home() / TC_FILE
 
@@ -96,11 +88,20 @@ def read_tc_properties() -> dict[str, str]:
 
 @dataclass
 class TestcontainersConfiguration:
+    def _render_bool(self, env_name: str, prop_name: str) -> bool:
+        env_val = environ.get(env_name, None)
+        if env_val is not None:
+            return env_val.lower() in ENABLE_FLAGS
+        prop_val = self.tc_properties.get(prop_name, None)
+        if prop_val is not None:
+            return prop_val.lower() in ENABLE_FLAGS
+        return False
+
     max_tries: int = int(environ.get("TC_MAX_TRIES", "120"))
-    sleep_time: int = int(environ.get("TC_POOLING_INTERVAL", "1"))
+    sleep_time: float = float(environ.get("TC_POOLING_INTERVAL", "1"))
     ryuk_image: str = environ.get("RYUK_CONTAINER_IMAGE", "testcontainers/ryuk:0.8.1")
-    ryuk_privileged: bool = get_bool_env("TESTCONTAINERS_RYUK_PRIVILEGED")
-    ryuk_disabled: bool = get_bool_env("TESTCONTAINERS_RYUK_DISABLED")
+    _ryuk_privileged: Optional[bool] = None
+    _ryuk_disabled: Optional[bool] = None
     _ryuk_docker_socket: str = ""
     ryuk_reconnection_timeout: str = environ.get("RYUK_RECONNECTION_TIMEOUT", "10s")
     tc_properties: dict[str, str] = field(default_factory=read_tc_properties)
@@ -130,7 +131,29 @@ def tc_properties_get_tc_host(self) -> Union[str, None]:
         return self.tc_properties.get("tc.host")
 
     @property
-    def timeout(self) -> int:
+    def ryuk_privileged(self) -> bool:
+        if self._ryuk_privileged is not None:
+            return bool(self._ryuk_privileged)
+        self._ryuk_privileged = self._render_bool("TESTCONTAINERS_RYUK_PRIVILEGED", "ryuk.container.privileged")
+        return self._ryuk_privileged
+
+    @ryuk_privileged.setter
+    def ryuk_privileged(self, value: bool) -> None:
+        self._ryuk_privileged = value
+
+    @property
+    def ryuk_disabled(self) -> bool:
+        if self._ryuk_disabled is not None:
+            return bool(self._ryuk_disabled)
+        self._ryuk_disabled = self._render_bool("TESTCONTAINERS_RYUK_DISABLED", "ryuk.disabled")
+        return self._ryuk_disabled
+
+    @ryuk_disabled.setter
+    def ryuk_disabled(self, value: bool) -> None:
+        self._ryuk_disabled = value
+
+    @property
+    def timeout(self) -> float:
         return self.max_tries * self.sleep_time
 
     @property

core/testcontainers/core/container.py

@@ -226,15 +226,17 @@ def get_container_host_ip(self) -> str:
         connection_mode: ConnectionMode
         connection_mode = self.get_docker_client().get_connection_mode()
 
-        # mypy:
-        container = self._container
-        assert container is not None
-
         if connection_mode == ConnectionMode.docker_host:
             return self.get_docker_client().host()
         elif connection_mode == ConnectionMode.gateway_ip:
+            # mypy:
+            container = self._container
+            assert container is not None
             return self.get_docker_client().gateway_ip(container.id)
         elif connection_mode == ConnectionMode.bridge_ip:
+            # mypy:
+            container = self._container
+            assert container is not None
             return self.get_docker_client().bridge_ip(container.id)
         else:
             # ensure that we covered all possible connection_modes

core/testcontainers/core/waiting_utils.py

@@ -73,15 +73,15 @@ class WaitStrategy(ABC):
     """Base class for all wait strategies."""
 
     def __init__(self) -> None:
-        self._startup_timeout: int = config.timeout
+        self._startup_timeout: float = config.timeout
         self._poll_interval: float = config.sleep_time
 
     def with_startup_timeout(self, timeout: Union[int, timedelta]) -> "WaitStrategy":
         """Set the maximum time to wait for the container to be ready."""
         if isinstance(timeout, timedelta):
-            self._startup_timeout = int(timeout.total_seconds())
+            self._startup_timeout = float(int(timeout.total_seconds()))
         else:
-            self._startup_timeout = timeout
+            self._startup_timeout = float(timeout)
         return self
 
     def with_poll_interval(self, interval: Union[float, timedelta]) -> "WaitStrategy":

core/tests/test_config.py

@@ -28,6 +28,68 @@ def test_read_tc_properties(monkeypatch: MonkeyPatch) -> None:
         assert config.tc_properties == {"tc.host": "some_value"}
 
 
+def test_set_tc_properties(monkeypatch: MonkeyPatch) -> None:
+    """
+    Ensure the configuration file variables can be read if no environment variable is set
+    """
+    with tempfile.TemporaryDirectory() as tmpdirname:
+        file = f"{tmpdirname}/{TC_FILE}"
+        with open(file, "w") as f:
+            f.write("ryuk.disabled=true\n")
+            f.write("ryuk.container.privileged=false\n")
+
+        monkeypatch.setattr("testcontainers.core.config.TC_GLOBAL", file)
+
+        config = TCC()
+
+        assert config.ryuk_disabled == True
+        assert config.ryuk_privileged == False
+
+
+def test_override_tc_properties_1(monkeypatch: MonkeyPatch) -> None:
+    """
+    Ensure that we can re-set the configuration variables programattically to override
+    testcontainers.properties
+    """
+    with tempfile.TemporaryDirectory() as tmpdirname:
+        file = f"{tmpdirname}/{TC_FILE}"
+        with open(file, "w") as f:
+            f.write("ryuk.disabled=true\n")
+            f.write("ryuk.container.privileged=false\n")
+
+        monkeypatch.setattr("testcontainers.core.config.TC_GLOBAL", file)
+
+        config = TCC()
+        config.ryuk_disabled = False
+        config.ryuk_privileged = True
+
+        assert config.ryuk_disabled == False
+        assert config.ryuk_privileged == True
+
+
+def test_override_tc_properties_2(monkeypatch: MonkeyPatch) -> None:
+    """
+    Ensure that we can override the testcontainers.properties with environment variables
+    """
+    with tempfile.TemporaryDirectory() as tmpdirname:
+        file = f"{tmpdirname}/{TC_FILE}"
+        with open(file, "w") as f:
+            f.write("ryuk.disabled=true\n")
+            f.write("ryuk.container.privileged=false\n")
+
+        monkeypatch.setattr("testcontainers.core.config.TC_GLOBAL", file)
+
+        import os
+
+        os.environ["TESTCONTAINERS_RYUK_DISABLED"] = "false"
+        os.environ["TESTCONTAINERS_RYUK_PRIVILEGED"] = "true"
+
+        config = TCC()
+
+        assert config.ryuk_disabled == False
+        assert config.ryuk_privileged == True
+
+
 @mark.parametrize("docker_auth_config_env", ["key=value", ""])
 @mark.parametrize("warning_dict", [{}, {"key": "value"}, {"DOCKER_AUTH_CONFIG": "TEST"}])
 @mark.parametrize("warning_dict_post", [{}, {"key": "value"}, {"DOCKER_AUTH_CONFIG": "TEST"}])

modules/azurite/testcontainers/azurite/__init__.py

@@ -10,6 +10,7 @@
 #    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 #    License for the specific language governing permissions and limitations
 #    under the License.
+import enum
 import os
 import socket
 from typing import Optional
@@ -19,6 +20,20 @@
 from testcontainers.core.waiting_utils import wait_container_is_ready
 
 
+class ConnectionStringType(enum.Enum):
+    """
+    Enumeration for specifying the type of connection string to generate for Azurite.
+
+    :cvar LOCALHOST: Represents a connection string for access from the host machine
+                     where the tests are running.
+    :cvar NETWORK: Represents a connection string for access from another container
+                   within the same Docker network as the Azurite container.
+    """
+
+    LOCALHOST = "localhost"
+    NETWORK = "network"
+
+
 class AzuriteContainer(DockerContainer):
     """
     The example below spins up an Azurite container and
@@ -73,7 +88,45 @@ def __init__(
         self.with_exposed_ports(blob_service_port, queue_service_port, table_service_port)
         self.with_env("AZURITE_ACCOUNTS", f"{self.account_name}:{self.account_key}")
 
-    def get_connection_string(self) -> str:
+    def get_connection_string(
+        self, connection_string_type: ConnectionStringType = ConnectionStringType.LOCALHOST
+    ) -> str:
+        """Retrieves the appropriate connection string for the Azurite container based on the specified access type.
+
+        This method acts as a dispatcher, returning a connection string optimized
+        either for access from the host machine or for inter-container communication within the same Docker network.
+
+        :param connection_string_type: The type of connection string to generate.
+                Use :attr:`ConnectionStringType.LOCALHOST` for connections
+                    from the machine running the tests (default), or
+                :attr:`ConnectionStringType.NETWORK` for connections
+                    from other containers within the same Docker network.
+        :type connection_string_type: ConnectionStringType
+        :return: The generated Azurite connection string.
+        :rtype: str
+        :raises ValueError: If an unrecognized `connection_string_type` is provided.
+        """
+        if connection_string_type == ConnectionStringType.LOCALHOST:
+            return self.__get_local_connection_string()
+        elif connection_string_type == ConnectionStringType.NETWORK:
+            return self.__get_external_connection_string()
+        else:
+            raise ValueError(
+                f"unrecognized connection string type {connection_string_type}, "
+                f"Supported values are ConnectionStringType.LOCALHOST or ConnectionStringType.NETWORK "
+            )
+
+    def __get_local_connection_string(self) -> str:
+        """Generates a connection string for Azurite accessible from the local host machine.
+
+        This connection string uses the Docker host IP address (obtained via
+        :meth:`testcontainers.core.container.DockerContainer.get_container_host_ip`)
+        and the dynamically exposed ports of the Azurite container. This ensures that
+        clients running on the host can connect successfully to the Azurite services.
+
+        :return: The Azurite connection string for local host access.
+        :rtype: str
+        """
         host_ip = self.get_container_host_ip()
         connection_string = (
             f"DefaultEndpointsProtocol=http;AccountName={self.account_name};AccountKey={self.account_key};"
@@ -96,6 +149,75 @@ def get_connection_string(self) -> str:
 
         return connection_string
 
+    def __get_external_connection_string(self) -> str:
+        """Generates a connection string for Azurite, primarily optimized for
+        inter-container communication within a custom Docker network.
+
+        This method attempts to provide the most suitable connection string
+        based on the container's network configuration:
+
+        - **For Inter-Container Communication (Recommended):** If the Azurite container is
+          part of a custom Docker network and has network aliases configured,
+          the connection string will use the first network alias as the hostname
+          and the internal container ports (e.g., #$#`http://<alias>:<internal_port>/<account_name>`#$#).
+          This is the most efficient and robust way for other containers
+          in the same network to connect to Azurite, leveraging Docker's internal DNS.
+
+        - **Fallback for Non-Networked/Aliased Scenarios:** If the container is
+          not on a custom network with aliases (e.g., running on the default
+          bridge network without explicit aliases), the method falls back to
+          using the Docker host IP (obtained via
+          :meth:`testcontainers.core.container.DockerContainer.get_container_host_ip`)
+          and the dynamically exposed ports (e.g., #$#`http://<host_ip>:<exposed_port>/<account_name>`#$#).
+          While this connection string is technically "external" to the container,
+          it primarily facilitates connections *from the host machine*.
+
+        :return: The generated Azurite connection string.
+        :rtype: str
+        """
+        # Check if we're on a custom network and have network aliases
+        if hasattr(self, "_network") and self._network and hasattr(self, "_network_aliases") and self._network_aliases:
+            # Use the first network alias for inter-container communication
+            host_ip = self._network_aliases[0]
+            # When using network aliases, use the internal container ports
+            blob_port = self.blob_service_port
+            queue_port = self.queue_service_port
+            table_port = self.table_service_port
+        else:
+            # Use the Docker host IP for external connections
+            host_ip = self.get_container_host_ip()
+            # When using host IP, use the exposed ports
+            blob_port = (
+                self.get_exposed_port(self.blob_service_port)
+                if self.blob_service_port in self.ports
+                else self.blob_service_port
+            )
+            queue_port = (
+                self.get_exposed_port(self.queue_service_port)
+                if self.queue_service_port in self.ports
+                else self.queue_service_port
+            )
+            table_port = (
+                self.get_exposed_port(self.table_service_port)
+                if self.table_service_port in self.ports
+                else self.table_service_port
+            )
+
+        connection_string = (
+            f"DefaultEndpointsProtocol=http;AccountName={self.account_name};AccountKey={self.account_key};"
+        )
+
+        if self.blob_service_port in self.ports:
+            connection_string += f"BlobEndpoint=http://{host_ip}:{blob_port}/{self.account_name};"
+
+        if self.queue_service_port in self.ports:
+            connection_string += f"QueueEndpoint=http://{host_ip}:{queue_port}/{self.account_name};"
+
+        if self.table_service_port in self.ports:
+            connection_string += f"TableEndpoint=http://{host_ip}:{table_port}/{self.account_name};"
+
+        return connection_string
+
     def start(self) -> "AzuriteContainer":
         super().start()
         self._connect()

modules/azurite/tests/samples/network_container/Dockerfile

@@ -0,0 +1,12 @@
+# Use an official Python runtime as a parent image
+FROM python:3.10-slim
+
+# Set the working directory in the container
+WORKDIR /app
+
+RUN pip install azure-storage-blob==12.19.0
+
+COPY ./netowrk_container.py netowrk_container.py
+EXPOSE 80
+# Define the command to run the application
+CMD ["python", "netowrk_container.py"]