iker-python-common 1.0.62__tar.gz → 1.0.63__tar.gz

{iker_python_common-1.0.62 → iker_python_common-1.0.63}/PKG-INFO

@@ -1,13 +1,12 @@
 Metadata-Version: 2.4
 Name: iker-python-common
-Version: 1.0.62
+Version: 1.0.63
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Requires-Python: <3.15,>=3.12
 Requires-Dist: asyncpg>=0.30
-Requires-Dist: docker>=7.1
 Requires-Dist: numpy>=2.3
 Requires-Dist: psycopg>=3.2
 Requires-Dist: pymysql>=1.1

{iker_python_common-1.0.62 → iker_python_common-1.0.63}/pyproject.toml

@@ -9,7 +9,6 @@ build-backend = "setuptools.build_meta"
 [dependency-groups]
 dev = [
     "asyncpg>=0.30",
-    "docker>=7.1",
     "numpy>=2.3",
     "psycopg>=3.2",
     "pymysql>=1.1",
@@ -37,7 +36,6 @@ classifiers = [
 ]
 dependencies = [
     "asyncpg>=0.30",
-    "docker>=7.1",
     "numpy>=2.3",
     "psycopg>=3.2",
     "pymysql>=1.1",

{iker_python_common-1.0.62 → iker_python_common-1.0.63}/src/iker_python_common.egg-info/PKG-INFO

@@ -1,13 +1,12 @@
 Metadata-Version: 2.4
 Name: iker-python-common
-Version: 1.0.62
+Version: 1.0.63
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Requires-Python: <3.15,>=3.12
 Requires-Dist: asyncpg>=0.30
-Requires-Dist: docker>=7.1
 Requires-Dist: numpy>=2.3
 Requires-Dist: psycopg>=3.2
 Requires-Dist: pymysql>=1.1

{iker_python_common-1.0.62 → iker_python_common-1.0.63}/src/iker_python_common.egg-info/SOURCES.txt

@@ -26,7 +26,6 @@ src/iker/common/utils/argutils.py
 src/iker/common/utils/config.py
 src/iker/common/utils/csv.py
 src/iker/common/utils/dbutils.py
-src/iker/common/utils/dockerutils.py
 src/iker/common/utils/dtutils.py
 src/iker/common/utils/funcutils.py
 src/iker/common/utils/jsonutils.py
@@ -48,12 +47,10 @@ src/iker_python_common.egg-info/requires.txt
 src/iker_python_common.egg-info/top_level.txt
 test/iker_test.py
 test/iker_tests/__init__.py
-test/iker_tests/docker_fixtures.py
 test/iker_tests/common/utils/argutils_test.py
 test/iker_tests/common/utils/config_test.py
 test/iker_tests/common/utils/csv_test.py
 test/iker_tests/common/utils/dbutils_test.py
-test/iker_tests/common/utils/dockerutils_test.py
 test/iker_tests/common/utils/dtutils_test.py
 test/iker_tests/common/utils/funcutils_test.py
 test/iker_tests/common/utils/jsonutils_test.py

{iker_python_common-1.0.62 → iker_python_common-1.0.63}/src/iker_python_common.egg-info/requires.txt

@@ -1,5 +1,4 @@
 asyncpg>=0.30
-docker>=7.1
 numpy>=2.3
 psycopg>=3.2
 pymysql>=1.1

iker_python_common-1.0.62/src/iker/common/utils/dockerutils.py

@@ -1,236 +0,0 @@
-import contextlib
-import dataclasses
-import re
-from collections.abc import Generator, Iterator
-from typing import Any
-
-import docker
-import docker.errors
-import docker.models.containers
-import docker.models.images
-import requests.exceptions
-
-from iker.common.utils import logger
-from iker.common.utils.strutils import parse_int_or, trim_to_empty
-
-__all__ = [
-    "ImageName",
-    "docker_create_client",
-    "docker_build_image",
-    "docker_get_image",
-    "docker_pull_image",
-    "docker_fetch_image",
-    "docker_run_detached",
-]
-
-
-@dataclasses.dataclass
-class ImageName(object):
-    registry_host: str | None
-    registry_port: int | None
-    components: list[str]
-    tag: str | None
-
-    @property
-    def registry(self) -> str:
-        if self.registry_host is None and self.registry_port is None:
-            return ""
-        if self.registry_port is None:
-            return self.registry_host
-        return f"{self.registry_host}:{self.registry_port}"
-
-    @property
-    def repository(self) -> str:
-        return "/".join(self.components)
-
-    @staticmethod
-    def parse(s: str):
-
-        # Registry absent version
-        matcher = re.compile(
-            r"^(?P<components>[a-z0-9]+((__?|-+)[a-z0-9]+)*(/[a-z0-9]+((__?|-+)[a-z0-9]+)*)*)(:(?P<tag>\w[\w.-]{0,127}))?$")
-        match = matcher.match(s)
-        if match:
-            return ImageName(registry_host=None,
-                             registry_port=None,
-                             components=trim_to_empty(match.group("components")).split("/"),
-                             tag=match.group("tag"))
-
-        # Registry present version
-        matcher = re.compile(
-            r"^((?P<host>[a-zA-Z0-9.-]+)(:(?P<port>\d+))?/)?(?P<components>[a-z0-9]+((__?|-+)[a-z0-9]+)*(/[a-z0-9]+((__?|-+)[a-z0-9]+)*)*)(:(?P<tag>\w[\w.-]{0,127}))?$")
-        match = matcher.match(s)
-        if match:
-            return ImageName(registry_host=match.group("host"),
-                             registry_port=parse_int_or(match.group("port"), None),
-                             components=trim_to_empty(match.group("components")).split("/"),
-                             tag=match.group("tag"))
-
-        return None
-
-
-def docker_create_client(
-    registry: str,
-    username: str,
-    password: str,
-) -> contextlib.AbstractContextManager[docker.DockerClient]:
-    try:
-        client = docker.DockerClient()
-        client.login(registry=registry, username=username, password=password, reauth=True)
-        return contextlib.closing(client)
-    except docker.errors.APIError:
-        logger.exception("Failed to login Docker server <%s>", registry)
-        raise
-
-
-def docker_build_image(
-    client: docker.DockerClient,
-    tag: str,
-    path: str,
-    dockerfile: str,
-    build_args: dict[str, str],
-) -> tuple[docker.models.images.Image, Iterator[dict[str, str]]]:
-    try:
-        return client.images.build(tag=tag,
-                                   path=path,
-                                   dockerfile=dockerfile,
-                                   buildargs=build_args,
-                                   rm=True,
-                                   forcerm=True,
-                                   nocache=True)
-
-    except docker.errors.BuildError:
-        logger.exception("Failed to build image <%s>", tag)
-        raise
-    except docker.errors.APIError:
-        logger.exception("Docker server returns an error while building image <%s>", tag)
-        raise
-    except Exception:
-        logger.exception("Unexpected error occurred while building image <%s>", tag)
-        raise
-
-
-def docker_get_image(
-    client: docker.DockerClient,
-    image: str,
-) -> docker.models.images.Image:
-    try:
-        return client.images.get(image)
-    except docker.errors.ImageNotFound:
-        logger.exception("Image <%s> is not found from local repository", image)
-        raise
-    except docker.errors.APIError:
-        logger.exception("Docker server returns an error while getting image <%s>", image)
-        raise
-    except Exception:
-        logger.exception("Unexpected error occurred while getting image <%s>", image)
-        raise
-
-
-def docker_pull_image(
-    client: docker.DockerClient,
-    image: str,
-    fallback_local: bool = False,
-) -> docker.models.images.Image:
-    try:
-        return client.images.pull(image)
-    except docker.errors.ImageNotFound:
-        if not fallback_local:
-            logger.exception("Image <%s> is not found from remote repository", image)
-            raise
-        logger.warning("Image <%s> is not found from remote repository, try local repository instead", image)
-    except docker.errors.APIError:
-        if not fallback_local:
-            logger.exception("Docker server returns an error while pulling image <%s>", image)
-            raise
-        logger.warning("Docker server returns an error while pulling image <%s>, try local repository instead", image)
-    except Exception:
-        logger.exception("Unexpected error occurred while pulling image <%s>", image)
-        raise
-
-    return docker_get_image(client, image)
-
-
-def docker_fetch_image(
-    client: docker.DockerClient,
-    image: str,
-    force_pull: bool = False,
-) -> docker.models.images.Image:
-    if force_pull:
-        return docker_pull_image(client, image, fallback_local=True)
-    else:
-        try:
-            return docker_get_image(client, image)
-        except Exception:
-            return docker_pull_image(client, image, fallback_local=False)
-
-
-def docker_run_detached(
-    client: docker.DockerClient,
-    image: str,
-    name: str,
-    command: str | list[str],
-    volumes: dict[str, dict[str, str]],
-    environment: dict[str, str],
-    extra_hosts: dict[str, str],
-    timeout: int,
-    **kwargs,
-) -> tuple[dict[str, Any], Any]:
-    @contextlib.contextmanager
-    def managed_docker_run(
-        client: docker.DockerClient,
-        **kwargs,
-    ) -> Generator[docker.models.containers.Container, None, None]:
-        container_model = None
-        try:
-            container_model = client.containers.run(**kwargs)
-            yield container_model
-        except docker.errors.DockerException:
-            raise
-        finally:
-            if container_model is not None:
-                try:
-                    if container_model.status != "exited":
-                        try:
-                            container_model.stop()
-                        except docker.errors.DockerException:
-                            pass
-                    container_model.wait()
-                    try:
-                        container_model.remove()
-                    except docker.errors.DockerException:
-                        pass
-                except Exception:
-                    raise
-
-    try:
-        run_args = kwargs.copy()
-        run_args.update(dict(image=image,
-                             name=name,
-                             command=command,
-                             volumes=volumes,
-                             environment=environment,
-                             extra_hosts=extra_hosts,
-                             detach=True))
-
-        with managed_docker_run(client, **run_args) as container_model:
-            result = container_model.wait(timeout=timeout)
-            logs = container_model.logs()
-
-            return result, logs
-
-    except requests.exceptions.ReadTimeout:
-        logger.exception("Running container <%s> of image <%s> exceed the timeout", name, image)
-        raise
-    except docker.errors.ImageNotFound:
-        logger.exception("Image <%s> is not found", image)
-        raise
-    except docker.errors.ContainerError:
-        logger.exception("Failed to run container <%s> of image <%s>", name, image)
-        raise
-    except docker.errors.APIError:
-        logger.exception("Docker server returns an error while running container <%s> of image <%s>", name, image)
-        raise
-    except Exception:
-        logger.exception("Unexpected error occurred while running container <%s> of image <%s>", image)
-        raise

iker_python_common-1.0.62/test/iker_tests/common/utils/dockerutils_test.py

@@ -1,544 +0,0 @@
-import unittest
-import unittest.mock
-
-import ddt
-import docker.errors
-import docker.models.containers
-import docker.models.images
-import requests.exceptions
-
-from iker.common.utils.dockerutils import *
-from iker.common.utils.testutils import return_callee
-from iker_tests.docker_fixtures import MockedDockerContainer, MockedDockerImage
-
-
-@ddt.ddt
-class DockerUtilsTest(unittest.TestCase):
-    data_image_name = [
-        (
-            "ubuntu",
-            ImageName(None, None, ["ubuntu"], None),
-            "",
-            "ubuntu",
-        ),
-        (
-            "ubuntu:latest",
-            ImageName(None, None, ["ubuntu"], "latest"),
-            "",
-            "ubuntu",
-        ),
-        (
-            "ubuntu:22.04",
-            ImageName(None, None, ["ubuntu"], "22.04"),
-            "",
-            "ubuntu",
-        ),
-        (
-            "canonical/ubuntu",
-            ImageName(None, None, ["canonical", "ubuntu"], None),
-            "",
-            "canonical/ubuntu",
-        ),
-        (
-            "canonical/ubuntu:latest",
-            ImageName(None, None, ["canonical", "ubuntu"], "latest"),
-            "",
-            "canonical/ubuntu",
-        ),
-        (
-            "canonical/ubuntu:22.04",
-            ImageName(None, None, ["canonical", "ubuntu"], "22.04"),
-            "",
-            "canonical/ubuntu",
-        ),
-        (
-            "hub.docker.com/canonical/ubuntu",
-            ImageName("hub.docker.com", None, ["canonical", "ubuntu"], None),
-            "hub.docker.com",
-            "canonical/ubuntu",
-        ),
-        (
-            "hub.docker.com/canonical/ubuntu:latest",
-            ImageName("hub.docker.com", None, ["canonical", "ubuntu"], "latest"),
-            "hub.docker.com",
-            "canonical/ubuntu",
-        ),
-        (
-            "hub.docker.com/canonical/ubuntu:22.04",
-            ImageName("hub.docker.com", None, ["canonical", "ubuntu"], "22.04"),
-            "hub.docker.com",
-            "canonical/ubuntu",
-        ),
-        (
-            "hub.docker.com:8080/canonical/ubuntu",
-            ImageName("hub.docker.com", 8080, ["canonical", "ubuntu"], None),
-            "hub.docker.com:8080",
-            "canonical/ubuntu",
-        ),
-        (
-            "hub.docker.com:8080/canonical/ubuntu:latest",
-            ImageName("hub.docker.com", 8080, ["canonical", "ubuntu"], "latest"),
-            "hub.docker.com:8080",
-            "canonical/ubuntu",
-        ),
-        (
-            "hub.docker.com:8080/canonical/ubuntu:22.04",
-            ImageName("hub.docker.com", 8080, ["canonical", "ubuntu"], "22.04"),
-            "hub.docker.com:8080",
-            "canonical/ubuntu",
-        ),
-        (
-            "hub.docker.com:8080/ubuntu",
-            ImageName("hub.docker.com", 8080, ["ubuntu"], None),
-            "hub.docker.com:8080",
-            "ubuntu",
-        ),
-        (
-            "hub.docker.com:8080/ubuntu:latest",
-            ImageName("hub.docker.com", 8080, ["ubuntu"], "latest"),
-            "hub.docker.com:8080",
-            "ubuntu",
-        ),
-        (
-            "hub.docker.com:8080/ubuntu:22.04",
-            ImageName("hub.docker.com", 8080, ["ubuntu"], "22.04"),
-            "hub.docker.com:8080",
-            "ubuntu",
-        ),
-        (
-            "hub.docker.com:8080/docker-hub/canonical/ubuntu",
-            ImageName("hub.docker.com", 8080, ["docker-hub", "canonical", "ubuntu"], None),
-            "hub.docker.com:8080",
-            "docker-hub/canonical/ubuntu",
-        ),
-        (
-            "hub.docker.com:8080/docker-hub/canonical/ubuntu:latest",
-            ImageName("hub.docker.com", 8080, ["docker-hub", "canonical", "ubuntu"], "latest"),
-            "hub.docker.com:8080",
-            "docker-hub/canonical/ubuntu",
-        ),
-        (
-            "hub.docker.com:8080/docker-hub/canonical/ubuntu:22.04",
-            ImageName("hub.docker.com", 8080, ["docker-hub", "canonical", "ubuntu"], "22.04"),
-            "hub.docker.com:8080",
-            "docker-hub/canonical/ubuntu",
-        ),
-    ]
-
-    @ddt.idata(data_image_name)
-    @ddt.unpack
-    def test_image_name(self, image_name_str, image_name, registry, repository):
-        actual = ImageName.parse(image_name_str)
-
-        self.assertEqual(image_name.registry_host, actual.registry_host)
-        self.assertEqual(image_name.registry_port, actual.registry_port)
-        self.assertEqual(image_name.components, actual.components)
-        self.assertEqual(image_name.tag, actual.tag)
-        self.assertEqual(image_name.registry, actual.registry)
-        self.assertEqual(image_name.repository, actual.repository)
-
-        self.assertEqual(registry, actual.registry)
-        self.assertEqual(repository, actual.repository)
-
-    data_image_name__bad_names = [
-        ("Ubuntu",),
-        ("UBUNTU",),
-        ("ubuntu.",),
-        ("ubuntu__",),
-        ("ubuntu-",),
-        ("ubuntu..ubuntu",),
-        ("ubuntu___ubuntu",),
-        ("ubuntu._ubuntu",),
-        ("ubuntu//ubuntu",),
-        ("underscore_hostname.dummy.io:12345/ubuntu",),
-        ("hostname.dummy.io:bad_port/ubuntu",),
-        (
-            "ubuntu:tag_is_too_too_too_too_too_too_too_too_too_too_too_too_too_too_too_too_too_too_too_too_too_too_too_too_too_too_too_too_too_too_long",
-        ),
-    ]
-
-    @ddt.idata(data_image_name__bad_names)
-    @ddt.unpack
-    def test_image_name__bad_names(self, image_name_str):
-        self.assertIsNone(ImageName.parse(image_name_str))
-
-    def test_docker_create_client(self):
-        with unittest.mock.patch("iker.common.utils.dockerutils.docker.DockerClient") as mock_docker_client:
-            with docker_create_client("dummy-registry", "dummy_username", "dummy_password"):
-                pass
-
-            mock_docker_client.return_value.login.assert_called_with(registry="dummy-registry",
-                                                                     username="dummy_username",
-                                                                     password="dummy_password",
-                                                                     reauth=True)
-
-    def test_docker_create_client__with_exception(self):
-        with unittest.mock.patch("iker.common.utils.dockerutils.docker.DockerClient") as mock_docker_client:
-            mock_docker_client.return_value.login.side_effect = docker.errors.APIError("")
-
-            with self.assertRaises(docker.errors.APIError):
-                with docker_create_client("dummy-registry", "dummy_username", "dummy_password"):
-                    pass
-
-            mock_docker_client.return_value.login.assert_called_with(registry="dummy-registry",
-                                                                     username="dummy_username",
-                                                                     password="dummy_password",
-                                                                     reauth=True)
-
-    def test_docker_build_image(self):
-        with unittest.mock.patch("iker.common.utils.dockerutils.docker.DockerClient") as mock_docker_client:
-            mock_docker_image = MockedDockerImage("dummy_image",
-                                                  tags_callee=return_callee("dummy_tags"),
-                                                  labels_callee=return_callee("dummy_labels"))
-            mock_docker_client.return_value.images.build.return_value = (
-                mock_docker_image,
-                [{"dummy-log-key": "dummy-log-value"}],
-            )
-
-            image_model, build_logs = docker_build_image(mock_docker_client.return_value,
-                                                         "dummy_tag",
-                                                         "dummy_path",
-                                                         "dummy_dockerfile",
-                                                         {"dummy_arg": "dummy_value"})
-
-            self.assertEqual(image_model.id, "dummy_image")
-            self.assertEqual(image_model.tags, "dummy_tags")
-            self.assertEqual(image_model.labels, "dummy_labels")
-            self.assertEqual(build_logs, [{"dummy-log-key": "dummy-log-value"}])
-
-            mock_docker_client.return_value.images.build.assert_called_with(tag="dummy_tag",
-                                                                            path="dummy_path",
-                                                                            dockerfile="dummy_dockerfile",
-                                                                            buildargs={"dummy_arg": "dummy_value"},
-                                                                            rm=True,
-                                                                            forcerm=True,
-                                                                            nocache=True)
-
-    data_docker_build_image__with_exception = [
-        (docker.errors.BuildError("dummy reason", iter([{"dummy-log-key": "dummy-log-value"}])),),
-        (docker.errors.APIError("dummy message"),),
-        (Exception(),),
-    ]
-
-    @ddt.idata(data_docker_build_image__with_exception)
-    @ddt.unpack
-    def test_docker_build_image__with_exception(self, exception):
-        with unittest.mock.patch("iker.common.utils.dockerutils.docker.DockerClient") as mock_docker_client:
-            mock_docker_client.return_value.images.build.side_effect = exception
-
-            with self.assertRaises(type(exception)):
-                docker_build_image(mock_docker_client.return_value,
-                                   "dummy_tag",
-                                   "dummy_path",
-                                   "dummy_dockerfile",
-                                   {"dummy_arg": "dummy_value"})
-
-            mock_docker_client.return_value.images.build.assert_called_with(tag="dummy_tag",
-                                                                            path="dummy_path",
-                                                                            dockerfile="dummy_dockerfile",
-                                                                            buildargs={"dummy_arg": "dummy_value"},
-                                                                            rm=True,
-                                                                            forcerm=True,
-                                                                            nocache=True)
-
-    def test_docker_get_image(self):
-        with unittest.mock.patch("iker.common.utils.dockerutils.docker.DockerClient") as mock_docker_client:
-            mock_docker_image = MockedDockerImage("dummy_image",
-                                                  tags_callee=return_callee("dummy_tags"),
-                                                  labels_callee=return_callee("dummy_labels"))
-            mock_docker_client.return_value.images.get.return_value = mock_docker_image
-
-            image_model = docker_get_image(mock_docker_client.return_value, "dummy_image")
-
-            self.assertEqual(image_model.id, "dummy_image")
-            self.assertEqual(image_model.tags, "dummy_tags")
-            self.assertEqual(image_model.labels, "dummy_labels")
-
-            mock_docker_client.return_value.images.get.assert_called_with("dummy_image")
-
-    data_docker_get_image__with_exception = [
-        (docker.errors.ImageNotFound("dummy message"),),
-        (docker.errors.APIError("dummy message"),),
-        (Exception(),),
-    ]
-
-    @ddt.idata(data_docker_get_image__with_exception)
-    @ddt.unpack
-    def test_docker_get_image__with_exception(self, exception):
-        with unittest.mock.patch("iker.common.utils.dockerutils.docker.DockerClient") as mock_docker_client:
-            mock_docker_client.return_value.images.get.side_effect = exception
-
-            with self.assertRaises(type(exception)):
-                docker_get_image(mock_docker_client.return_value, "dummy_image")
-
-            mock_docker_client.return_value.images.get.assert_called_with("dummy_image")
-
-    def test_docker_pull_image(self):
-        with unittest.mock.patch("iker.common.utils.dockerutils.docker.DockerClient") as mock_docker_client:
-            mock_get_docker_image = MockedDockerImage("dummy_get_image",
-                                                      tags_callee=return_callee("dummy_get_tags"),
-                                                      labels_callee=return_callee("dummy_get_labels"))
-            mock_docker_client.return_value.images.get.return_value = mock_get_docker_image
-            mock_pull_docker_image = MockedDockerImage("dummy_pull_image",
-                                                       tags_callee=return_callee("dummy_pull_tags"),
-                                                       labels_callee=return_callee("dummy_pull_labels"))
-            mock_docker_client.return_value.images.pull.return_value = mock_pull_docker_image
-
-            image_model = docker_pull_image(mock_docker_client.return_value, "dummy_image", fallback_local=True)
-
-            self.assertEqual(image_model.id, "dummy_pull_image")
-            self.assertEqual(image_model.tags, "dummy_pull_tags")
-            self.assertEqual(image_model.labels, "dummy_pull_labels")
-
-            mock_docker_client.return_value.images.get.assert_not_called()
-            mock_docker_client.return_value.images.pull.assert_called_with("dummy_image")
-
-    def test_docker_pull_image__fallback(self):
-        with unittest.mock.patch("iker.common.utils.dockerutils.docker.DockerClient") as mock_docker_client:
-            mock_docker_image = MockedDockerImage("dummy_get_image",
-                                                  tags_callee=return_callee("dummy_get_tags"),
-                                                  labels_callee=return_callee("dummy_get_labels"))
-            mock_docker_client.return_value.images.get.return_value = mock_docker_image
-            mock_docker_client.return_value.images.pull.side_effect = docker.errors.APIError("dummy message")
-
-            image_model = docker_pull_image(mock_docker_client.return_value, "dummy_image", fallback_local=True)
-
-            self.assertEqual(image_model.id, "dummy_get_image")
-            self.assertEqual(image_model.tags, "dummy_get_tags")
-            self.assertEqual(image_model.labels, "dummy_get_labels")
-
-            mock_docker_client.return_value.images.get.assert_called_with("dummy_image")
-            mock_docker_client.return_value.images.pull.assert_called_with("dummy_image")
-
-    data_docker_pull_image__with_exception = [
-        (docker.errors.ImageNotFound("dummy message"),),
-        (docker.errors.APIError("dummy message"),),
-        (Exception(),),
-    ]
-
-    @ddt.idata(data_docker_pull_image__with_exception)
-    @ddt.unpack
-    def test_docker_pull_image__with_exception(self, exception):
-        with unittest.mock.patch("iker.common.utils.dockerutils.docker.DockerClient") as mock_docker_client:
-            mock_docker_client.return_value.images.get.side_effect = docker.errors.APIError("dummy message")
-
-            mock_docker_client.return_value.images.pull.side_effect = exception
-
-            with self.assertRaises(type(exception)):
-                docker_pull_image(mock_docker_client.return_value, "dummy_image", fallback_local=False)
-
-            mock_docker_client.return_value.images.get.assert_not_called()
-            mock_docker_client.return_value.images.pull.assert_called_with("dummy_image")
-
-    data_docker_pull_image__fallback_with_exception = [
-        (docker.errors.ImageNotFound("dummy message"),),
-        (docker.errors.APIError("dummy message"),),
-        (Exception(),),
-    ]
-
-    @ddt.idata(data_docker_pull_image__fallback_with_exception)
-    @ddt.unpack
-    def test_docker_pull_image__fallback_with_exception(self, exception):
-        with unittest.mock.patch("iker.common.utils.dockerutils.docker.DockerClient") as mock_docker_client:
-            mock_docker_client.return_value.images.get.side_effect = exception
-            mock_docker_client.return_value.images.pull.side_effect = docker.errors.APIError("dummy message")
-
-            with self.assertRaises(type(exception)):
-                docker_pull_image(mock_docker_client.return_value, "dummy_image", fallback_local=True)
-
-            mock_docker_client.return_value.images.get.assert_called_with("dummy_image")
-            mock_docker_client.return_value.images.pull.assert_called_with("dummy_image")
-
-    def test_docker_fetch_image(self):
-        with (
-            unittest.mock.patch("iker.common.utils.dockerutils.docker.DockerClient") as mock_docker_client,
-            unittest.mock.patch("iker.common.utils.dockerutils.docker_get_image") as mock_docker_get_image,
-            unittest.mock.patch("iker.common.utils.dockerutils.docker_pull_image") as mock_docker_pull_image,
-        ):
-            docker_fetch_image(mock_docker_client.return_value, "dummy_image")
-
-            mock_docker_get_image.assert_called_with(mock_docker_client.return_value, "dummy_image")
-            mock_docker_pull_image.assert_not_called()
-
-    def test_docker_fetch_image__force_pull(self):
-        with (
-            unittest.mock.patch("iker.common.utils.dockerutils.docker.DockerClient") as mock_docker_client,
-            unittest.mock.patch("iker.common.utils.dockerutils.docker_get_image") as mock_docker_get_image,
-            unittest.mock.patch("iker.common.utils.dockerutils.docker_pull_image") as mock_docker_pull_image,
-        ):
-            docker_fetch_image(mock_docker_client.return_value, "dummy_image", force_pull=True)
-
-            mock_docker_get_image.assert_not_called()
-            mock_docker_pull_image.assert_called_with(mock_docker_client.return_value,
-                                                      "dummy_image",
-                                                      fallback_local=True)
-
-    def test_docker_fetch_image__get_image_failed(self):
-        with (
-            unittest.mock.patch("iker.common.utils.dockerutils.docker.DockerClient") as mock_docker_client,
-            unittest.mock.patch("iker.common.utils.dockerutils.docker_get_image") as mock_docker_get_image,
-            unittest.mock.patch("iker.common.utils.dockerutils.docker_pull_image") as mock_docker_pull_image,
-        ):
-            mock_docker_get_image.side_effect = docker.errors.APIError("dummy message")
-
-            docker_fetch_image(mock_docker_client.return_value, "dummy_image")
-
-            mock_docker_get_image.assert_called_with(mock_docker_client.return_value, "dummy_image")
-            mock_docker_pull_image.assert_called_with(mock_docker_client.return_value,
-                                                      "dummy_image",
-                                                      fallback_local=False)
-
-    def test_docker_run_detached(self):
-        with unittest.mock.patch("iker.common.utils.dockerutils.docker.DockerClient") as mock_docker_client:
-            mock_docker_container = MockedDockerContainer("dummy_container",
-                                                          status_callee=return_callee("dummy_status"),
-                                                          wait_callee=return_callee({"dummy_key": "dummy_value"}),
-                                                          logs_callee=return_callee("dummy log"),
-                                                          stop_callee=return_callee(),
-                                                          remove_callee=return_callee())
-            mock_docker_client.return_value.containers.run.return_value = mock_docker_container
-
-            result, log = docker_run_detached(mock_docker_client.return_value,
-                                              "dummy_image",
-                                              "dummy_container",
-                                              "dummy_command",
-                                              {"/dummy/src/path": {"bind": "/dummy/dst/path", "mode": "rw"}},
-                                              {"DUMMY_ENV_KEY": "DUMMY_ENV_VALUE"},
-                                              {"dummy.ip.address": "127.0.0.1"},
-                                              1000,
-                                              dummy_kwarg="dummy_value")
-
-            self.assertEqual(result, {"dummy_key": "dummy_value"})
-            self.assertEqual(log, "dummy log")
-
-            mock_docker_client.return_value.containers.run.assert_called_with(
-                image="dummy_image",
-                name="dummy_container",
-                command="dummy_command",
-                volumes={"/dummy/src/path": {"bind": "/dummy/dst/path", "mode": "rw"}},
-                environment={"DUMMY_ENV_KEY": "DUMMY_ENV_VALUE"},
-                extra_hosts={"dummy.ip.address": "127.0.0.1"},
-                detach=True,
-                dummy_kwarg="dummy_value",
-            )
-            mock_docker_container.status_callee.assert_called_once()
-            mock_docker_container.wait_callee.assert_called_once_with()(timeout=1000)
-            mock_docker_container.wait_callee.assert_called_once_with()()
-            mock_docker_container.logs_callee.assert_called_once()
-            mock_docker_container.stop_callee.assert_called_once()
-            mock_docker_container.remove_callee.assert_called_once()
-
-    data_docker_run_detached__with_exception_on_wait = [
-        (requests.exceptions.ReadTimeout(),),
-        (docker.errors.ImageNotFound("dummy message"),),
-        (
-            docker.errors.ContainerError("dummy container",
-                                         "dummy exit status",
-                                         "dummy command",
-                                         "dummy image",
-                                         "dummy stderr"),
-        ),
-        (docker.errors.APIError("dummy message"),),
-        (Exception(),),
-    ]
-
-    @ddt.idata(data_docker_run_detached__with_exception_on_wait)
-    @ddt.unpack
-    def test_docker_run_detached__with_exception_on_wait(self, exception):
-        with unittest.mock.patch("iker.common.utils.dockerutils.docker.DockerClient") as mock_docker_client:
-            def mock_containers_run_wait_valuer(*args, **kwargs):
-                if kwargs == dict(timeout=1000):
-                    raise exception
-
-            mock_docker_container = MockedDockerContainer("dummy_container",
-                                                          status_callee=return_callee("dummy_status"),
-                                                          wait_callee=return_callee(mock_containers_run_wait_valuer),
-                                                          logs_callee=return_callee("dummy log"),
-                                                          stop_callee=return_callee(),
-                                                          remove_callee=return_callee())
-            mock_docker_client.return_value.containers.run.return_value = mock_docker_container
-
-            with self.assertRaises(type(exception)):
-                docker_run_detached(mock_docker_client.return_value,
-                                    "dummy_image",
-                                    "dummy_container",
-                                    "dummy_command",
-                                    {"/dummy/src/path": {"bind": "/dummy/dst/path", "mode": "rw"}},
-                                    {"DUMMY_ENV_KEY": "DUMMY_ENV_VALUE"},
-                                    {"dummy.ip.address": "127.0.0.1"},
-                                    1000,
-                                    dummy_kwarg="dummy_value")
-
-            mock_docker_client.return_value.containers.run.assert_called_with(
-                image="dummy_image",
-                name="dummy_container",
-                command="dummy_command",
-                volumes={"/dummy/src/path": {"bind": "/dummy/dst/path", "mode": "rw"}},
-                environment={"DUMMY_ENV_KEY": "DUMMY_ENV_VALUE"},
-                extra_hosts={"dummy.ip.address": "127.0.0.1"},
-                detach=True,
-                dummy_kwarg="dummy_value",
-            )
-            mock_docker_container.status_callee.assert_called_once()
-            mock_docker_container.wait_callee.assert_called_once_with()(timeout=1000)
-            mock_docker_container.wait_callee.assert_called_once_with()()
-            mock_docker_container.logs_callee.assert_not_called()
-            mock_docker_container.stop_callee.assert_called_once()
-            mock_docker_container.remove_callee.assert_called_once()
-
-    data_docker_run_detached__with_exception_on_stop = [
-        (docker.errors.ImageNotFound("dummy message"),),
-        (
-            docker.errors.ContainerError("dummy container",
-                                         "dummy exit status",
-                                         "dummy command",
-                                         "dummy image",
-                                         "dummy stderr"),
-        ),
-        (docker.errors.APIError("dummy message"),),
-    ]
-
-    @ddt.idata(data_docker_run_detached__with_exception_on_stop)
-    @ddt.unpack
-    def test_docker_run_detached__with_exception_on_stop(self, exception):
-        with unittest.mock.patch("iker.common.utils.dockerutils.docker.DockerClient") as mock_docker_client:
-            def mock_containers_run_stop_valuer(*args, **kwargs):
-                raise exception
-
-            mock_docker_container = MockedDockerContainer("dummy_container",
-                                                          status_callee=return_callee("dummy_status"),
-                                                          wait_callee=return_callee({"dummy_key": "dummy_value"}),
-                                                          logs_callee=return_callee("dummy log"),
-                                                          stop_callee=return_callee(mock_containers_run_stop_valuer),
-                                                          remove_callee=return_callee())
-            mock_docker_client.return_value.containers.run.return_value = mock_docker_container
-
-            result, log = docker_run_detached(mock_docker_client.return_value,
-                                              "dummy_image",
-                                              "dummy_container",
-                                              "dummy_command",
-                                              {"/dummy/src/path": {"bind": "/dummy/dst/path", "mode": "rw"}},
-                                              {"DUMMY_ENV_KEY": "DUMMY_ENV_VALUE"},
-                                              {"dummy.ip.address": "127.0.0.1"},
-                                              1000,
-                                              dummy_kwarg="dummy_value")
-
-            self.assertEqual(result, {"dummy_key": "dummy_value"})
-            self.assertEqual(log, "dummy log")
-
-            mock_docker_client.return_value.containers.run.assert_called_with(
-                image="dummy_image",
-                name="dummy_container",
-                command="dummy_command",
-                volumes={"/dummy/src/path": {"bind": "/dummy/dst/path", "mode": "rw"}},
-                environment={"DUMMY_ENV_KEY": "DUMMY_ENV_VALUE"},
-                extra_hosts={"dummy.ip.address": "127.0.0.1"},
-                detach=True,
-                dummy_kwarg="dummy_value",
-            )
-            mock_docker_container.status_callee.assert_called_once()
-            mock_docker_container.wait_callee.assert_called_once_with()(timeout=1000)
-            mock_docker_container.wait_callee.assert_called_once_with()()
-            mock_docker_container.logs_callee.assert_called_once()
-            mock_docker_container.stop_callee.assert_called_once()
-            mock_docker_container.remove_callee.assert_called_once()

iker_python_common-1.0.62/test/iker_tests/docker_fixtures.py

@@ -1,79 +0,0 @@
-import docker
-import docker.errors
-import docker.models.containers
-import docker.models.images
-import docker.models.resource
-
-from iker.common.utils.testutils import CalleeMock
-from iker.common.utils.testutils import return_callee
-
-__all__ = [
-    "MockedDockerClient",
-    "MockedDockerImage",
-    "MockedDockerContainer",
-]
-
-
-class MockedDockerClient(docker.DockerClient):
-    def __init__(self):
-        # Do not call superclass init to avoid underlying API client being initialized
-        pass
-
-    def close(self):
-        pass
-
-
-class MockedDockerImage(docker.models.resource.Model):
-    def __init__(
-        self,
-        model_id: str,
-        *,
-        tags_callee: CalleeMock = return_callee(),
-        labels_callee: CalleeMock = return_callee(),
-    ):
-        super(MockedDockerImage, self).__init__({docker.models.resource.Model.id_attribute: model_id})
-        self.tags_callee = tags_callee
-        self.labels_callee = labels_callee
-
-    @property
-    def tags(self):
-        return self.tags_callee()
-
-    @property
-    def labels(self):
-        return self.labels_callee()
-
-
-class MockedDockerContainer(docker.models.resource.Model):
-    def __init__(
-        self,
-        model_id: str,
-        *,
-        status_callee: CalleeMock = return_callee(),
-        wait_callee: CalleeMock = return_callee(),
-        logs_callee: CalleeMock = return_callee(),
-        stop_callee: CalleeMock = return_callee(),
-        remove_callee: CalleeMock = return_callee(),
-    ):
-        super(MockedDockerContainer, self).__init__({docker.models.resource.Model.id_attribute: model_id})
-        self.status_callee = status_callee
-        self.wait_callee = wait_callee
-        self.logs_callee = logs_callee
-        self.stop_callee = stop_callee
-        self.remove_callee = remove_callee
-
-    @property
-    def status(self):
-        return self.status_callee()
-
-    def wait(self, **kwargs):
-        return self.wait_callee(**kwargs)
-
-    def logs(self, **kwargs):
-        return self.logs_callee(**kwargs)
-
-    def stop(self, **kwargs):
-        return self.stop_callee(**kwargs)
-
-    def remove(self, **kwargs):
-        return self.remove_callee(**kwargs)