def test_must_write_only_stdout(self):
Container._write_container_output(self.output_itr, stdout=self.stdout_mock, stderr=None)
self.stdout_mock.write.assert_has_calls([call(b"stdout1"), call(b"stdout2"), call(b"stdout3")])
self.stderr_mock.write.assert_not_called() # stderr must never be called
def test_must_write_stdout_and_stderr_data(self):
# All the invalid frames must be ignored
Container._write_container_output(self.output_itr, stdout=self.stdout_mock, stderr=self.stderr_mock)
self.stdout_mock.write.assert_has_calls([call(b"stdout1"), call(b"stdout2"), call(b"stdout3")])
self.stderr_mock.write.assert_has_calls([call(b"stderr1"), call(b"stderr2"), call(b"stderr3")])
def test_must_write_only_stderr(self):
# All the invalid frames must be ignored
Container._write_container_output(self.output_itr, stdout=None, stderr=self.stderr_mock)
self.stdout_mock.write.assert_not_called()
self.stderr_mock.write.assert_has_calls([call(b"stderr1"), call(b"stderr2"), call(b"stderr3")])
def test_must_write_only_stdout(self):
Container._write_container_output(self.output_itr, stdout=self.stdout_mock, stderr=None)
self.stdout_mock.write.assert_has_calls([
call(b"stdout1"), call(b"stdout2"), call(b"stdout3")
])
self.stderr_mock.write.assert_not_called() # stderr must never be called
def test_must_write_only_stderr(self):
# All the invalid frames must be ignored
Container._write_container_output(self.output_itr, stdout=None, stderr=self.stderr_mock)
self.stdout_mock.write.assert_not_called()
self.stderr_mock.write.assert_has_calls([
call(b"stderr1"), call(b"stderr2"), call(b"stderr3")
])
def test_must_write_stdout_and_stderr_data(self):
# All the invalid frames must be ignored
Container._write_container_output(self.output_itr, stdout=self.stdout_mock, stderr=self.stderr_mock)
self.stdout_mock.write.assert_has_calls([
call(b"stdout1"), call(b"stdout2"), call(b"stdout3")
])
self.stderr_mock.write.assert_has_calls([
call(b"stderr1"), call(b"stderr2"), call(b"stderr3")
])
def test_must_create_container_with_required_values(self):
"""
Create a container with only required values. Optional values are not provided
:return:
"""
expected_volumes = {
self.host_dir: {
"bind": self.working_dir,
"mode": "ro,delegated"
}
}
generated_id = "fooobar"
self.mock_docker_client.containers.create.return_value = Mock()
self.mock_docker_client.containers.create.return_value.id = generated_id
container = Container(self.image,
self.cmd,
self.working_dir,
self.host_dir,
docker_client=self.mock_docker_client)
container_id = container.create()
self.assertEquals(container_id, generated_id)
self.assertEquals(container.id, generated_id)
self.mock_docker_client.containers.create.assert_called_with(self.image,
command=self.cmd,
working_dir=self.working_dir,
volumes=expected_volumes,
tty=False)
self.mock_docker_client.networks.get.assert_not_called()
def test_must_connect_to_network_on_create(self):
"""
Create a container with only required values. Optional values are not provided
:return:
"""
network_id = "some id"
generated_id = "fooobar"
self.mock_docker_client.containers.create.return_value = Mock()
self.mock_docker_client.containers.create.return_value.id = generated_id
network_mock = Mock()
self.mock_docker_client.networks.get.return_value = network_mock
network_mock.connect = Mock()
container = Container(self.image,
self.cmd,
self.working_dir,
self.host_dir,
docker_client=self.mock_docker_client)
container.network_id = network_id
container_id = container.create()
self.assertEquals(container_id, generated_id)
self.mock_docker_client.networks.get.assert_called_with(network_id)
network_mock.connect.assert_called_with(container_id)
def test_init_must_store_all_values(self):
container = Container(
self.image,
self.cmd,
self.working_dir,
self.host_dir,
self.memory_mb,
self.exposed_ports,
self.entrypoint,
self.env_vars,
self.mock_docker_client,
)
self.assertEqual(self.image, container._image)
self.assertEqual(self.cmd, container._cmd)
self.assertEqual(self.working_dir, container._working_dir)
self.assertEqual(self.host_dir, container._host_dir)
self.assertEqual(self.exposed_ports, container._exposed_ports)
self.assertEqual(self.entrypoint, container._entrypoint)
self.assertEqual(self.env_vars, container._env_vars)
self.assertEqual(self.memory_mb, container._memory_limit_mb)
self.assertEqual(None, container._network_id)
self.assertEqual(None, container.id)
self.assertEqual(self.mock_docker_client, container.docker_client)
def setUp(self):
self.mock_client = Mock()
self.container = Container("image",
"cmd",
"dir",
"dir",
docker_client=self.mock_client)
def test_must_create_container_including_all_optional_values(self):
"""
Create a container with required and optional values.
:return:
"""
expected_volumes = {
self.host_dir: {
"bind": self.working_dir,
"mode": "ro,delegated"
},
"/somepath": {
"blah": "blah value"
},
}
expected_memory = "{}m".format(self.memory_mb)
generated_id = "fooobar"
self.mock_docker_client.containers.create.return_value = Mock()
self.mock_docker_client.containers.create.return_value.id = generated_id
container = Container(
self.image,
self.cmd,
self.working_dir,
self.host_dir,
memory_limit_mb=self.memory_mb,
exposed_ports=self.exposed_ports,
entrypoint=self.entrypoint,
env_vars=self.env_vars,
docker_client=self.mock_docker_client,
container_opts=self.container_opts,
additional_volumes=self.additional_volumes,
)
container_id = container.create()
self.assertEqual(container_id, generated_id)
self.assertEqual(container.id, generated_id)
self.mock_docker_client.containers.create.assert_called_with(
self.image,
command=self.cmd,
working_dir=self.working_dir,
volumes=expected_volumes,
tty=False,
use_config_proxy=True,
environment=self.env_vars,
ports={
container_port: ("127.0.0.1", host_port)
for container_port, host_port in {
**self.exposed_ports,
**self.always_exposed_ports
}.items()
},
entrypoint=self.entrypoint,
mem_limit=expected_memory,
container="opts",
)
self.mock_docker_client.networks.get.assert_not_called()
def setUp(self):
self.mock_client = Mock()
self.container = Container(IMAGE,
"cmd",
"dir",
"dir",
docker_client=self.mock_client)
self.container.id = "containerid"
def test_must_create_container_translate_volume_path(self, os_mock):
"""
Create a container with required and optional values, with windows style volume mount.
:return:
"""
os_mock.name = "nt"
host_dir = "C:\\Users\\Username\\AppData\\Local\\Temp\\tmp1337"
additional_volumes = {"C:\\Users\\Username\\AppData\\Local\\Temp\\tmp1338": {"blah": "blah value"}}
translated_volumes = {
"/c/Users/Username/AppData/Local/Temp/tmp1337": {"bind": self.working_dir, "mode": "ro,delegated"}
}
translated_additional_volumes = {"/c/Users/Username/AppData/Local/Temp/tmp1338": {"blah": "blah value"}}
translated_volumes.update(translated_additional_volumes)
expected_memory = "{}m".format(self.memory_mb)
generated_id = "fooobar"
self.mock_docker_client.containers.create.return_value = Mock()
self.mock_docker_client.containers.create.return_value.id = generated_id
container = Container(
self.image,
self.cmd,
self.working_dir,
host_dir,
memory_limit_mb=self.memory_mb,
exposed_ports=self.exposed_ports,
entrypoint=self.entrypoint,
env_vars=self.env_vars,
docker_client=self.mock_docker_client,
container_opts=self.container_opts,
additional_volumes=additional_volumes,
)
container_id = container.create()
self.assertEqual(container_id, generated_id)
self.assertEqual(container.id, generated_id)
self.mock_docker_client.containers.create.assert_called_with(
self.image,
command=self.cmd,
working_dir=self.working_dir,
volumes=translated_volumes,
tty=False,
use_config_proxy=True,
environment=self.env_vars,
ports={
container_port: ("127.0.0.1", host_port)
for container_port, host_port in {**self.exposed_ports, **self.always_exposed_ports}.items()
},
entrypoint=self.entrypoint,
mem_limit=expected_memory,
container="opts",
)
self.mock_docker_client.networks.get.assert_not_called()
def test_must_fail_if_already_created(self):
container = Container(
self.image, self.cmd, self.working_dir, self.host_dir, docker_client=self.mock_docker_client
)
container.is_created = Mock()
container.is_created.return_value = True
with self.assertRaises(RuntimeError):
container.create()
def test_must_create_container_including_all_optional_values(self):
"""
Create a container with required and optional values.
:return:
"""
expected_volumes = {
self.host_dir: {
"bind": self.working_dir,
"mode": "ro"
},
'/somepath': {
"blah": "blah value"
}
}
expected_memory = "{}m".format(self.memory_mb)
generated_id = "fooobar"
self.mock_docker_client.containers.create.return_value = Mock()
self.mock_docker_client.containers.create.return_value.id = generated_id
container = Container(self.image,
self.cmd,
self.working_dir,
self.host_dir,
memory_limit_mb=self.memory_mb,
exposed_ports=self.exposed_ports,
entrypoint=self.entrypoint,
env_vars=self.env_vars,
docker_client=self.mock_docker_client,
container_opts=self.container_opts,
additional_volumes=self.additional_volumes)
container_id = container.create()
self.assertEquals(container_id, generated_id)
self.assertEquals(container.id, generated_id)
self.mock_docker_client.containers.create.assert_called_with(
self.image,
command=self.cmd,
working_dir=self.working_dir,
volumes=expected_volumes,
tty=False,
environment=self.env_vars,
ports=self.exposed_ports,
entrypoint=self.entrypoint,
mem_limit=expected_memory,
container='opts')
self.mock_docker_client.networks.get.assert_not_called()
def setUp(self):
self.image = "image"
self.cmd = ["cmd"]
self.working_dir = "working_dir"
self.host_dir = "host_dir"
self.mock_docker_client = Mock()
self.mock_docker_client.containers = Mock()
self.mock_docker_client.containers.get = Mock()
self.container = Container(
self.image, self.cmd, self.working_dir, self.host_dir, docker_client=self.mock_docker_client
)
self.container.id = "someid"
self.container.is_created = Mock()
def test_must_create_container_with_required_values(self):
"""
Create a container with only required values. Optional values are not provided
:return:
"""
expected_volumes = {
self.host_dir: {
"bind": self.working_dir,
"mode": "ro,delegated"
}
}
generated_id = "fooobar"
self.mock_docker_client.containers.create.return_value = Mock()
self.mock_docker_client.containers.create.return_value.id = generated_id
container = Container(
self.image,
self.cmd,
self.working_dir,
self.host_dir,
docker_client=self.mock_docker_client,
exposed_ports=self.exposed_ports,
)
container_id = container.create()
self.assertEqual(container_id, generated_id)
self.assertEqual(container.id, generated_id)
self.mock_docker_client.containers.create.assert_called_with(
self.image,
command=self.cmd,
working_dir=self.working_dir,
volumes=expected_volumes,
tty=False,
ports={
container_port: ("127.0.0.1", host_port)
for container_port, host_port in {
**self.exposed_ports,
**self.always_exposed_ports
}.items()
},
use_config_proxy=True,
)
self.mock_docker_client.networks.get.assert_not_called()
def setUp(self):
self.image = IMAGE
self.name = "function_name"
self.event = {}
self.cmd = ["cmd"]
self.working_dir = "working_dir"
self.host_dir = "host_dir"
self.mock_docker_client = Mock()
self.mock_docker_client.containers = Mock()
self.mock_docker_client.containers.get = Mock()
self.container = Container(
self.image, self.cmd, self.working_dir, self.host_dir, docker_client=self.mock_docker_client
)
self.container.id = "someid"
self.container.is_created = Mock()
self.timeout = 1
def test_must_connect_to_host_network_on_create(self):
"""
Create a container with only required values. Optional values are not provided
:return:
"""
expected_volumes = {
self.host_dir: {
"bind": self.working_dir,
"mode": "ro,delegated"
}
}
network_id = "host"
generated_id = "fooobar"
self.mock_docker_client.containers.create.return_value = Mock()
self.mock_docker_client.containers.create.return_value.id = generated_id
network_mock = Mock()
self.mock_docker_client.networks.get.return_value = network_mock
network_mock.connect = Mock()
container = Container(self.image,
self.cmd,
self.working_dir,
self.host_dir,
docker_client=self.mock_docker_client)
container.network_id = network_id
container_id = container.create()
self.assertEqual(container_id, generated_id)
self.mock_docker_client.containers.create.assert_called_with(
self.image,
command=self.cmd,
working_dir=self.working_dir,
ports=self.always_exposed_ports,
tty=False,
use_config_proxy=True,
volumes=expected_volumes,
network_mode="host",
)
self.mock_docker_client.networks.get.assert_not_called()
def test_must_create_container_with_required_values_extensions_preview(
self, PreviewEnabledMock):
"""
Create a container with only required values. Optional values are not provided
:return:
"""
PreviewEnabledMock.return_value = True
expected_volumes = {
self.host_dir: {
"bind": self.working_dir,
"mode": "ro,delegated"
}
}
generated_id = "fooobar"
self.mock_docker_client.containers.create.return_value = Mock()
self.mock_docker_client.containers.create.return_value.id = generated_id
container = Container(self.image,
self.cmd,
self.working_dir,
self.host_dir,
docker_client=self.mock_docker_client)
container_id = container.create()
self.assertEqual(container_id, generated_id)
self.assertEqual(container.id, generated_id)
self.mock_docker_client.containers.create.assert_called_with(
self.image,
command=self.cmd,
working_dir=self.working_dir,
volumes=expected_volumes,
ports={Container.RAPID_PORT_CONTAINER: ANY},
tty=False,
use_config_proxy=True,
)
self.mock_docker_client.networks.get.assert_not_called()
def setUp(self, PreviewEnabledMock):
self.image = "image"
self.name = "function_name"
self.event = {}
self.cmd = ["cmd"]
self.working_dir = "working_dir"
self.host_dir = "host_dir"
self.mock_docker_client = Mock()
self.mock_docker_client.containers = Mock()
self.mock_docker_client.containers.get = Mock()
PreviewEnabledMock.return_value = True
self.container = Container(self.image,
self.cmd,
self.working_dir,
self.host_dir,
docker_client=self.mock_docker_client)
self.container.id = "someid"
self.container.is_created = Mock()
self.timeout = 0.1
def test_must_return_image_value(self):
image = "myimage"
container = Container(image, "cmd", "dir", "dir")
self.assertEquals(image, container.image)
