Пример #1
0
def test_kafka_sibling_network(docker_client, create_and_pull):
    with temp_network(docker_client) as network, \
            KafkaService.run(docker_client, spinner=False) as service, \
            connect(network, service) as alias:
        container = create_and_pull(
            docker_client, "confluentinc/cp-kafkacat:latest",
            f"kafkacat -b {alias[0]}:{service.inner_port} -L")
        with connect(network, container):
            container.start()
            return_status = container.wait()
            assert return_status["StatusCode"] == 0
Пример #2
0
def test_connection_works_sibling_network(docker_client, create_and_pull):
    with temp_network(docker_client) as network:
        with BlobStorageService.run(docker_client) as blob, \
                connect(network, blob) as aliases:
            url = f"http://{aliases[0]}:{BLOB_STORAGE_DEFAULT_PORT}"
            container = create_and_pull(docker_client,
                                        "byrnedo/alpine-curl:latest",
                                        f'-vvv -I "{url}" --http0.9',
                                        detach=True)
            with connect(network, container):
                container.start()
                return_status = container.wait()
                assert return_status["StatusCode"] == 0
Пример #3
0
def test_connection_works_sibling_network(docker_client, vhost, create_and_pull):
    with temp_network(docker_client) as network:
        with RabbitMQService.run(docker_client, image="rabbitmq:management-alpine", virtual_host=vhost) \
                as rabbit, \
                connect(network, rabbit) as aliases:
            url = f"http://{aliases[0]}:{RABBIT_HTTP_API_PORT}/api/vhosts"
            container = create_and_pull(
                docker_client,
                "byrnedo/alpine-curl:latest", f'-u guest:guest -vvv -I "{url}" --http0.9',
                detach=True
            )
            with connect(network, container):
                container.start()
                return_status = container.wait()
                assert return_status["StatusCode"] == 0
Пример #4
0
    def run(
            cls: Type[_T],
            docker_client: DockerClient,
            *,
            spinner: bool = True,  # type: ignore
            retry_spec: Optional[RetrySpec] = None,
            network: Optional[Network] = None,
            **kwargs) -> Iterator[_T]:
        """
        Same as RunMixin.run, but allows to forward retry arguments to the blocking start method.

        Args:
            docker_client: a DockerClient instance to use when creating the service
            spinner: whether or not to use a yaspin spinner
            retry_spec: forwarded to cls.start
            network: connect service to network
            **kwargs: all keyword arguments are forwarded to the class's constructor
        """
        yaspin_spinner = _get_spinner(spinner)
        with yaspin_spinner(f"Fetching {cls.service_name()} ..."
                            ):  # type: ignore[attr-defined]
            service = cls(docker_client, **kwargs)

        connect_network: ContextManager[None]
        if network:
            connect_network = networks_mod.connect(network, service)
        else:
            connect_network = nullcontext()

        with connect_network:
            with yaspin_spinner(f"Waiting for {cls.service_name()} to start..."
                                ):  # type: ignore[attr-defined]
                service.start(retry_spec=retry_spec)
            with service:
                yield service
Пример #5
0
def test_kafka_connect_in_run(docker_client, create_and_pull):
    with temp_network(docker_client) as network, \
            KafkaService.run(docker_client, spinner=False, network=network) as service:
        container = create_and_pull(
            docker_client, "confluentinc/cp-kafkacat:latest",
            f"kafkacat -b {get_aliases(service.broker, network)[0]}:{service.inner_port} -L"
        )
        with connect(network, container):
            container.start()
            return_status = container.wait()
            assert return_status["StatusCode"] == 0