Merge branch 'main' into add-toxiproxy-support-to-test-containers

Author: jarlah

.github/workflows/elixir.yml

@@ -51,7 +51,7 @@ jobs:
     - name: Install dependencies
       run: mix deps.get
     - name: Run tests
-      run: MIX_ENV=test mix citest
+      run: mix citest
     - name: Verify version
       run: |
         mix run -e "if(Testcontainers.Constants.library_version() == Mix.Project.config()[:version], do: IO.puts("OK"), else: System.halt(\"version mismatch\"))"

lib/container.ex

@@ -92,18 +92,30 @@ defmodule Testcontainers.Container do
   Adds a _port_ to be exposed on the _container_.
   """
   def with_exposed_port(%__MODULE__{} = config, port) when is_integer(port) do
-    filtered_ports = config.exposed_ports |> Enum.reject(fn p -> p == port end)
+    filtered_ports =
+      config.exposed_ports
+      |> Enum.reject(fn
+        {p, _} -> p == port
+        p -> p == port
+      end)
 
-    %__MODULE__{config | exposed_ports: [port | filtered_ports]}
+    %__MODULE__{config | exposed_ports: [{port, nil} | filtered_ports]}
   end
 
   @doc """
   Adds multiple _ports_ to be exposed on the _container_.
   """
   def with_exposed_ports(%__MODULE__{} = config, ports) when is_list(ports) do
-    filtered_ports = config.exposed_ports |> Enum.reject(fn port -> port in ports end)
+    filtered_ports =
+      config.exposed_ports
+      |> Enum.reject(fn
+        {p, _} -> p in ports
+        p -> p in ports
+      end)
 
-    %__MODULE__{config | exposed_ports: ports ++ filtered_ports}
+    new_ports = Enum.map(ports, fn port -> {port, nil} end)
+
+    %__MODULE__{config | exposed_ports: new_ports ++ filtered_ports}
   end
 
   @doc """
@@ -172,6 +184,16 @@ defmodule Testcontainers.Container do
     %__MODULE__{config | auto_remove: auto_remove}
   end
 
+  @doc """
+  Sets whether the container should run in privileged mode.
+
+  Required for containers that need access to the Docker/Podman socket
+  when running under SELinux (e.g., Ryuk on Podman).
+  """
+  def with_privileged(%__MODULE__{} = config, privileged) when is_boolean(privileged) do
+    %__MODULE__{config | privileged: privileged}
+  end
+
   @doc """
   Sets whether the container should be reused if it is already running.
   """
@@ -264,13 +286,10 @@ defmodule Testcontainers.Container do
   """
   def mapped_port(%__MODULE__{} = container, port) when is_number(port) do
     container.exposed_ports
-    |> Enum.filter(fn
-      {exposed_port, _} -> exposed_port == port
-      port -> port == port
+    |> Enum.find_value(nil, fn
+      {^port, host_port} -> host_port
+      _ -> nil
     end)
-    |> List.first({})
-    |> Tuple.to_list()
-    |> List.last()
   end
 
   @doc """

lib/docker/api.ex

@@ -301,7 +301,6 @@ defmodule Testcontainers.Docker.Api do
     container_config.exposed_ports
     |> Enum.map(fn
       {container_port, _host_port} -> {container_port, %{}}
-      port -> {port, %{}}
     end)
     |> Enum.into(%{})
   end
@@ -314,11 +313,11 @@ defmodule Testcontainers.Docker.Api do
   defp map_port_bindings(%Container{} = container_config) do
     container_config.exposed_ports
     |> Enum.map(fn
+      {container_port, host_port} when is_nil(host_port) ->
+        {container_port, [%{"HostIp" => "0.0.0.0", "HostPort" => ""}]}
+
       {container_port, host_port} ->
         {container_port, [%{"HostIp" => "0.0.0.0", "HostPort" => to_string(host_port)}]}
-
-      port ->
-        {port, [%{"HostIp" => "0.0.0.0", "HostPort" => ""}]}
     end)
     |> Enum.into(%{})
   end

lib/testcontainers.ex

@@ -50,24 +50,29 @@ defmodule Testcontainers do
   defp setup(options) do
     {conn, docker_host_url, docker_host} = Connection.get_connection(options)
 
+    # Read properties first so we can configure Ryuk appropriately
+    {:ok, properties} = PropertiesParser.read_property_sources()
+
     session_id =
       :crypto.hash(:sha, "#{inspect(self())}#{DateTime.utc_now() |> DateTime.to_string()}")
       |> Base.encode16()
 
+    ryuk_privileged = Map.get(properties, "ryuk.container.privileged", "false") == "true"
+
     ryuk_config =
       Container.new("testcontainers/ryuk:#{Constants.ryuk_version()}")
       |> Container.with_exposed_port(8080)
       |> then(&apply_docker_socket_volume_binding(&1, docker_host))
       |> Container.with_auto_remove(true)
+      |> Container.with_privileged(ryuk_privileged)
 
     with {:ok, _} <- Api.pull_image(ryuk_config.image, conn),
          {:ok, docker_hostname} <- get_docker_hostname(docker_host_url, conn),
          {:ok, ryuk_container_id} <- Api.create_container(ryuk_config, conn),
          :ok <- Api.start_container(ryuk_container_id, conn),
          {:ok, container} <- Api.get_container(ryuk_container_id, conn),
          {:ok, socket} <- create_ryuk_socket(container, docker_hostname),
-         :ok <- register_ryuk_filter(session_id, socket),
-         {:ok, properties} <- PropertiesParser.read_property_file() do
+         :ok <- register_ryuk_filter(session_id, socket) do
       Logger.info("Testcontainers initialized")
 
       {:ok,

lib/util/properties.ex

@@ -1,9 +1,11 @@
 defmodule Testcontainers.Util.PropertiesParser do
   @moduledoc false
 
-  @file_path "~/.testcontainers.properties"
+  @user_file "~/.testcontainers.properties"
+  @project_file ".testcontainers.properties"
+  @env_prefix "TESTCONTAINERS_"
 
-  def read_property_file(file_path \\ @file_path) do
+  def read_property_file(file_path \\ @user_file) do
     if File.exists?(Path.expand(file_path)) do
       with {:ok, content} <- File.read(Path.expand(file_path)),
            properties <- parse_properties(content) do
@@ -18,6 +20,78 @@ defmodule Testcontainers.Util.PropertiesParser do
     end
   end
 
+  @doc """
+  Reads properties from all sources with proper precedence.
+
+  Configuration is read from three sources with the following precedence
+  (highest to lowest):
+
+  1. Environment variables (TESTCONTAINERS_* prefix)
+  2. User file (~/.testcontainers.properties)
+  3. Project file (.testcontainers.properties)
+
+  Environment variables are converted from TESTCONTAINERS_PROPERTY_NAME format
+  to property.name format (uppercase to lowercase, underscores to dots, prefix removed).
+
+  ## Options
+
+  - `:user_file` - path to user properties file (default: ~/.testcontainers.properties)
+  - `:project_file` - path to project properties file (default: .testcontainers.properties)
+  - `:env_prefix` - environment variable prefix (default: TESTCONTAINERS_)
+
+  ## Returns
+
+  - `{:ok, map}` with merged properties.
+  """
+  def read_property_sources(opts \\ []) do
+    user_file = Keyword.get(opts, :user_file, @user_file)
+    project_file = Keyword.get(opts, :project_file, @project_file)
+    env_prefix = Keyword.get(opts, :env_prefix, @env_prefix)
+
+    project_props = read_file_silent(project_file)
+    user_props = read_file_silent(user_file)
+    env_props = read_env_vars(env_prefix)
+
+    # Merge in order of lowest to highest precedence
+    merged =
+      project_props
+      |> Map.merge(user_props)
+      |> Map.merge(env_props)
+
+    {:ok, merged}
+  end
+
+  defp read_file_silent(file_path) do
+    expanded = Path.expand(file_path)
+
+    if File.exists?(expanded) do
+      case File.read(expanded) do
+        {:ok, content} -> parse_properties(content)
+        {:error, _} -> %{}
+      end
+    else
+      %{}
+    end
+  end
+
+  defp read_env_vars(prefix) do
+    System.get_env()
+    |> Enum.filter(fn {key, _value} -> String.starts_with?(key, prefix) end)
+    |> Enum.map(&env_to_property(&1, prefix))
+    |> Map.new()
+  end
+
+  # Converts TESTCONTAINERS_RYUK_CONTAINER_PRIVILEGED to ryuk.container.privileged
+  defp env_to_property({key, value}, prefix) do
+    property_key =
+      key
+      |> String.replace_prefix(prefix, "")
+      |> String.downcase()
+      |> String.replace("_", ".")
+
+    {property_key, value}
+  end
+
   defp parse_properties(content) do
     content
     |> String.split("\n")

mix.exs

@@ -23,6 +23,11 @@ defmodule TestcontainersElixir.MixProject do
         links: %{"GitHub" => @source_url},
         licenses: ["MIT"]
       ],
+      preferred_cli_env: [
+        test: :test,
+        citest: :test,
+        "testcontainers.test": :test
+      ],
       test_coverage: [
         summary: [threshold: 50],
         ignore_modules: [
@@ -34,8 +39,8 @@ defmodule TestcontainersElixir.MixProject do
     ]
   end
 
-  defp elixirc_paths(:test), do: ["lib", "docker_engine_api", "test/support"]
-  defp elixirc_paths(_), do: ["lib", "docker_engine_api"]
+  defp elixirc_paths(:prod), do: ["lib", "docker_engine_api"]
+  defp elixirc_paths(_),     do: ["lib", "test/support", "docker_engine_api"]
 
   def application do
     [

test/container_test.exs

@@ -21,10 +21,10 @@ defmodule Testcontainers.ContainerTest do
       container2 = ContainerBuilder.build(Testcontainers.PostgresContainer.new())
 
       assert Testcontainers.Util.Hash.struct_to_hash(container1) ==
-               "2ac8f31c61b760b17176a9b9e51bd9d969eb26adadc9bf3db4cdcac69cfb065f"
+               "082851e217cae88e1684169a9759a6d702d012016054c14b23d192f7e2559c63"
 
       assert Testcontainers.Util.Hash.struct_to_hash(container2) ==
-               "2ac8f31c61b760b17176a9b9e51bd9d969eb26adadc9bf3db4cdcac69cfb065f"
+               "082851e217cae88e1684169a9759a6d702d012016054c14b23d192f7e2559c63"
     end
   end
 
@@ -34,7 +34,7 @@ defmodule Testcontainers.ContainerTest do
         Container.new("my-image")
         |> Container.with_exposed_port(80)
 
-      assert container.exposed_ports == [80]
+      assert container.exposed_ports == [{80, nil}]
     end
 
     test "removes duplicate exposed ports" do
@@ -43,7 +43,7 @@ defmodule Testcontainers.ContainerTest do
         |> Container.with_exposed_port(80)
         |> Container.with_exposed_port(80)
 
-      assert container.exposed_ports == [80]
+      assert container.exposed_ports == [{80, nil}]
     end
   end
 
@@ -53,7 +53,7 @@ defmodule Testcontainers.ContainerTest do
         Container.new("my-image")
         |> Container.with_exposed_ports([80, 443])
 
-      assert container.exposed_ports == [80, 443]
+      assert container.exposed_ports == [{80, nil}, {443, nil}]
     end
 
     test "removes duplicate exposed ports" do
@@ -62,7 +62,7 @@ defmodule Testcontainers.ContainerTest do
         |> Container.with_exposed_ports([80, 443])
         |> Container.with_exposed_ports([80])
 
-      assert container.exposed_ports == [80, 443]
+      assert container.exposed_ports == [{80, nil}, {443, nil}]
     end
   end
 
@@ -96,6 +96,11 @@ defmodule Testcontainers.ContainerTest do
       container = Container.new("my-image")
       assert Container.mapped_port(container, 80) == nil
     end
+
+    test "returns nil (and does not crash) if the exposed port is present but not mapped (integer)" do
+      container = Container.new("my-image") |> Container.with_exposed_port(80)
+      assert Container.mapped_port(container, 80) == nil
+    end
   end
 
   describe "with_network_mode/2" do
@@ -205,4 +210,24 @@ defmodule Testcontainers.ContainerTest do
                    end
     end
   end
+
+  describe "with_privileged/2" do
+    test "sets privileged to true" do
+      container = Container.new("my-image")
+      assert container.privileged == false
+
+      updated_container = Container.with_privileged(container, true)
+
+      assert updated_container.privileged == true
+    end
+
+    test "sets privileged to false" do
+      container =
+        Container.new("my-image")
+        |> Container.with_privileged(true)
+        |> Container.with_privileged(false)
+
+      assert container.privileged == false
+    end
+  end
 end

test/test_helper.exs

@@ -1,7 +1,3 @@
 Testcontainers.start_link()
 
 ExUnit.start()
-
-# Application.put_env(:tesla, DockerEngineAPI.Connection,
-#   middleware: [{Tesla.Middleware.Logger, log_level: :info}]
-# )