def test_add_route_with_content(self, LoadBalancer):
self.storage.store_binding("inst", "app.host.com")
lb = LoadBalancer.find.return_value
lb.hosts = [mock.Mock(), mock.Mock()]
manager = Manager(self.config)
manager.consul_manager = mock.Mock()
manager.add_route("inst", "/somewhere", None, "location /x { something; }")
LoadBalancer.find.assert_called_with("inst")
binding_data = self.storage.find_binding("inst")
self.assertDictEqual(binding_data, {
"_id": "inst",
"app_host": "app.host.com",
"paths": [
{
"path": "/",
"destination": "app.host.com",
},
{
"path": "/somewhere",
"destination": None,
"content": "location /x { something; }",
}
]
})
manager.consul_manager.write_location.assert_called_with("inst", "/somewhere", destination=None,
content="location /x { something; }")
def test_list_block(self, LoadBalancer):
lb = LoadBalancer.find.return_value
lb.hosts = [mock.Mock(), mock.Mock()]
manager = Manager(self.config)
manager.consul_manager = mock.Mock()
manager.consul_manager.list_blocks.return_value = [
'9796', [{u'LockIndex': 0,
u'ModifyIndex': 9796,
u'Value': 'something nice in server',
u'Flags': 0,
u'Key': u'test-suite-rpaas/myrpaas/blocks/server/ROOT',
u'CreateIndex': 9796},
{u'LockIndex': 0,
u'ModifyIndex': 9796,
u'Value': 'something nice in http',
u'Flags': 0,
u'Key': u'test-suite-rpaas/myrpaas/blocks/http/ROOT',
u'CreateIndex': 9796}]
]
blocks = manager.list_blocks("inst")
self.assertDictEqual(blocks[0], {'block_name': 'server',
'content': 'something nice in server'})
self.assertDictEqual(blocks[1], {'block_name': 'http',
'content': 'something nice in http'})
LoadBalancer.find.assert_called_with("inst")
manager.consul_manager.list_blocks.assert_called_with("inst")
def test_remove_instance_remove_task_on_exception(self):
self.storage.store_instance_metadata("x", plan_name="small")
lb = self.LoadBalancer.find.return_value
lb.hosts = [mock.Mock(side_effect=Exception("test"))]
manager = Manager(self.config)
manager.consul_manager = mock.Mock()
manager.remove_instance("x")
self.assertEquals(self.storage.find_task("x").count(), 0)
def test_delete_block(self, LoadBalancer):
lb = LoadBalancer.find.return_value
lb.hosts = [mock.Mock(), mock.Mock()]
manager = Manager(self.config)
manager.consul_manager = mock.Mock()
manager.delete_block("inst", "http")
LoadBalancer.find.assert_called_with("inst")
manager.consul_manager.remove_block.assert_called_with("inst", "http")
def test_update_certificate(self, LoadBalancer):
self.storage.store_binding("inst", "app.host.com")
lb = LoadBalancer.find.return_value
lb.hosts = [mock.Mock(), mock.Mock()]
manager = Manager(self.config)
manager.consul_manager = mock.Mock()
manager.update_certificate("inst", "cert", "key")
LoadBalancer.find.assert_called_with("inst")
manager.consul_manager.set_certificate.assert_called_with("inst", "cert", "key")
def test_add_block_with_content(self, LoadBalancer):
lb = LoadBalancer.find.return_value
lb.hosts = [mock.Mock(), mock.Mock()]
manager = Manager(self.config)
manager.consul_manager = mock.Mock()
manager.add_block("inst", "server", "location /x { something; }")
LoadBalancer.find.assert_called_with("inst")
manager.consul_manager.write_block.assert_called_with(
"inst", "server", "location /x { something; }"
)
def test_empty_list_blocks(self, LoadBalancer):
lb = LoadBalancer.find.return_value
lb.hosts = [mock.Mock(), mock.Mock()]
manager = Manager(self.config)
manager.consul_manager = mock.Mock()
manager.consul_manager.list_blocks.return_value = []
blocks = manager.list_blocks("inst")
self.assertEqual(blocks, [])
LoadBalancer.find.assert_called_with("inst")
manager.consul_manager.list_blocks.assert_called_with("inst")
def test_node_status_no_hostname(self, LoadBalancer):
lb = LoadBalancer.find.return_value
lb.hosts = [mock.Mock(), mock.Mock()]
lb.hosts[0].dns_name = '10.1.1.1'
lb.hosts[1].dns_name = '10.2.2.2'
manager = Manager(self.config)
manager.consul_manager = mock.Mock()
manager.consul_manager.node_hostname.side_effect = ['vm-1', None]
manager.consul_manager.node_status.return_value = {'vm-1': 'OK', 'vm-2': 'DEAD'}
node_status = manager.node_status("x")
LoadBalancer.find.assert_called_with("x")
self.assertDictEqual(node_status, {'vm-1': {'status': 'OK', 'address': '10.1.1.1'},
'vm-2': {'status': 'DEAD'}})
def test_purge_location(self, LoadBalancer):
lb = LoadBalancer.find.return_value
lb.hosts = [mock.Mock(), mock.Mock()]
manager = Manager(self.config)
manager.nginx_manager = mock.Mock()
manager.nginx_manager.purge_location.side_effect = [True, True]
purged_hosts = manager.purge_location("inst", "/foo/bar")
LoadBalancer.find.assert_called_with("inst")
self.assertEqual(purged_hosts, 2)
manager.nginx_manager.purge_location.assert_any_call(lb.hosts[0].dns_name, "/foo/bar")
manager.nginx_manager.purge_location.assert_any_call(lb.hosts[1].dns_name, "/foo/bar")
def test_unbind_instance(self, LoadBalancer):
self.storage.store_binding("inst", "app.host.com")
lb = LoadBalancer.find.return_value
lb.hosts = [mock.Mock(), mock.Mock()]
manager = Manager(self.config)
manager.consul_manager = mock.Mock()
manager.unbind("inst", "app.host.com")
binding_data = self.storage.find_binding("inst")
self.assertDictEqual(binding_data, {
"_id": "inst",
"paths": []
})
LoadBalancer.find.assert_called_with("inst")
manager.consul_manager.remove_location.assert_called_with("inst", "/")
def test_remove_instance_no_token(self):
self.storage.store_task("x")
self.storage.store_instance_metadata("x", plan_name="small")
lb = self.LoadBalancer.find.return_value
lb.hosts = [mock.Mock()]
manager = Manager(self.config)
manager.consul_manager = mock.Mock()
manager.remove_instance("x")
self.LoadBalancer.find.assert_called_with("x", self.config)
for h in lb.hosts:
h.destroy.assert_called_once()
lb.destroy.assert_called_once()
self.assertEquals(self.storage.find_task("x").count(), 0)
self.assertIsNone(self.storage.find_instance_metadata("x"))
manager.consul_manager.destroy_token.assert_not_called()
def test_scale_instance_down_with_healing_enabled(self, consul_manager):
consul = consul_manager.ConsulManager.return_value
config = copy.deepcopy(self.config)
lb = self.LoadBalancer.find.return_value
lb.hosts = [mock.Mock(), mock.Mock()]
lb.hosts[0].dns_name = '10.2.2.2'
self.storage.store_instance_metadata("x", consul_token="abc-123")
self.addCleanup(self.storage.remove_instance_metadata, "x")
consul.node_hostname.return_value = 'rpaas-2'
manager = Manager(config)
manager.consul_manager = mock.Mock()
manager.consul_manager.generate_token.return_value = "abc-123"
manager.scale_instance("x", 1)
lb.hosts[0].destroy.assert_called_once
lb.remove_host.assert_called_once_with(lb.hosts[0])
consul.remove_node.assert_called_once_with('x', 'rpaas-2')
def test_bind_instance(self, LoadBalancer):
lb = LoadBalancer.find.return_value
lb.hosts = [mock.Mock(), mock.Mock()]
lb.hosts[0].dns_name = "h1"
lb.hosts[1].dns_name = "h2"
manager = Manager(self.config)
manager.consul_manager = mock.Mock()
manager.bind("x", "apphost.com")
binding_data = self.storage.find_binding("x")
self.assertDictEqual(binding_data, {
"_id": "x",
"app_host": "apphost.com",
"paths": [{"path": "/", "destination": "apphost.com"}]
})
LoadBalancer.find.assert_called_with("x")
manager.consul_manager.write_location.assert_called_with("x", "/", destination="apphost.com")
def test_new_instance(self, nginx):
manager = Manager(self.config)
manager.consul_manager = mock.Mock()
manager.consul_manager.generate_token.return_value = "abc-123"
manager.new_instance("x")
host = self.Host.create.return_value
lb = self.LoadBalancer.create.return_value
config = copy.deepcopy(self.config)
config["HOST_TAGS"] = "rpaas_service:test-suite-rpaas,rpaas_instance:x,consul_token:abc-123"
self.Host.create.assert_called_with("my-host-manager", "x", config)
self.LoadBalancer.create.assert_called_with("my-lb-manager", "x", config)
lb.add_host.assert_called_with(host)
self.assertEquals(self.storage.find_task("x").count(), 0)
nginx.Nginx.assert_called_once_with(config)
nginx_manager = nginx.Nginx.return_value
nginx_manager.wait_healthcheck.assert_called_once_with(host.dns_name, timeout=600)
manager.consul_manager.write_healthcheck.assert_called_once_with("x")
def test_remove_instance(self):
self.storage.store_instance_metadata("x", plan_name="small", consul_token="abc-123")
lb = self.LoadBalancer.find.return_value
lb.hosts = [mock.Mock()]
manager = Manager(self.config)
manager.consul_manager = mock.Mock()
manager.remove_instance("x")
config = copy.deepcopy(self.config)
config.update(self.plan["config"])
self.LoadBalancer.find.assert_called_with("x", config)
for h in lb.hosts:
h.destroy.assert_called_once()
lb.destroy.assert_called_once()
self.assertEquals(self.storage.find_task("x").count(), 0)
self.assertIsNone(self.storage.find_instance_metadata("x"))
manager.consul_manager.destroy_token.assert_called_with("abc-123")
manager.consul_manager.destroy_instance.assert_called_with("x")
def test_unbind_instance_with_extra_path(self, LoadBalancer):
self.storage.store_binding("inst", "app.host.com")
self.storage.replace_binding_path("inst", "/me", "somewhere.com")
lb = LoadBalancer.find.return_value
lb.hosts = [mock.Mock(), mock.Mock()]
manager = Manager(self.config)
manager.consul_manager = mock.Mock()
manager.unbind("inst", "app.host.com")
binding_data = self.storage.find_binding("inst")
self.assertDictEqual(binding_data, {
"_id": "inst",
"paths": [
{"path": "/me", "destination": "somewhere.com", "content": None}
]
})
LoadBalancer.find.assert_called_with("inst")
manager.consul_manager.remove_location.assert_called_with("inst", "/")
def test_delete_route(self, LoadBalancer):
self.storage.store_binding("inst", "app.host.com")
self.storage.replace_binding_path("inst", "/arrakis", "dune.com")
lb = LoadBalancer.find.return_value
lb.hosts = [mock.Mock(), mock.Mock()]
manager = Manager(self.config)
manager.consul_manager = mock.Mock()
manager.delete_route("inst", "/arrakis")
LoadBalancer.find.assert_called_with("inst")
binding_data = self.storage.find_binding("inst")
self.assertDictEqual(binding_data, {
"_id": "inst",
"app_host": "app.host.com",
"paths": [{"path": "/", "destination": "app.host.com"}]
})
manager.consul_manager.remove_location.assert_called_with("inst", "/arrakis")
def test_scale_instance_up_no_token(self, nginx):
lb = self.LoadBalancer.find.return_value
lb.name = "x"
lb.hosts = [mock.Mock(), mock.Mock()]
config = copy.deepcopy(self.config)
config["HOST_TAGS"] = "rpaas_service:test-suite-rpaas,rpaas_instance:x,consul_token:abc-123"
manager = Manager(self.config)
manager.consul_manager = mock.Mock()
manager.consul_manager.generate_token.return_value = "abc-123"
manager.scale_instance("x", 5)
self.Host.create.assert_called_with("my-host-manager", "x", config)
self.assertEqual(self.Host.create.call_count, 3)
lb.add_host.assert_called_with(self.Host.create.return_value)
self.assertEqual(lb.add_host.call_count, 3)
nginx_manager = nginx.Nginx.return_value
created_host = self.Host.create.return_value
expected_calls = [mock.call(created_host.dns_name, timeout=600),
mock.call(created_host.dns_name, timeout=600),
mock.call(created_host.dns_name, timeout=600)]
self.assertEqual(expected_calls, nginx_manager.wait_healthcheck.call_args_list)
def test_list_block(self, LoadBalancer):
lb = LoadBalancer.find.return_value
lb.hosts = [mock.Mock(), mock.Mock()]
manager = Manager(self.config)
manager.consul_manager = mock.Mock()
manager.consul_manager.list_blocks.return_value = [
{u'block_name': 'server',
u'content': 'something nice in server'},
{u'block_name': 'http',
u'content': 'something nice in http'}
]
blocks = manager.list_blocks("inst")
self.assertDictEqual(blocks[0], {'block_name': 'server',
'content': 'something nice in server'})
self.assertDictEqual(blocks[1], {'block_name': 'http',
'content': 'something nice in http'})
LoadBalancer.find.assert_called_with("inst")
manager.consul_manager.list_blocks.assert_called_with("inst")
def test_bind_instance_multiple_bind_hosts(self, LoadBalancer):
lb = LoadBalancer.find.return_value
lb.hosts = [mock.Mock(), mock.Mock()]
manager = Manager(self.config)
manager.consul_manager = mock.Mock()
manager.bind("x", "apphost.com")
binding_data = self.storage.find_binding("x")
self.assertDictEqual(binding_data, {
"_id": "x",
"app_host": "apphost.com",
"paths": [{"path": "/", "destination": "apphost.com"}]
})
LoadBalancer.find.assert_called_with("x")
manager.consul_manager.write_location.assert_called_with("x", "/", destination="apphost.com")
manager.consul_manager.reset_mock()
manager.bind("x", "apphost.com")
self.assertEqual(0, len(manager.consul_manager.mock_calls))
with self.assertRaises(rpaas.manager.BindError):
manager.bind("x", "another.host.com")
self.assertEqual(0, len(manager.consul_manager.mock_calls))
def test_add_route_no_binding_creates_one(self, LoadBalancer):
lb = LoadBalancer.find.return_value
lb.hosts = [mock.Mock(), mock.Mock()]
manager = Manager(self.config)
manager.consul_manager = mock.Mock()
manager.add_route("inst", "/somewhere", "my.other.host", None)
LoadBalancer.find.assert_called_with("inst")
binding_data = self.storage.find_binding("inst")
self.assertDictEqual(binding_data, {
"_id": "inst",
"paths": [
{
"path": "/somewhere",
"destination": "my.other.host",
"content": None,
}
]
})
manager.consul_manager.write_location.assert_called_with("inst", "/somewhere",
destination="my.other.host",
content=None)
def test_info_status_pending(self, tasks):
self.storage.store_task("x")
self.storage.update_task("x", "something-id")
async_init = tasks.NewInstanceTask.return_value.AsyncResult
async_init.return_value.status = "PENDING"
manager = Manager(self.config)
info = manager.info("x")
self.assertItemsEqual(info, [
{
"label": "Address",
"value": "pending"
},
{
"label": "Instances",
"value": "0"
},
{
"label": "Routes",
"value": ""
},
])
async_init.assert_called_with("something-id")
self.assertEqual(manager.status("x"), "pending")
def test_scale_instance_up(self, nginx):
lb = self.LoadBalancer.find.return_value
lb.name = "x"
lb.hosts = [mock.Mock(), mock.Mock()]
self.storage.store_instance_metadata("x", consul_token="abc-123")
self.addCleanup(self.storage.remove_instance_metadata, "x")
config = copy.deepcopy(self.config)
config[
"HOST_TAGS"] = "rpaas_service:test-suite-rpaas,rpaas_instance:x,consul_token:abc-123"
manager = Manager(self.config)
manager.scale_instance("x", 5)
self.Host.create.assert_called_with("my-host-manager", "x", config)
self.assertEqual(self.Host.create.call_count, 3)
lb.add_host.assert_called_with(self.Host.create.return_value)
self.assertEqual(lb.add_host.call_count, 3)
nginx_manager = nginx.Nginx.return_value
created_host = self.Host.create.return_value
expected_calls = [
mock.call(created_host.dns_name, timeout=600),
mock.call(created_host.dns_name, timeout=600),
mock.call(created_host.dns_name, timeout=600)
]
self.assertEqual(expected_calls,
nginx_manager.wait_healthcheck.call_args_list)
def test_add_route_no_binding_creates_one(self, LoadBalancer, nginx):
lb = LoadBalancer.find.return_value
lb.hosts = [mock.Mock(), mock.Mock()]
manager = Manager(self.config)
manager.add_route("inst", "/somewhere", "my.other.host", None)
LoadBalancer.find.assert_called_with("inst")
binding_data = self.storage.find_binding("inst")
self.assertDictEqual(binding_data, {
"_id": "inst",
"paths": [
{
"path": "/somewhere",
"destination": "my.other.host",
"content": None,
}
]
})
nginx_manager = nginx.NginxDAV.return_value
nginx_manager.update_binding.assert_any_call(
lb.hosts[0].dns_name, "/somewhere", "my.other.host", None)
nginx_manager.update_binding.assert_any_call(
lb.hosts[1].dns_name, "/somewhere", "my.other.host", None)
def test_scale_instance_error_task_running(self):
self.storage.store_task("x")
manager = Manager(self.config)
with self.assertRaises(rpaas.tasks.NotReadyError):
manager.scale_instance("x", 5)
def test_update_certificate_no_binding(self, LoadBalancer):
manager = Manager(self.config)
with self.assertRaises(storage.InstanceNotFoundError):
manager.update_certificate("inst", "cert", "key")
LoadBalancer.find.assert_called_with("inst")
def test_bind_instance_error_task_running(self):
self.storage.store_task("x")
manager = Manager(self.config)
with self.assertRaises(rpaas.tasks.NotReadyError):
manager.bind("x", "apphost.com")
def test_new_instance_error_already_running(self):
self.storage.store_task("x")
manager = Manager(self.config)
with self.assertRaises(storage.DuplicateError):
manager.new_instance("x")
def test_new_instance_plan_not_found(self):
manager = Manager(self.config)
with self.assertRaises(storage.PlanNotFoundError):
manager.new_instance("x", plan_name="supersmall")
def test_add_route_error_task_running(self):
self.storage.store_task("inst")
manager = Manager(self.config)
with self.assertRaises(rpaas.tasks.NotReadyError):
manager.add_route("inst", "/somewhere", "my.other.host", None)
def test_update_certificate_error_task_running(self):
self.storage.store_task("inst")
manager = Manager(self.config)
with self.assertRaises(rpaas.tasks.NotReadyError):
manager.update_certificate("inst", "cert", "key")
def test_new_instance_error_already_exists(self, LoadBalancer):
LoadBalancer.find.return_value = "something"
manager = Manager(self.config)
with self.assertRaises(storage.DuplicateError):
manager.new_instance("x")
LoadBalancer.find.assert_called_once_with("x")
def teste_restore_machine_instance_cancel(self):
manager = Manager(self.config)
self.storage.store_task("restore_10.1.1.1")
manager.restore_machine_instance('foo', '10.1.1.1', True)
task = self.storage.find_task("restore_10.1.1.1")
self.assertEquals(task.count(), 0)
def test_delete_route_error_task_running(self):
self.storage.store_task("inst")
manager = Manager(self.config)
with self.assertRaises(rpaas.tasks.NotReadyError):
manager.delete_route("inst", "/arrakis")
def teste_restore_machine_instance_cancel_invalid_task(self):
manager = Manager(self.config)
with self.assertRaises(rpaas.tasks.TaskNotFoundError):
manager.restore_machine_instance('foo', '10.1.1.1', True)
def test_scale_instance_error(self):
lb = self.LoadBalancer.find.return_value
lb.hosts = [mock.Mock(), mock.Mock()]
manager = Manager(self.config)
with self.assertRaises(ScaleError):
manager.scale_instance("x", 0)
