Add more tests and exposed_ports

Author: surister

modules/cratedb/README.rst

@@ -0,0 +1,2 @@
+.. autoclass:: testcontainers.cratedb.CrateDBContainer
+.. title:: testcontainers.cratedb.CrateDBContainer

modules/cratedb/example_basic.py

@@ -0,0 +1,9 @@
+import sqlalchemy
+
+from testcontainers import cratedb
+
+with cratedb.CrateDBContainer("crate:latest", ports={4200: None, 5432: None}) as container:
+    engine = sqlalchemy.create_engine(container.get_connection_url())
+    with engine.begin() as conn:
+        result = conn.execute(sqlalchemy.text("select version()"))
+        version = result.fetchone()

modules/cratedb/testcontainers/cratedb/__init__.py

@@ -33,24 +33,19 @@ class CrateDBContainer(DockerContainer):
 
         .. doctest::
 
-            >>> from cratedb_toolkit.testing.testcontainers.cratedb import CrateDBContainer
+            >>> from testcontainers import cratedb import CrateDBContainer
             >>> import sqlalchemy
 
-            >>> cratedb_container = CrateDBContainer("crate:5.2.3")
-            >>> cratedb_container.start()
-            >>> with cratedb_container as cratedb:
+            >>> cratedb_container =
+            >>> with CrateDBContainer("crate:6.0") as cratedb:
             ...     engine = sqlalchemy.create_engine(cratedb.get_connection_url())
             ...     with engine.begin() as connection:
             ...         result = connection.execute(sqlalchemy.text("select version()"))
             ...         version, = result.fetchone()
             >>> version
-            'CrateDB 5.2.3...'
+            'CrateDB 6.0.2..'
     """
 
-    CRATEDB_USER = os.environ.get("CRATEDB_USER", "crate")
-    CRATEDB_PASSWORD = os.environ.get("CRATEDB_PASSWORD", "crate")
-    CRATEDB_DB = os.environ.get("CRATEDB_DB", "doc")
-    KEEPALIVE = asbool(os.environ.get("CRATEDB_KEEPALIVE", os.environ.get("TC_KEEPALIVE", False)))
     CMD_OPTS: t.ClassVar[dict[str, str]] = {
         "discovery.type": "single-node",
         "node.attr.storage": "hot",
@@ -82,21 +77,30 @@ def __init__(
         :param kwargs: misc keyword arguments
         """
         super().__init__(image=image, **kwargs)
-
-        self._name = "testcontainers-cratedb"
-
         cmd_opts = cmd_opts or {}
         self._command = self._build_cmd({**self.CMD_OPTS, **cmd_opts})
 
-        self.CRATEDB_USER = user or self.CRATEDB_USER
-        self.CRATEDB_PASSWORD = password or self.CRATEDB_PASSWORD
-        self.CRATEDB_DB = dbname or self.CRATEDB_DB
+        self.CRATEDB_USER = user or os.environ.get("CRATEDB_USER", "crate")
+        self.CRATEDB_PASSWORD = password or os.environ.get("CRATEDB_PASSWORD", "crate")
+        self.CRATEDB_DB = dbname or os.environ.get("CRATEDB_DB", "doc")
 
         self.port_mapping = ports if ports else {4200: None}
-        self.port_to_expose, _ = next(iter(self.port_mapping.items()))
+        self.port_to_expose = next(iter(self.port_mapping.items()))
 
         self.waiting_for(HttpWaitStrategy(4200).for_status_code(200).with_startup_timeout(5))
 
+    def exposed_ports(self) -> dict[int, int]:
+        """Returns a dictionary with the ports that are currently exposed in the container.
+
+        Contrary to the '--port' parameter used in docker cli, this returns {internal_port: external_port}
+
+            Examples:
+                {4200: 19382}
+
+            :returns: The exposed ports.
+        """
+        return {port: self.get_exposed_port(port) for port in self.ports}
+
     @staticmethod
     def _build_cmd(opts: dict) -> str:
         """
@@ -127,21 +131,21 @@ def _configure(self) -> None:
         self._configure_credentials()
 
     def get_connection_url(self, dialect: str = "crate", host: t.Optional[str] = None) -> str:
+        # We should remove this method once the new DBContainer generic gets added to the library.
         """
         Return a connection URL to the DB
 
         :param host: optional string
         :param dialect: a string with the dialect name to generate a DB URI
         :return: string containing a connection URL to te DB
         """
-        # TODO: When using `db_name=self.CRATEDB_DB`:
-        #       Connection.__init__() got an unexpected keyword argument 'database'
         return self._create_connection_url(
             dialect=dialect,
             username=self.CRATEDB_USER,
             password=self.CRATEDB_PASSWORD,
             host=host,
-            port=self.port_to_expose,
+            port=self.port_to_expose[0],
+            dbname=self.CRATEDB_DB,
         )
 
     def _create_connection_url(
@@ -156,12 +160,16 @@ def _create_connection_url(
     ) -> str:
         if raise_for_deprecated_parameter(kwargs, "db_name", "dbname"):
             raise ValueError(f"Unexpected arguments: {','.join(kwargs)}")
+
         if self._container is None:
             raise ContainerStartException("container has not been started")
+
         host = host or self.get_container_host_ip()
         assert port is not None
+
         port = self.get_exposed_port(port)
         quoted_password = quote(password, safe=" +")
+
         url = f"{dialect}://{username}:{quoted_password}@{host}:{port}"
         if dbname:
             url = f"{url}/{dbname}"

modules/cratedb/tests/test_cratedb.py

@@ -1,10 +1,14 @@
+import urllib.parse
+import os
+
 import sqlalchemy
 import pytest
+
 from testcontainers.cratedb import CrateDBContainer
 
 
 @pytest.mark.parametrize("version", ["5.9", "5.10", "6.0", "latest"])
-def test_docker_run_cratedb(version: str):
+def test_docker_run_cratedb_versions(version: str):
     with CrateDBContainer(f"crate:{version}") as container:
         engine = sqlalchemy.create_engine(container.get_connection_url())
         with engine.begin() as conn:
@@ -13,6 +17,49 @@ def test_docker_run_cratedb(version: str):
             assert sum_result == 15
 
 
+@pytest.mark.parametrize(
+    "ports, expected",
+    [
+        ({5432: None, 4200: None}, False),
+        ({5432: 5432, 4200: 4200}, {5432: 5432, 4200: 4200}),
+    ],
+)
+def test_docker_run_cratedb_ports(ports, expected):
+    with CrateDBContainer("crate:latest", ports=ports) as container:
+        exposed_ports = container.exposed_ports()
+        assert len(exposed_ports) == 2
+        assert all(map(lambda port: isinstance(port, int), exposed_ports))
+        if expected:
+            assert exposed_ports == expected
+
+
+def test_docker_run_cratedb_credentials():
+    expected_user, expected_password, expected_db, expected_port = "user1", "pass1", "host1", 4200
+    expected_default_dialect, expected_default_host = "crate", "localhost"
+    expected_defined_dialect, expected_defined_host = "somedialect", "somehost"
+    os.environ["CRATEDB_USER"], os.environ["CRATEDB_PASSWORD"] = expected_user, expected_password
+    os.environ["CRATEDB_DB"] = expected_db
+
+    with CrateDBContainer("crate:latest", ports={4200: expected_port}) as container:
+        url = urllib.parse.urlparse(container.get_connection_url())
+        user, password = url.netloc.split("@")[0].split(":")
+        host, port = url.netloc.split("@")[1].split(":")
+        assert user == expected_user
+        assert password == expected_password
+        assert url.scheme == expected_default_dialect
+        assert host == expected_default_host
+        assert int(port) == expected_port
+        assert url.path.replace("/", "") == expected_db
+
+        url = urllib.parse.urlparse(
+            container.get_connection_url(dialect=expected_defined_dialect, host=expected_defined_host)
+        )
+        host, _ = url.netloc.split("@")[1].split(":")
+
+        assert url.scheme == expected_defined_dialect
+        assert host == expected_defined_host
+
+
 @pytest.mark.parametrize(
     "opts, expected",
     [