def test_parse_fail_2(self):
containers = {
"c1": {"ima": "image1", "command": "/bin/bash"},
"c2": {"image": "image2", "links": ["c1"]}
}
d = dict(containers=containers)
with self.assertRaises(BlockadeConfigError):
BlockadeConfig.from_dict(d)
def test_parse_with_start_delay_fail_nonnumeric(self):
containers = {
"c1": {"image": "image1", "command": "/bin/bash",
"start_delay": "abc123"}
}
d = dict(containers=containers, network={})
with self.assertRaisesRegexp(BlockadeConfigError, "start_delay"):
BlockadeConfig.from_dict(d)
def test_parse_with_start_delay_fail_nonnumeric(self):
containers = {
"c1": {
"image": "image1",
"command": "/bin/bash",
"start_delay": "abc123"
}
}
d = dict(containers=containers, network={})
with self.assertRaisesRegexp(BlockadeConfigError, "start_delay"):
BlockadeConfig.from_dict(d)
def test_parse_fail_2(self):
containers = {
"c1": {
"ima": "image1",
"command": "/bin/bash"
},
"c2": {
"image": "image2",
"links": ["c1"]
}
}
d = dict(containers=containers)
with self.assertRaises(BlockadeConfigError):
BlockadeConfig.from_dict(d)
def test_create(self):
containers = {
'c1': BlockadeContainerConfig("c1", "image"),
'c2': BlockadeContainerConfig("c2", "image"),
'c3': BlockadeContainerConfig("c3", "image")
}
config = BlockadeConfig(containers)
self.network.get_container_device.side_effect = lambda dc, y: "veth" + y
self.state.exists.side_effect = lambda: False
self.state.blockade_id = self.blockade_id
self.docker_client.create_container.side_effect = [{
"Id": "container1"
}, {
"Id": "container2"
}, {
"Id": "container3"
}]
b = Blockade(config,
state=self.state,
network=self.network,
docker_client=self.docker_client)
b.create()
self.assertEqual(self.state.initialize.call_count, 1)
self.assertEqual(self.docker_client.create_container.call_count, 3)
def test_create(self):
containers = {
'c1': BlockadeContainerConfig("c1", "image"),
'c2': BlockadeContainerConfig("c2", "image"),
'c3': BlockadeContainerConfig("c3", "image")
}
config = BlockadeConfig(containers)
self.network.get_container_device.side_effect = lambda dc, y: "veth" + y
initialize = lambda x, y: BlockadeState("ourblockadeid", x)
self.state_factory.initialize.side_effect = initialize
self.state_factory.exists.side_effect = lambda: False
self.state_factory.get_blockade_id = mock.MagicMock(
return_value="ourblockadeid")
self.docker_client.create_container.side_effect = [{
"Id": "container1"
}, {
"Id": "container2"
}, {
"Id": "container3"
}]
b = Blockade(config, self.state_factory, self.network,
self.docker_client)
b.create()
self.assertEqual(self.state_factory.initialize.call_count, 1)
self.assertEqual(self.docker_client.create_container.call_count, 3)
def test_parse_with_start_delay_2(self):
containers = {
"c1": {"image": "image1", "command": "/bin/bash",
"start_delay": 0.4}
}
d = dict(containers=containers, network={})
config = BlockadeConfig.from_dict(d)
self.assertEqual(len(config.containers), 1)
c1 = config.containers['c1']
self.assertEqual(c1.start_delay, 0.4)
def test_parse_with_numeric_port(self):
containers = {
"c1": {"image": "image1", "command": "/bin/bash",
"expose": [10000]}
}
d = dict(containers=containers, network={})
config = BlockadeConfig.from_dict(d)
self.assertEqual(len(config.containers), 1)
c1 = config.containers['c1']
self.assertEqual(c1.expose_ports, [10000])
def test_parse_with_publish_1(self):
containers = {
"c1": {"image": "image1", "ports": {8080: 80}, "expose": [80]}
}
d = dict(containers=containers, network={})
config = BlockadeConfig.from_dict(d)
self.assertEqual(len(config.containers), 1)
c1 = config.containers['c1']
self.assertEqual(c1.expose_ports, [80])
self.assertEqual(c1.publish_ports, {'8080': '80'})
def test_parse_with_env_1(self):
containers = {
"c1": {"image": "image1", "command": "/bin/bash",
"environment": {"HATS": 4, "JACKETS": "some"}}
}
d = dict(containers=containers, network={})
config = BlockadeConfig.from_dict(d)
self.assertEqual(len(config.containers), 1)
c1 = config.containers['c1']
self.assertEqual(c1.environment, {"HATS": "4", "JACKETS": "some"})
def test_parse_2(self):
containers = {"c1": {"image": "image1", "command": "/bin/bash"}}
network = {"flaky": "61%"}
d = dict(containers=containers, network=network)
config = BlockadeConfig.from_dict(d)
# default value should be there
self.assertIn("flaky", config.network)
self.assertEqual(config.network['flaky'], "61%")
# default value should be there
self.assertIn("slow", config.network)
def test_parse_with_multiple_cap_add(self):
containers = {
"c1": {"image": "image1", "command": "/bin/bash",
"cap_add": ["NET_ADMIN", "MKNOD"]}
}
d = dict(containers=containers, network={})
config = BlockadeConfig.from_dict(d)
self.assertEqual(len(config.containers), 1)
c1 = config.containers['c1']
self.assertEqual(c1.cap_add, ["NET_ADMIN", "MKNOD"])
def test_parse_with_name(self):
containers = {
"c1": {"image": "image1", "command": "/bin/bash",
"container_name": "abc"}
}
network = {}
d = dict(containers=containers, network=network)
config = BlockadeConfig.from_dict(d)
# default value should be there
self.assertEqual(len(config.containers), 1)
c1 = config.containers['c1']
self.assertEqual(c1.container_name, "abc")
def test_parse_2(self):
containers = {
"c1": {"image": "image1", "command": "/bin/bash"}
}
network = {"flaky": "61%"}
d = dict(containers=containers, network=network)
config = BlockadeConfig.from_dict(d)
# default value should be there
self.assertIn("flaky", config.network)
self.assertEqual(config.network['flaky'], "61%")
# default value should be there
self.assertIn("slow", config.network)
def test_parse_with_volumes_4(self):
containers = {
"c1": {"image": "image1", "command": "/bin/bash",
"volumes": {"/some/mount": None}}
}
network = {}
d = dict(containers=containers, network=network)
config = BlockadeConfig.from_dict(d)
# default value should be there
self.assertEqual(len(config.containers), 1)
c1 = config.containers['c1']
self.assertEqual(c1.volumes, {"/some/mount": "/some/mount"})
def test_parse_with_numeric_port(self):
containers = {
"c1": {
"image": "image1",
"command": "/bin/bash",
"expose": [10000]
}
}
d = dict(containers=containers, network={})
config = BlockadeConfig.from_dict(d)
self.assertEqual(len(config.containers), 1)
c1 = config.containers['c1']
self.assertEqual(c1.expose_ports, {"10000": "10000"})
def test_parse_with_multiple_cap_add(self):
containers = {
"c1": {
"image": "image1",
"command": "/bin/bash",
"cap_add": ["NET_ADMIN", "MKNOD"]
}
}
d = dict(containers=containers, network={})
config = BlockadeConfig.from_dict(d)
self.assertEqual(len(config.containers), 1)
c1 = config.containers['c1']
self.assertEqual(c1.cap_add, ["NET_ADMIN", "MKNOD"])
def test_parse_with_start_delay_2(self):
containers = {
"c1": {
"image": "image1",
"command": "/bin/bash",
"start_delay": 0.4
}
}
d = dict(containers=containers, network={})
config = BlockadeConfig.from_dict(d)
self.assertEqual(len(config.containers), 1)
c1 = config.containers['c1']
self.assertEqual(c1.start_delay, 0.4)
def test_parse_with_count_1(self):
containers = {
"db": {"image": "image1", "command": "/bin/bash", "count": 2},
"app": {"image": "image1", "command": "/bin/bash",
"container_name": "abc", "count": 3}
}
d = dict(containers=containers, network={})
config = BlockadeConfig.from_dict(d)
self.assertEqual(set(config.containers.keys()),
set(["db_1", "db_2", "app_1", "app_2", "app_3"]))
self.assertEqual(config.containers["app_1"].container_name, "abc_1")
self.assertEqual(config.containers["app_2"].container_name, "abc_2")
self.assertEqual(config.containers["app_3"].container_name, "abc_3")
def test_parse_1(self):
containers = {
"c1": {"image": "image1", "command": "/bin/bash"},
"c2": {"image": "image2", "links": ["c1"]}
}
d = dict(containers=containers)
config = BlockadeConfig.from_dict(d)
self.assertEqual(len(config.containers), 2)
self.assertEqual(config.containers["c1"].name, "c1")
self.assertEqual(config.containers["c1"].image, "image1")
self.assertEqual(config.containers["c1"].command, "/bin/bash")
self.assertEqual(config.containers["c2"].name, "c2")
self.assertEqual(config.containers["c2"].image, "image2")
def test_parse_with_volumes_2(self):
containers = {
"c1": {
"image": "image1",
"command": "/bin/bash",
"volumes": ["/some/mount"]
}
}
network = {}
d = dict(containers=containers, network=network)
config = BlockadeConfig.from_dict(d)
# default value should be there
self.assertEqual(len(config.containers), 1)
c1 = config.containers['c1']
self.assertEqual(c1.volumes, {"/some/mount": "/some/mount"})
def test_parse_with_name(self):
containers = {
"c1": {
"image": "image1",
"command": "/bin/bash",
"container_name": "abc"
}
}
network = {}
d = dict(containers=containers, network=network)
config = BlockadeConfig.from_dict(d)
# default value should be there
self.assertEqual(len(config.containers), 1)
c1 = config.containers['c1']
self.assertEqual(c1.container_name, "abc")
def create(name):
if not request.headers['Content-Type'] == 'application/json':
abort(415)
if BlockadeManager.blockade_exists(name):
return 'Blockade name already exists', 400
# This will abort with a 400 if the JSON is bad
data = request.get_json()
config = BlockadeConfig.from_dict(data)
BlockadeManager.store_config(name, config)
b = BlockadeManager.get_blockade(name)
containers = b.create()
return '', 204
def test_parse_with_env_1(self):
containers = {
"c1": {
"image": "image1",
"command": "/bin/bash",
"environment": {
"HATS": 4,
"JACKETS": "some"
}
}
}
d = dict(containers=containers, network={})
config = BlockadeConfig.from_dict(d)
self.assertEqual(len(config.containers), 1)
c1 = config.containers['c1']
self.assertEqual(c1.environment, {"HATS": 4, "JACKETS": "some"})
def test_parse_with_publish_1(self):
containers = {
"c1": {
"image": "image1",
"ports": {
8080: 80
},
"expose": [80]
}
}
d = dict(containers=containers, network={})
config = BlockadeConfig.from_dict(d)
self.assertEqual(len(config.containers), 1)
c1 = config.containers['c1']
self.assertEqual(c1.expose_ports, [80])
self.assertEqual(c1.publish_ports, {'8080': '80'})
def test_parse_1(self):
containers = {
"c1": {
"image": "image1",
"command": "/bin/bash"
},
"c2": {
"image": "image2",
"links": ["c1"]
}
}
d = dict(containers=containers)
config = BlockadeConfig.from_dict(d)
self.assertEqual(len(config.containers), 2)
self.assertEqual(config.containers["c1"].name, "c1")
self.assertEqual(config.containers["c1"].image, "image1")
self.assertEqual(config.containers["c1"].command, "/bin/bash")
self.assertEqual(config.containers["c2"].name, "c2")
self.assertEqual(config.containers["c2"].image, "image2")
def test_add_docker_containers(self):
containers = ['id1', 'id2', 'id3']
self.docker_client.inspect_container.side_effect = lambda id: {
"Id": id
}
self.network.get_container_device.side_effect = lambda dc, y: "veth" + y
self.state.exists.side_effect = lambda: False
self.state.container_id.side_effect = lambda name: None
self.state.containers = {}
self.state.blockade_id = self.blockade_id
b = Blockade(BlockadeConfig(),
state=self.state,
network=self.network,
docker_client=self.docker_client)
b.add_container(containers)
self.assertEqual(self.state.update.call_count, 1)
self.assertEqual(len(self.state.containers), 3)
def test_create(self):
containers = [BlockadeContainerConfig("c1", "image"),
BlockadeContainerConfig("c2", "image"),
BlockadeContainerConfig("c3", "image")]
config = BlockadeConfig(containers)
self.network.new_veth_device_name.side_effect = ["veth1", "veth2",
"veth3"]
initialize = lambda x: BlockadeState("ourblockadeid", x)
self.state_factory.initialize.side_effect = initialize
self.docker_client.create_container.side_effect = [
{"Id": "container1"},
{"Id": "container2"},
{"Id": "container3"}]
b = Blockade(config, self.state_factory, self.network,
self.docker_client)
b.create()
self.assertEqual(self.state_factory.initialize.call_count, 1)
self.assertEqual(self.docker_client.create_container.call_count, 3)
def test_get_container_description_ip_address_info(self):
expected_ip = "1.2.3.4"
self.docker_client.inspect_container.side_effect = lambda id: {
"Id": id,
"IPAddress": "",
"NetworkSettings": {
"Networks": {
"TheOnlyNetwork": {
"IPAddress": expected_ip
}
}
}
}
b = Blockade(BlockadeConfig(),
state=self.state,
network=self.network,
docker_client=self.docker_client)
container = b._get_container_description("c1")
self.assertEqual(expected_ip, container.ip_address)
def test_parse_with_count_1(self):
containers = {
"db": {
"image": "image1",
"command": "/bin/bash",
"count": 2
},
"app": {
"image": "image1",
"command": "/bin/bash",
"container_name": "abc",
"count": 3
}
}
d = dict(containers=containers, network={})
config = BlockadeConfig.from_dict(d)
self.assertEqual(set(config.containers.keys()),
set(["db_1", "db_2", "app_1", "app_2", "app_3"]))
self.assertEqual(config.containers["app_1"].container_name, "abc_1")
self.assertEqual(config.containers["app_2"].container_name, "abc_2")
self.assertEqual(config.containers["app_3"].container_name, "abc_3")
