diff --git a/flameclient/client.py b/flameclient/client.py index 52f2d8b..1be3b38 100644 --- a/flameclient/client.py +++ b/flameclient/client.py @@ -22,6 +22,23 @@ # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. -def template_configuration(allow_insecure=False, exclude_servers=False, - exclude_volumes=False, generate_stack_data=False): - raise NotImplementedError() +from flameclient.flame import TemplateGenerator # noqa + + +class Client(object): + def __init__(self, api_version, **kwargs): + + username = kwargs.get('username') + password = kwargs.get('password') + tenant_name = kwargs.get('tenant_name') + auth_url = kwargs.get('auth_url') + + insecure = kwargs.get('insecure') + self.template_generator = TemplateGenerator(username, password, + tenant_name, auth_url, + insecure) + + def generate(self, include_networks, include_instances, include_volumes): + return self.template_generator.generate(include_networks, + include_instances, + include_volumes) diff --git a/flameclient/cmd.py b/flameclient/cmd.py index 7d82a8f..55c747f 100644 --- a/flameclient/cmd.py +++ b/flameclient/cmd.py @@ -22,13 +22,15 @@ # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. +from __future__ import print_function + import argparse import os from flame import TemplateGenerator -def main(): +def main(args=None): desc = "Heat template and data file generator" parser = argparse.ArgumentParser(description=desc) parser.add_argument("--username", type=str, @@ -65,9 +67,13 @@ def main(): "stack data file.") args = parser.parse_args() - arguments = (args.username, args.password, args.project, args.auth_url, - args.insecure) - TemplateGenerator(args.exclude_servers, - args.exclude_volumes, - args.generate_stack_data, - *arguments).run() + template = TemplateGenerator(args.username, args.password, args.project, + args.auth_url, args.insecure) + template.extract_vm_details(args.exclude_servers, args.exclude_volumes, + args.generate_stack_data) + template.extract_data() + print("### Heat Template ###") + print(template.heat_template()) + if args.generate_stack_data: + print("### Stack Data ###") + print(template.stack_data_template()) diff --git a/flameclient/flame.py b/flameclient/flame.py index 24c84f9..26d4b5d 100644 --- a/flameclient/flame.py +++ b/flameclient/flame.py @@ -30,7 +30,6 @@ import yaml from flameclient import managers - logging.basicConfig(level=logging.ERROR) template_skeleton = ''' @@ -48,26 +47,38 @@ resources: class TemplateGenerator(object): + template = None + stack_data = None - neutron_manager = managers.NeutronManager - nova_manager = managers.NovaManager - cinder_manager = managers.CinderManager - - def __init__(self, exclude_servers, exclude_volumes, - generate_data, *arguments): - self.exclude_servers = exclude_servers - self.exclude_volumes = exclude_volumes - self.generate_data = generate_data + def __init__(self, username, password, tenant_name, auth_url, insecure): + self.generate_data = False + self._setup_templates() + self._setup_managers(username, password, tenant_name, auth_url, + insecure) + def _setup_templates(self): self.template = yaml.load(template_skeleton) self.template['resources'] = {} self.template['parameters'] = {} - if self.generate_data: - self.stack_data = yaml.load(stack_data_skeleton) - self.stack_data['resources'] = {} + self.stack_data = yaml.load(stack_data_skeleton) + self.stack_data['resources'] = {} + + def _setup_managers(self, username, password, tenant_name, auth_url, + insecure): + self.neutron = managers.NeutronManager(username, password, tenant_name, + auth_url, insecure) + self.nova = managers.NovaManager(username, password, tenant_name, + auth_url, insecure) + self.cinder = managers.CinderManager(username, password, tenant_name, + auth_url, insecure) + + def extract_vm_details(self, exclude_servers, exclude_volumes, + generate_data): + self.exclude_servers = exclude_servers + self.exclude_volumes = exclude_volumes + self.generate_data = generate_data - self.neutron = self.neutron_manager(*arguments) self.subnets = self.build_data(self.neutron.subnet_list()) self.networks = self.build_data(self.neutron.network_list()) self.routers = self.neutron.router_list() @@ -76,18 +87,16 @@ class TemplateGenerator(object): self.ports = self.build_data(self.neutron.port_list()) self.external_networks = [] - self.nova = self.nova_manager(*arguments) self.keys = dict( (key.name, (index, key)) for index, key in enumerate(self.nova.keypair_list())) - if not self.exclude_servers: + if not exclude_servers: self.flavors = self.build_data(self.nova.flavor_list()) self.servers = self.build_data(self.nova.server_list()) - if (not self.exclude_volumes or - (self.exclude_volumes and not self.exclude_servers)): - self.cinder = self.cinder_manager(*arguments) + if (not exclude_volumes or + (exclude_volumes and not exclude_servers)): self.volumes = self.build_data(self.cinder.volume_list()) def build_data(self, data): @@ -101,9 +110,9 @@ class TemplateGenerator(object): return dict((element.id, (index, element)) for index, element in enumerate(data)) - def print_generated(self, file, message): - print("########## %s ##########" % message) - print(yaml.safe_dump(file, default_flow_style=False)) + @staticmethod + def print_generated(filename): + print(yaml.safe_dump(filename, default_flow_style=False)) def add_resource(self, name, status, resource_id, resource_type): resource = { @@ -191,7 +200,7 @@ class TemplateGenerator(object): } self.template['resources'].update(resource) - def extract_routers(self): + def _extract_routers(self): for n, router in enumerate(self.routers): router_resource_name = "router_%d" % n resource_type = 'OS::Neutron::Router' @@ -219,7 +228,7 @@ class TemplateGenerator(object): self.add_router_gateway_resource(router_resource_name, router) - def extract_networks(self): + def _extract_networks(self): for n, network in self.networks.itervalues(): if network['router:external']: self.external_networks.append(network['id']) @@ -245,13 +254,13 @@ class TemplateGenerator(object): } self.template['resources'].update(resource) - def get_network_resource_name(self, id): - return "network_%d" % self.networks[id][0] + def get_network_resource_name(self, network_id): + return "network_%d" % self.networks[network_id][0] - def get_subnet_resource_name(self, id): - return "subnet_%d" % self.subnets[id][0] + def get_subnet_resource_name(self, subnet_id): + return "subnet_%d" % self.subnets[subnet_id][0] - def extract_subnets(self): + def _extract_subnets(self): for n, subnet in self.subnets.itervalues(): if subnet['network_id'] in self.external_networks: continue @@ -301,7 +310,7 @@ class TemplateGenerator(object): brules.append(rule) return brules - def extract_secgroups(self): + def _extract_secgroups(self): for n, secgroup in self.secgroups.itervalues(): resource_name = "security_group_%d" % n @@ -330,7 +339,7 @@ class TemplateGenerator(object): } self.template['resources'].update(resource) - def extract_keys(self): + def _extract_keys(self): for n, key in self.keys.itervalues(): key_resource_name = "key_%d" % n resource_type = 'OS::Nova::KeyPair' @@ -390,7 +399,7 @@ class TemplateGenerator(object): networks.append({'network': {'get_resource': net}}) return networks - def extract_servers(self): + def _extract_servers(self): for n, server in self.servers.itervalues(): resource_name = "server_%d" % n resource_type = 'OS::Nova::Server' @@ -475,7 +484,7 @@ class TemplateGenerator(object): } self.template['resources'].update(resource) - def extract_floating(self): + def _extract_floating(self): for n, ip in enumerate(self.floatingips): ip_resource_name = "floatingip_%d" % n net_param_name = "external_network_for_floating_ip_%d" % n @@ -523,7 +532,7 @@ class TemplateGenerator(object): self.template['resources'].update(resource) self.template['resources'].update(floating_resource) - def extract_volumes(self): + def _extract_volumes(self): for n, volume in self.volumes.itervalues(): resource_name = "volume_%d" % n resource_type = 'OS::Cinder::Volume' @@ -582,21 +591,20 @@ class TemplateGenerator(object): } self.template['resources'].update(resource) - def run(self): - self.extract_routers() - self.extract_networks() - self.extract_subnets() - self.extract_secgroups() - self.extract_floating() - self.extract_keys() - + def extract_data(self): + self._extract_routers() + self._extract_networks() + self._extract_subnets() + self._extract_secgroups() + self._extract_floating() + self._extract_keys() if not self.exclude_servers: - self.extract_servers() - + self._extract_servers() if not self.exclude_volumes: - self.extract_volumes() + self._extract_volumes() - self.print_generated(self.template, "Heat Template") + def heat_template(self): + return self.print_generated(self.template) - if self.generate_data: - self.print_generated(self.stack_data, "Heat Stack Data") + def stack_data_template(self): + return self.print_generated(self.stack_data) diff --git a/flameclient/managers.py b/flameclient/managers.py index 6632cff..152c6e1 100644 --- a/flameclient/managers.py +++ b/flameclient/managers.py @@ -30,108 +30,171 @@ from novaclient.v1_1 import client as nova_client class KeystoneManager(object): """Manages Keystone queries.""" + _client = None def __init__(self, username, password, project, auth_url, insecure): - self.client = keystone_client.Client( - username=username, password=password, - tenant_name=project, auth_url=auth_url, insecure=insecure) + self.username = username + self.password = password + self.project = project + self.auth_url = auth_url + self.insecure = insecure + + def client(self): + if not self._client: + self._client = keystone_client.Client(username=self.username, + password=self.password, + tenant_name=self.project, + auth_url=self.auth_url, + insecure=self.insecure) + return self._client + + def set_client(client): + self._client = client def get_token(self): - return self.client.auth_token + return self.client().auth_token def get_endpoint(self, service_type, endpoint_type="publicURL"): - catalog = self.client.service_catalog.get_endpoints() + catalog = self.client().service_catalog.get_endpoints() return catalog[service_type][0][endpoint_type] def get_project_id(self): - return self.client.tenant_id + return self.client().tenant_id class NeutronManager(object): + _client = None + _project_id = None + def __init__(self, username, password, project, auth_url, insecure): - self.client = neutron_client.Client( - username=username, password=password, - tenant_name=project, auth_url=auth_url, - insecure=insecure) - keystone_mgr = KeystoneManager(username, password, project, - auth_url, insecure) - self.project_id = keystone_mgr.get_project_id() + self.username = username + self.password = password + self.project = project + self.auth_url = auth_url + self.insecure = insecure + + def client(self): + if not self._client: + self._client = neutron_client.Client(username=self.username, + password=self.password, + tenant_name=self.project, + auth_url=self.auth_url, + insecure=self.insecure) + if not self._project_id: + keystone_mgr = KeystoneManager(self.username, self.password, + self.project, self.auth_url, + self.insecure) + self._project_id = keystone_mgr.get_project_id() + return self._client + + def set_client(self, client): + self._client = client + + def set_project_id(self, project_id): + self._project_id = project_id def router_list(self): return filter(self._owned_resource, - self.client.list_routers()['routers']) + self.client().list_routers()['routers']) def router_interfaces_list(self, router): - return self.client.list_ports(device_id=router['id'])['ports'] + return self._client.list_ports(device_id=router['id'])['ports'] def port_list(self): - return self.client.list_ports()['ports'] + return self.client().list_ports()['ports'] def network_list(self): return filter(self._owned_resource, - self.client.list_networks()['networks']) + self.client().list_networks()['networks']) def secgroup_list(self): return filter(self._owned_resource, - self.client.list_security_groups()['security_groups']) + self.client().list_security_groups()['security_groups']) def floatingip_list(self): return filter(self._owned_resource, - self.client.list_floatingips()['floatingips']) + self.client().list_floatingips()['floatingips']) def subnet_list(self): return filter(self._owned_resource, - self.client.list_subnets()['subnets']) + self.client().list_subnets()['subnets']) def _owned_resource(self, res): # Only considering resources owned by project - return res['tenant_id'] == self.project_id + return res['tenant_id'] == self._project_id class NovaManager(object): """Manage nova resources.""" + _client = None def __init__(self, username, password, project, auth_url, insecure): - self.client = nova_client.Client(username, password, project, - auth_url, insecure=insecure) + self.username = username + self.password = password + self.project = project + self.auth_url = auth_url + self.insecure = insecure + + def client(self): + if not self._client: + self._client = nova_client.Client(self.username, self.password, + self.project, self.auth_url, + insecure=self.insecure) + return self._client + + def set_client(self, client): + self._client = client def server_list(self): - return self.client.servers.list() + return self.client().servers.list() def floating_ip_list(self): - return self.client.floating_ips.list() + return self.client().floating_ips.list() def flavor_list(self): - return self.client.flavors.list() + return self.client().flavors.list() def flavor_get(self, id): - return self.client.flavors.get(id) + return self.client().flavors.get(id) def keypair_list(self): - return self.client.keypairs.list() + return self.client().keypairs.list() def keypair_show(self, keypair): - return self.client.keypairs.get(keypair) + return self.client().keypairs.get(keypair) def server_security_group_list(self, server): - return self.client.servers.list_security_group(server) + return self.client().servers.list_security_group(server) class CinderManager(object): """Manage Cinder resources.""" + _client = None def __init__(self, username, password, project, auth_url, insecure): - self.client = cinder_client.Client(username, - password, - project, - auth_url, - insecure=insecure) + self.username = username + self.password = password + self.project = project + self.auth_url = auth_url + self.insecure = insecure + + def client(self): + if not self._client: + self._client = cinder_client.Client(self.username, + self.password, + self.project, + self.auth_url, + insecure=self.insecure) + return self._client + + def set_client(self, client): + self._client = client def volume_list(self): volumes = [] - for vol in self.client.volumes.list(): - volumes.append(self.client.volumes.get(vol.id)) + for vol in self.client().volumes.list(): + volumes.append(self.client().volumes.get(vol.id)) return volumes def snapshot_list(self): - return self.client.volume_snapshots.list() + return self.client().volume_snapshots.list() diff --git a/flameclient/tests/base.py b/flameclient/tests/base.py index 3bf12a8..6e93268 100644 --- a/flameclient/tests/base.py +++ b/flameclient/tests/base.py @@ -50,4 +50,4 @@ class TestCase(testtools.TestCase): stderr = self.useFixture(fixtures.StringStream('stderr')).stream self.useFixture(fixtures.MonkeyPatch('sys.stderr', stderr)) - self.log_fixture = self.useFixture(fixtures.FakeLogger()) \ No newline at end of file + self.log_fixture = self.useFixture(fixtures.FakeLogger()) diff --git a/flameclient/tests/test_flame.py b/flameclient/tests/test_flame.py index 583a7ab..2e2e591 100644 --- a/flameclient/tests/test_flame.py +++ b/flameclient/tests/test_flame.py @@ -24,6 +24,9 @@ import datetime +import mock + +import flameclient from flameclient.flame import TemplateGenerator # noqa from flameclient.tests import base @@ -83,10 +86,19 @@ class FakeSecurityGroup(FakeBase): class FakeNeutronManager(object): groups = [] - routers = [] + routers = [{'name': 'myrouter', + 'id': '1234', + 'admin_state_up': 'true', + 'external_gateway_info': None}, ] ports = [] subnets = [] - networks = [] + networks = [{'status': 'ACTIVE', + 'subnets': ['1111'], + 'name': 'mynetwork', + 'router:external': False, + 'admin_state_up': True, + 'shared': False, + 'id': '2222'}, ] floatingips = [] def subnet_list(self): @@ -113,7 +125,7 @@ class FakeNeutronManager(object): class FakeNovaManager(object): - servers = [] + servers = [FakeServer()] flavors = [FakeFlavor(id='2', name='m1.small')] groups = {} keypairs = [FakeKeypair(name='testkey', public_key='ssh-rsa XXXX')] @@ -133,7 +145,7 @@ class FakeNovaManager(object): class FakeCinderManager(object): - volumes = [] + volumes = [FakeVolume(), ] def volume_list(self): return self.volumes @@ -142,15 +154,24 @@ class FakeCinderManager(object): class StackDataTests(base.TestCase): def setUp(self): super(StackDataTests, self).setUp() - self.neutron_manager = FakeNeutronManager() - TemplateGenerator.neutron_manager = (lambda x: self.neutron_manager) - self.nova_manager = FakeNovaManager() - TemplateGenerator.nova_manager = (lambda x: self.nova_manager) - self.cinder_manager = FakeCinderManager() - TemplateGenerator.cinder_manager = (lambda x: self.cinder_manager) + self.patch_neutron = mock.patch('flameclient.managers.NeutronManager') + self.mock_neutron = self.patch_neutron.start() + self.patch_nova = mock.patch('flameclient.managers.NovaManager') + self.mock_nova = self.patch_nova.start() + self.patch_cinder = mock.patch('flameclient.managers.CinderManager') + self.mock_cinder = self.patch_cinder.start() + + def tearDown(self): + super(StackDataTests, self).tearDown() + self.mock_neutron.stop() + self.mock_nova.stop() + self.mock_cinder.stop() def test_keypair(self): - generator = TemplateGenerator(False, False, True) + self.mock_nova.return_value = FakeNovaManager() + generator = TemplateGenerator('x', 'x', 'x', 'x', True) + generator.extract_vm_details(False, False, True) + expected = { 'action': 'CREATE', 'status': 'COMPLETE', @@ -166,18 +187,14 @@ class StackDataTests(base.TestCase): } } } - generator.extract_keys() + generator._extract_keys() self.assertEqual(expected, generator.stack_data) def test_router(self): - router = { - 'name': 'myrouter', - 'id': '1234', - 'admin_state_up': 'true', - 'external_gateway_info': None - } - self.neutron_manager.routers = [router] - generator = TemplateGenerator(False, False, True) + self.mock_neutron.return_value = FakeNeutronManager() + generator = TemplateGenerator('x', 'x', 'x', 'x', True) + generator.extract_vm_details(False, False, True) + expected = { 'action': 'CREATE', 'status': 'COMPLETE', @@ -193,21 +210,21 @@ class StackDataTests(base.TestCase): } } } - generator.extract_routers() + generator._extract_routers() self.assertEqual(expected, generator.stack_data) def test_router_with_external_gateway(self): - router = { - 'name': 'myrouter', - 'id': '1234', - 'admin_state_up': 'true', - 'external_gateway_info': { - 'network_id': '8765', - 'enable_snat': 'true' - } - } - self.neutron_manager.routers = [router] - generator = TemplateGenerator(False, False, True) + fake = FakeNeutronManager() + fake.routers = [{'name': 'myrouter', + 'id': '1234', + 'admin_state_up': 'true', + 'external_gateway_info': { + 'network_id': '8765', + 'enable_snat': 'true'}}, ] + self.mock_neutron.return_value = fake + generator = TemplateGenerator('x', 'x', 'x', 'x', True) + generator.extract_vm_details(False, False, True) + expected = { 'action': 'CREATE', 'status': 'COMPLETE', @@ -233,50 +250,41 @@ class StackDataTests(base.TestCase): } } - generator.extract_routers() + generator._extract_routers() self.assertEqual(expected, generator.stack_data) def test_router_with_ports(self): - router = { - 'name': 'myrouter', - 'id': '1234', - 'admin_state_up': 'true', - 'external_gateway_info': None - } - port = { - 'status': 'ACTIVE', - 'name': '', - 'allowed_address_pairs': [], - 'admin_state_up': True, - 'network_id': '4444', - 'extra_dhcp_opts': [], - 'binding:vnic_type': 'normal', - 'device_owner': 'network:router_interface', - 'mac_address': 'fa:16:3e:4b:8c:98', - 'fixed_ips': [{'subnet_id': '1111', 'ip_address': '10.123.2.3'}], - 'id': '1234567', - 'security_groups': [], - 'device_id': '1234' - } - subnet = { - 'name': 'subnet_1111', - 'enable_dhcp': True, - 'network_id': '1234', - 'dns_nameservers': [], - 'allocation_pools': [{'start': '10.123.2.2', - 'end': '10.123.2.30'}], - 'host_routes': [], - 'ip_version': 4, - 'gateway_ip': '10.123.2.1', - 'cidr': '10.123.2.0/27', - 'id': '1111' - } + fake = FakeNeutronManager() + fake.ports = [{'status': 'ACTIVE', + 'name': '', + 'allowed_address_pairs': [], + 'admin_state_up': True, + 'network_id': '4444', + 'extra_dhcp_opts': [], + 'binding:vnic_type': 'normal', + 'device_owner': 'network:router_interface', + 'mac_address': 'fa:16:3e:4b:8c:98', + 'fixed_ips': [{'subnet_id': '1111', + 'ip_address': '10.123.2.3'}], + 'id': '1234567', + 'security_groups': [], + 'device_id': '1234'}, ] + fake.subnets = [{'name': 'subnet_1111', + 'enable_dhcp': True, + 'network_id': '1234', + 'dns_nameservers': [], + 'allocation_pools': [{'start': '10.123.2.2', + 'end': '10.123.2.30'}], + 'host_routes': [], + 'ip_version': 4, + 'gateway_ip': '10.123.2.1', + 'cidr': '10.123.2.0/27', + 'id': '1111'}, ] - self.neutron_manager.ports = [port] - self.neutron_manager.subnets = [subnet] - self.neutron_manager.routers = [router] + self.mock_neutron.return_value = fake + generator = TemplateGenerator('x', 'x', 'x', 'x', True) + generator.extract_vm_details(False, False, True) - generator = TemplateGenerator(False, False, True) expected = { 'action': 'CREATE', 'status': 'COMPLETE', @@ -301,21 +309,15 @@ class StackDataTests(base.TestCase): } } } - generator.extract_routers() + generator._extract_routers() self.assertEqual(expected, generator.stack_data) def test_network(self): - network = { - 'status': 'ACTIVE', - 'subnets': ['1111'], - 'name': 'mynetwork', - 'router:external': False, - 'admin_state_up': True, - 'shared': False, - 'id': '2222' - } - self.neutron_manager.networks = [network] - generator = TemplateGenerator(False, False, True) + fake = FakeNeutronManager() + self.mock_neutron.return_value = FakeNeutronManager() + generator = TemplateGenerator('x', 'x', 'x', 'x', True) + generator.extract_vm_details(False, False, True) + expected = { 'action': 'CREATE', 'status': 'COMPLETE', @@ -331,56 +333,43 @@ class StackDataTests(base.TestCase): } } } - generator.extract_networks() + generator._extract_networks() self.assertEqual(expected, generator.stack_data) def test_external_network(self): - network = { - 'status': 'ACTIVE', - 'subnets': ['1111'], - 'name': 'internet', - 'router:external': True, - 'admin_state_up': True, - 'shared': False, - 'id': '2222' - } - self.neutron_manager.networks = [network] - generator = TemplateGenerator(False, False, True) + fake = FakeNeutronManager() + fake.networks[0]['router:external'] = True + self.mock_neutron.return_value = fake + + generator = TemplateGenerator('x', 'x', 'x', 'x', True) + generator.extract_vm_details(False, False, True) + expected = { 'action': 'CREATE', 'status': 'COMPLETE', 'resources': {} } - generator.extract_networks() + generator._extract_networks() self.assertEqual(expected, generator.stack_data) def test_subnet(self): - network = { - 'status': 'ACTIVE', - 'subnets': ['1111'], - 'name': 'mynetwork', - 'router:external': False, - 'admin_state_up': True, - 'shared': False, - 'id': '2222' - } - subnet = { - 'name': 'subnet_1111', - 'enable_dhcp': True, - 'network_id': '2222', - 'dns_nameservers': [], - 'allocation_pools': [{'start': '10.123.2.2', - 'end': '10.123.2.30'}], - 'host_routes': [], - 'ip_version': 4, - 'gateway_ip': '10.123.2.1', - 'cidr': '10.123.2.0/27', - 'id': '1111' - } - self.neutron_manager.networks = [network] - self.neutron_manager.subnets = [subnet] + fake = FakeNeutronManager() + fake.subnets = [{'name': 'subnet_1111', + 'enable_dhcp': True, + 'network_id': '2222', + 'dns_nameservers': [], + 'allocation_pools': [{'start': '10.123.2.2', + 'end': '10.123.2.30'}], + 'host_routes': [], + 'ip_version': 4, + 'gateway_ip': '10.123.2.1', + 'cidr': '10.123.2.0/27', + 'id': '1111'}, ] + self.mock_neutron.return_value = fake + + generator = TemplateGenerator('x', 'x', 'x', 'x', True) + generator.extract_vm_details(False, False, True) - generator = TemplateGenerator(False, False, True) expected = { 'action': 'CREATE', 'status': 'COMPLETE', @@ -397,21 +386,22 @@ class StackDataTests(base.TestCase): } } - generator.extract_subnets() + generator._extract_subnets() self.assertEqual(expected, generator.stack_data) def test_floatingip(self): - ip = { - 'router_id': '1111', - 'status': 'ACTIVE', - 'floating_network_id': '1234', - 'fixed_ip_address': '10.0.48.251', - 'floating_ip_address': '84.39.33.60', - 'port_id': '4321', - 'id': '2222' - } - self.neutron_manager.floatingips = [ip] - generator = TemplateGenerator(True, False, True) + fake = FakeNeutronManager() + fake.floatingips = [{'router_id': '1111', + 'status': 'ACTIVE', + 'floating_network_id': '1234', + 'fixed_ip_address': '10.0.48.251', + 'floating_ip_address': '84.39.33.60', + 'port_id': '4321', + 'id': '2222'}, ] + self.mock_neutron.return_value = fake + + generator = TemplateGenerator('x', 'x', 'x', 'x', True) + generator.extract_vm_details(True, False, True) expected = { 'action': 'CREATE', 'status': 'COMPLETE', @@ -428,12 +418,11 @@ class StackDataTests(base.TestCase): } } - generator.extract_floating() + generator._extract_floating() self.assertEqual(expected, generator.stack_data) def test_security_group(self): - rules = [ - { + rules = [{ 'remote_group_id': None, 'direction': 'ingress', 'remote_ip_prefix': '0.0.0.0/0', @@ -444,18 +433,18 @@ class StackDataTests(base.TestCase): 'port_range_min': 22, 'id': '8901', 'security_group_id': '1234' - }, - ] - group = { - 'tenant_id': '7777', - 'name': 'somename', - 'description': 'description', - 'security_group_rules': rules, - 'id': '1234' - } + }, ] + fake = FakeNeutronManager() + fake.groups = [{'tenant_id': '7777', + 'name': 'somename', + 'description': 'description', + 'security_group_rules': rules, + 'id': '1234'}, ] + self.mock_neutron.return_value = fake + + generator = TemplateGenerator('x', 'x', 'x', 'x', True) + generator.extract_vm_details(False, False, True) - self.neutron_manager.groups = [group] - generator = TemplateGenerator(False, False, True) expected = { 'action': 'CREATE', 'status': 'COMPLETE', @@ -471,12 +460,11 @@ class StackDataTests(base.TestCase): } } } - generator.extract_secgroups() + generator._extract_secgroups() self.assertEqual(expected, generator.stack_data) def test_default_security_group(self): - rules = [ - { + rules = [{ 'remote_group_id': None, 'direction': 'ingress', 'remote_ip_prefix': '0.0.0.0/0', @@ -487,29 +475,32 @@ class StackDataTests(base.TestCase): 'port_range_min': 22, 'id': '8901', 'security_group_id': '1234' - }, - ] - group = { - 'tenant_id': '7777', - 'name': 'default', - 'description': 'default', - 'security_group_rules': rules, - 'id': '1234' - } + }, ] + fake = FakeNeutronManager() + fake.groups = [{'tenant_id': '7777', + 'name': 'default', + 'description': 'default', + 'security_group_rules': rules, + 'id': '1234'}, ] + self.mock_neutron.return_value = fake + + generator = TemplateGenerator('x', 'x', 'x', 'x', True) + generator.extract_vm_details(False, False, True) - self.neutron_manager.groups = [group] - generator = TemplateGenerator(False, False, True) expected = { 'action': 'CREATE', 'status': 'COMPLETE', 'resources': {} } - generator.extract_secgroups() + generator._extract_secgroups() self.assertEqual(expected, generator.stack_data) def test_volume(self): - self.cinder_manager.volumes = [FakeVolume()] - generator = TemplateGenerator(False, False, True) + self.mock_cinder.return_value = FakeCinderManager() + + generator = TemplateGenerator('x', 'x', 'x', 'x', True) + generator.extract_vm_details(False, False, True) + expected = { 'action': 'CREATE', 'status': 'COMPLETE', @@ -526,12 +517,15 @@ class StackDataTests(base.TestCase): } } - generator.extract_volumes() + generator._extract_volumes() self.assertEqual(expected, generator.stack_data) def test_server(self): - self.nova_manager.servers = [FakeServer()] - generator = TemplateGenerator(False, False, True) + self.mock_nova.return_value = FakeNovaManager() + + generator = TemplateGenerator('x', 'x', 'x', 'x', True) + generator.extract_vm_details(False, False, True) + expected = { 'action': 'CREATE', 'status': 'COMPLETE', @@ -548,22 +542,24 @@ class StackDataTests(base.TestCase): } } - generator.extract_servers() + generator._extract_servers() self.assertEqual(expected, generator.stack_data) def test_server_with_default_security_group(self): - self.neutron_manager.groups = [ - { - "name": "default", - "id": "1", - "security_group_rules": [], - "description": "default" - } - ] - self.nova_manager.groups = {'server1': [FakeSecurityGroup( + fake_neutron = FakeNeutronManager() + fake_nova = FakeNovaManager() + fake_neutron.groups = [{"name": "default", + "id": "1", + "security_group_rules": [], + "description": "default"}, ] + fake_nova.groups = {'server1': [FakeSecurityGroup( name='default', description='default')]} - self.nova_manager.servers = [FakeServer()] - generator = TemplateGenerator(False, False, True) + self.mock_neutron.return_value = fake_neutron + self.mock_nova.return_value = fake_nova + + generator = TemplateGenerator('x', 'x', 'x', 'x', True) + generator.extract_vm_details(False, False, True) + expected = { 'action': 'CREATE', 'status': 'COMPLETE', @@ -617,24 +613,32 @@ class StackDataTests(base.TestCase): } } } - generator.extract_servers() + generator._extract_servers() self.assertEqual(expected, generator.stack_data) self.assertEqual(template_expected, generator.template) class NetworkTests(base.TestCase): - def setUp(self): super(NetworkTests, self).setUp() - self.neutron_manager = FakeNeutronManager() - TemplateGenerator.neutron_manager = (lambda x: self.neutron_manager) - self.nova_manager = FakeNovaManager() - TemplateGenerator.nova_manager = (lambda x: self.nova_manager) - self.cinder_manager = FakeCinderManager() - TemplateGenerator.cinder_manager = (lambda x: self.cinder_manager) + self.patch_neutron = mock.patch('flameclient.managers.NeutronManager') + self.mock_neutron = self.patch_neutron.start() + self.patch_nova = mock.patch('flameclient.managers.NovaManager') + self.mock_nova = self.patch_nova.start() + self.patch_cinder = mock.patch('flameclient.managers.CinderManager') + self.mock_cinder = self.patch_cinder.start() + + def tearDown(self): + super(NetworkTests, self).tearDown() + self.mock_neutron.stop() + self.mock_nova.stop() + self.mock_cinder.stop() def test_keypair(self): - generator = TemplateGenerator(False, False, False) + self.mock_nova.return_value = FakeNovaManager() + generator = TemplateGenerator('x', 'x', 'x', 'x', True) + generator.extract_vm_details(False, False, True) + expected = { 'heat_template_version': datetime.date(2013, 5, 23), 'description': 'Generated template', @@ -649,18 +653,14 @@ class NetworkTests(base.TestCase): } } } - generator.extract_keys() + generator._extract_keys() self.assertEqual(expected, generator.template) def test_router(self): - router = { - 'name': 'myrouter', - 'id': '1234', - 'admin_state_up': 'true', - 'external_gateway_info': None - } - self.neutron_manager.routers = [router] - generator = TemplateGenerator(False, False, False) + self.mock_neutron.return_value = FakeNeutronManager() + generator = TemplateGenerator('x', 'x', 'x', 'x', True) + generator.extract_vm_details(False, False, True) + expected = { 'heat_template_version': datetime.date(2013, 5, 23), 'description': 'Generated template', @@ -675,21 +675,21 @@ class NetworkTests(base.TestCase): } } } - generator.extract_routers() + generator._extract_routers() self.assertEqual(expected, generator.template) def test_router_with_external_gateway(self): - router = { - 'name': 'myrouter', - 'id': '1234', - 'admin_state_up': 'true', - 'external_gateway_info': { - 'network_id': '8765', - 'enable_snat': 'true' - } - } - self.neutron_manager.routers = [router] - generator = TemplateGenerator(False, False, False) + fake = FakeNeutronManager() + fake.routers = [{'name': 'myrouter', + 'id': '1234', + 'admin_state_up': 'true', + 'external_gateway_info': { + 'network_id': '8765', + 'enable_snat': 'true'}}, ] + self.mock_neutron.return_value = fake + generator = TemplateGenerator('x', 'x', 'x', 'x', True) + generator.extract_vm_details(False, False, True) + expected = { 'heat_template_version': datetime.date(2013, 5, 23), 'description': 'Generated template', @@ -719,50 +719,41 @@ class NetworkTests(base.TestCase): } } } - generator.extract_routers() + generator._extract_routers() self.assertEqual(expected, generator.template) def test_router_with_ports(self): - router = { - 'name': 'myrouter', - 'id': '1234', - 'admin_state_up': 'true', - 'external_gateway_info': None - } - port = { - 'status': 'ACTIVE', - 'name': '', - 'allowed_address_pairs': [], - 'admin_state_up': True, - 'network_id': '4444', - 'extra_dhcp_opts': [], - 'binding:vnic_type': 'normal', - 'device_owner': 'network:router_interface', - 'mac_address': 'fa:16:3e:4b:8c:98', - 'fixed_ips': [{'subnet_id': '1111', 'ip_address': '10.123.2.3'}], - 'id': '1234567', - 'security_groups': [], - 'device_id': '1234' - } - subnet = { - 'name': 'subnet_1111', - 'enable_dhcp': True, - 'network_id': '1234', - 'dns_nameservers': [], - 'allocation_pools': [{'start': '10.123.2.2', - 'end': '10.123.2.30'}], - 'host_routes': [], - 'ip_version': 4, - 'gateway_ip': '10.123.2.1', - 'cidr': '10.123.2.0/27', - 'id': '1111' - } + fake = FakeNeutronManager() + fake.ports = [{'status': 'ACTIVE', + 'name': '', + 'allowed_address_pairs': [], + 'admin_state_up': True, + 'network_id': '4444', + 'extra_dhcp_opts': [], + 'binding:vnic_type': 'normal', + 'device_owner': 'network:router_interface', + 'mac_address': 'fa:16:3e:4b:8c:98', + 'fixed_ips': [{'subnet_id': '1111', + 'ip_address': '10.123.2.3'}], + 'id': '1234567', + 'security_groups': [], + 'device_id': '1234'}, ] + fake.subnets = [{'name': 'subnet_1111', + 'enable_dhcp': True, + 'network_id': '1234', + 'dns_nameservers': [], + 'allocation_pools': [{'start': '10.123.2.2', + 'end': '10.123.2.30'}], + 'host_routes': [], + 'ip_version': 4, + 'gateway_ip': '10.123.2.1', + 'cidr': '10.123.2.0/27', + 'id': '1111'}, ] - self.neutron_manager.ports = [port] - self.neutron_manager.subnets = [subnet] - self.neutron_manager.routers = [router] + self.mock_neutron.return_value = fake + generator = TemplateGenerator('x', 'x', 'x', 'x', True) + generator.extract_vm_details(False, False, True) - generator = TemplateGenerator(False, False, False) expected = { 'heat_template_version': datetime.date(2013, 5, 23), 'description': 'Generated template', @@ -784,21 +775,15 @@ class NetworkTests(base.TestCase): } } } - generator.extract_routers() + generator._extract_routers() self.assertEqual(expected, generator.template) def test_network(self): - network = { - 'status': 'ACTIVE', - 'subnets': ['1111'], - 'name': 'mynetwork', - 'router:external': False, - 'admin_state_up': True, - 'shared': False, - 'id': '2222' - } - self.neutron_manager.networks = [network] - generator = TemplateGenerator([], [], []) + fake = FakeNeutronManager() + self.mock_neutron.return_value = FakeNeutronManager() + generator = TemplateGenerator('x', 'x', 'x', 'x', True) + generator.extract_vm_details(False, False, True) + expected = { 'heat_template_version': datetime.date(2013, 5, 23), 'description': 'Generated template', @@ -814,57 +799,44 @@ class NetworkTests(base.TestCase): } } } - generator.extract_networks() + generator._extract_networks() self.assertEqual(expected, generator.template) def test_external_network(self): - network = { - 'status': 'ACTIVE', - 'subnets': ['1111'], - 'name': 'mynetwork', - 'router:external': True, - 'admin_state_up': True, - 'shared': False, - 'id': '2222' - } - self.neutron_manager.networks = [network] - generator = TemplateGenerator([], [], []) + fake = FakeNeutronManager() + fake.networks[0]['router:external'] = True + self.mock_neutron.return_value = fake + + generator = TemplateGenerator('x', 'x', 'x', 'x', True) + generator.extract_vm_details(False, False, True) + expected = { 'heat_template_version': datetime.date(2013, 5, 23), 'description': 'Generated template', 'parameters': {}, 'resources': {} } - generator.extract_networks() + generator._extract_networks() self.assertEqual(expected, generator.template) def test_subnet(self): - network = { - 'status': 'ACTIVE', - 'subnets': ['1111'], - 'name': 'mynetwork', - 'router:external': False, - 'admin_state_up': True, - 'shared': False, - 'id': '2222' - } - subnet = { - 'name': 'subnet_1111', - 'enable_dhcp': True, - 'network_id': '2222', - 'dns_nameservers': [], - 'allocation_pools': [{'start': '10.123.2.2', - 'end': '10.123.2.30'}], - 'host_routes': [], - 'ip_version': 4, - 'gateway_ip': '10.123.2.1', - 'cidr': '10.123.2.0/27', - 'id': '1111' - } - self.neutron_manager.networks = [network] - self.neutron_manager.subnets = [subnet] + fake = FakeNeutronManager() + fake.subnets = [{'name': 'subnet_1111', + 'enable_dhcp': True, + 'network_id': '2222', + 'dns_nameservers': [], + 'allocation_pools': [{'start': '10.123.2.2', + 'end': '10.123.2.30'}], + 'host_routes': [], + 'ip_version': 4, + 'gateway_ip': '10.123.2.1', + 'cidr': '10.123.2.0/27', + 'id': '1111'}, ] + self.mock_neutron.return_value = fake + + generator = TemplateGenerator('x', 'x', 'x', 'x', True) + generator.extract_vm_details(False, False, True) - generator = TemplateGenerator([], [], []) expected = { 'heat_template_version': datetime.date(2013, 5, 23), 'description': 'Generated template', @@ -886,21 +858,23 @@ class NetworkTests(base.TestCase): } } } - generator.extract_subnets() + generator._extract_subnets() self.assertEqual(expected, generator.template) def test_floatingip(self): - ip = { - 'router_id': '1111', - 'status': 'ACTIVE', - 'floating_network_id': '1234', - 'fixed_ip_address': '10.0.48.251', - 'floating_ip_address': '84.39.33.60', - 'port_id': '4321', - 'id': '2222' - } - self.neutron_manager.floatingips = [ip] - generator = TemplateGenerator(True, [], []) + fake = FakeNeutronManager() + fake.floatingips = [{'router_id': '1111', + 'status': 'ACTIVE', + 'floating_network_id': '1234', + 'fixed_ip_address': '10.0.48.251', + 'floating_ip_address': '84.39.33.60', + 'port_id': '4321', + 'id': '2222'}, ] + self.mock_neutron.return_value = fake + + generator = TemplateGenerator('x', 'x', 'x', 'x', True) + generator.extract_vm_details(True, False, False) + expected = { 'heat_template_version': datetime.date(2013, 5, 23), 'description': 'Generated template', @@ -922,7 +896,7 @@ class NetworkTests(base.TestCase): } } } - generator.extract_floating() + generator._extract_floating() self.assertEqual(expected, generator.template) def test_security_group(self): @@ -976,16 +950,17 @@ class NetworkTests(base.TestCase): 'security_group_id': '1234' }, ] - group = { - 'tenant_id': '7777', - 'name': 'toto', - 'description': 'description', - 'security_group_rules': rules, - 'id': '1234' - } + fake = FakeNeutronManager() + fake.groups = [{'tenant_id': '7777', + 'name': 'toto', + 'description': 'description', + 'security_group_rules': rules, + 'id': '1234'}, ] + self.mock_neutron.return_value = fake + + generator = TemplateGenerator('x', 'x', 'x', 'x', True) + generator.extract_vm_details(False, False, False) - self.neutron_manager.groups = [group] - generator = TemplateGenerator([], [], []) expected = { 'heat_template_version': datetime.date(2013, 5, 23), 'description': 'Generated template', @@ -1026,7 +1001,7 @@ class NetworkTests(base.TestCase): } } } - generator.extract_secgroups() + generator._extract_secgroups() self.assertEqual(expected, generator.template) def test_security_group_default(self): @@ -1092,16 +1067,17 @@ class NetworkTests(base.TestCase): 'security_group_id': '1111' } ] - group = { - 'tenant_id': '7777', - 'name': 'default', - 'description': 'default', - 'security_group_rules': rules, - 'id': '1111' - } + fake = FakeNeutronManager() + fake.groups = [{'tenant_id': '7777', + 'name': 'default', + 'description': 'default', + 'security_group_rules': rules, + 'id': '1111'}, ] + self.mock_neutron.return_value = fake + + generator = TemplateGenerator('x', 'x', 'x', 'x', True) + generator.extract_vm_details(False, False, False) - self.neutron_manager.groups = [group] - generator = TemplateGenerator([], [], []) expected = { 'heat_template_version': datetime.date(2013, 5, 23), 'description': 'Generated template', @@ -1144,7 +1120,7 @@ class NetworkTests(base.TestCase): } } } - generator.extract_secgroups() + generator._extract_secgroups() self.assertEqual(expected, generator.template) def test_security_groups(self): @@ -1249,22 +1225,23 @@ class NetworkTests(base.TestCase): 'security_group_id': '2222' } ] - group1 = { - 'tenant_id': '7777', - 'name': 'security_group_1', - 'description': 'security_group_1', - 'security_group_rules': rules1, - 'id': '1111' - } - group2 = { - 'tenant_id': '7777', - 'name': 'security_group_2', - 'description': 'security_group_2', - 'security_group_rules': rules2, - 'id': '2222' - } - self.neutron_manager.groups = [group1, group2] - generator = TemplateGenerator([], [], []) + fake = FakeNeutronManager() + fake.groups = [{'tenant_id': '7777', + 'name': 'security_group_1', + 'description': 'security_group_1', + 'security_group_rules': rules1, + 'id': '1111'}, + {'tenant_id': '7777', + 'name': 'security_group_2', + 'description': 'security_group_2', + 'security_group_rules': rules2, + 'id': '2222'}, + ] + self.mock_neutron.return_value = fake + + generator = TemplateGenerator('x', 'x', 'x', 'x', True) + generator.extract_vm_details(False, False, True) + expected = { 'heat_template_version': datetime.date(2013, 5, 23), 'description': 'Generated template', @@ -1345,24 +1322,32 @@ class NetworkTests(base.TestCase): } } } - generator.extract_secgroups() + generator._extract_secgroups() self.assertEqual(expected, generator.template) class VolumeTests(base.TestCase): - def setUp(self): super(VolumeTests, self).setUp() - self.neutron_manager = FakeNeutronManager() - TemplateGenerator.neutron_manager = (lambda x: self.neutron_manager) - self.nova_manager = FakeNovaManager() - TemplateGenerator.nova_manager = (lambda x: self.nova_manager) - self.cinder_manager = FakeCinderManager() - TemplateGenerator.cinder_manager = (lambda x: self.cinder_manager) + self.patch_neutron = mock.patch('flameclient.managers.NeutronManager') + self.mock_neutron = self.patch_neutron.start() + self.patch_nova = mock.patch('flameclient.managers.NovaManager') + self.mock_nova = self.patch_nova.start() + self.patch_cinder = mock.patch('flameclient.managers.CinderManager') + self.mock_cinder = self.patch_cinder.start() + + def tearDown(self): + super(VolumeTests, self).tearDown() + self.mock_neutron.stop() + self.mock_nova.stop() + self.mock_cinder.stop() def test_basic(self): - self.cinder_manager.volumes = [FakeVolume()] - generator = TemplateGenerator(False, False, False) + self.mock_cinder.return_value = FakeCinderManager() + + generator = TemplateGenerator('x', 'x', 'x', 'x', True) + generator.extract_vm_details(False, False, True) + expected = { 'heat_template_version': datetime.date(2013, 5, 23), 'description': 'Generated template', @@ -1378,12 +1363,17 @@ class VolumeTests(base.TestCase): } } } - generator.extract_volumes() + generator._extract_volumes() self.assertEqual(expected, generator.template) def test_source_volid_external(self): - self.cinder_manager.volumes = [FakeVolume(source_volid=5678)] - generator = TemplateGenerator(False, False, False) + fake = FakeCinderManager() + fake.volumes = [FakeVolume(source_volid=5678), ] + self.mock_cinder.return_value = fake + + generator = TemplateGenerator('x', 'x', 'x', 'x', True) + generator.extract_vm_details(False, False, True) + expected = { 'heat_template_version': datetime.date(2013, 5, 23), 'description': 'Generated template', @@ -1405,13 +1395,18 @@ class VolumeTests(base.TestCase): } } } - generator.extract_volumes() + generator._extract_volumes() self.assertEqual(expected, generator.template) def test_source_volid_included(self): - self.cinder_manager.volumes = [ - FakeVolume(source_volid=5678), FakeVolume(id=5678)] - generator = TemplateGenerator(False, False, False) + fake = FakeCinderManager() + fake.volumes = [FakeVolume(source_volid=5678), FakeVolume(id=5678)] + + self.mock_cinder.return_value = fake + + generator = TemplateGenerator('x', 'x', 'x', 'x', True) + generator.extract_vm_details(False, False, True) + expected = { 'heat_template_version': datetime.date(2013, 5, 23), 'description': 'Generated template', @@ -1436,7 +1431,7 @@ class VolumeTests(base.TestCase): } } } - generator.extract_volumes() + generator._extract_volumes() self.assertEqual(expected, generator.template) def test_image(self): @@ -1451,11 +1446,14 @@ class VolumeTests(base.TestCase): 'checksum': 'f8a2e', 'min_disk': '0', 'size': '25'} + fake = FakeCinderManager() + fake.volumes = [FakeVolume(bootable='true', + volume_image_metadata=metadata), ] + self.mock_cinder.return_value = fake + + generator = TemplateGenerator('x', 'x', 'x', 'x', True) + generator.extract_vm_details(False, False, True) - self.cinder_manager.volumes = [ - FakeVolume(bootable='true', volume_image_metadata=metadata) - ] - generator = TemplateGenerator(False, False, False) expected = { 'heat_template_version': datetime.date(2013, 5, 23), 'description': 'Generated template', @@ -1478,12 +1476,17 @@ class VolumeTests(base.TestCase): } } } - generator.extract_volumes() + generator._extract_volumes() self.assertEqual(expected, generator.template) def test_snapshot_id(self): - self.cinder_manager.volumes = [FakeVolume(snapshot_id=5678)] - generator = TemplateGenerator(False, False, False) + fake = FakeCinderManager() + fake.volumes = [FakeVolume(snapshot_id=5678), ] + self.mock_cinder.return_value = fake + + generator = TemplateGenerator('x', 'x', 'x', 'x', True) + generator.extract_vm_details(False, False, True) + expected = { 'heat_template_version': datetime.date(2013, 5, 23), 'description': 'Generated template', @@ -1506,12 +1509,17 @@ class VolumeTests(base.TestCase): } } } - generator.extract_volumes() + generator._extract_volumes() self.assertEqual(expected, generator.template) def test_volume_type(self): - self.cinder_manager.volumes = [FakeVolume(volume_type='isci')] - generator = TemplateGenerator(False, False, False) + fake = FakeCinderManager() + fake.volumes = [FakeVolume(volume_type='isci'), ] + self.mock_cinder.return_value = fake + + generator = TemplateGenerator('x', 'x', 'x', 'x', True) + generator.extract_vm_details(False, False, True) + expected = { 'heat_template_version': datetime.date(2013, 5, 23), 'description': 'Generated template', @@ -1534,12 +1542,17 @@ class VolumeTests(base.TestCase): } } } - generator.extract_volumes() + generator._extract_volumes() self.assertEqual(expected, generator.template) def test_metadata(self): - self.cinder_manager.volumes = [FakeVolume(metadata={'key': 'value'})] - generator = TemplateGenerator(False, False, False) + fake = FakeCinderManager() + fake.volumes = [FakeVolume(metadata={'key': 'value'}), ] + self.mock_cinder.return_value = fake + + generator = TemplateGenerator('x', 'x', 'x', 'x', True) + generator.extract_vm_details(False, False, True) + expected = { 'heat_template_version': datetime.date(2013, 5, 23), 'description': 'Generated template', @@ -1556,24 +1569,32 @@ class VolumeTests(base.TestCase): } } } - generator.extract_volumes() + generator._extract_volumes() self.assertEqual(expected, generator.template) class ServerTests(base.TestCase): - def setUp(self): super(ServerTests, self).setUp() - self.neutron_manager = FakeNeutronManager() - TemplateGenerator.neutron_manager = (lambda x: self.neutron_manager) - self.nova_manager = FakeNovaManager() - TemplateGenerator.nova_manager = (lambda x: self.nova_manager) - self.cinder_manager = FakeCinderManager() - TemplateGenerator.cinder_manager = (lambda x: self.cinder_manager) + self.patch_neutron = mock.patch('flameclient.managers.NeutronManager') + self.mock_neutron = self.patch_neutron.start() + self.patch_nova = mock.patch('flameclient.managers.NovaManager') + self.mock_nova = self.patch_nova.start() + self.patch_cinder = mock.patch('flameclient.managers.CinderManager') + self.mock_cinder = self.patch_cinder.start() + + def tearDown(self): + super(ServerTests, self).tearDown() + self.mock_neutron.stop() + self.mock_nova.stop() + self.mock_cinder.stop() def test_basic(self): - self.nova_manager.servers = [FakeServer()] - generator = TemplateGenerator(False, False, False) + self.mock_nova.return_value = FakeNovaManager() + + generator = TemplateGenerator('x', 'x', 'x', 'x', True) + generator.extract_vm_details(False, False, True) + expected = { 'heat_template_version': datetime.date(2013, 5, 23), 'description': 'Generated template', @@ -1601,12 +1622,17 @@ class ServerTests(base.TestCase): } } } - generator.extract_servers() + generator._extract_servers() self.assertEqual(expected, generator.template) def test_keypair(self): - self.nova_manager.servers = [FakeServer(key_name='testkey')] - generator = TemplateGenerator(False, False, False) + fake = FakeNovaManager() + fake.servers = [FakeServer(key_name='testkey')] + self.mock_nova.return_value = fake + + generator = TemplateGenerator('x', 'x', 'x', 'x', True) + generator.extract_vm_details(False, False, True) + expected = { 'heat_template_version': datetime.date(2013, 5, 23), 'description': 'Generated template', @@ -1635,7 +1661,7 @@ class ServerTests(base.TestCase): } } } - generator.extract_servers() + generator._extract_servers() self.assertEqual(expected, generator.template) def test_boot_from_volume(self): @@ -1643,18 +1669,22 @@ class ServerTests(base.TestCase): 'server_id': '777', 'id': '5678', 'host_name': None, - 'volume_id': '5678'}] - self.cinder_manager.volumes = [FakeVolume(id=5678, - attachments=attachments, - bootable='true')] - servers_args = { - "id": 777, - "image": None, - "os-extended-volumes:volumes_attached": [{'id': 5678}] - } - server = FakeServer(**servers_args) - self.nova_manager.servers = [server] - generator = TemplateGenerator(False, False, False) + 'volume_id': '5678'}, ] + servers_args = {"id": 777, + "image": None, + "os-extended-volumes:volumes_attached": [{'id': 5678}]} + fake_nova = FakeNovaManager() + fake_nova.servers = [FakeServer(**servers_args), ] + self.mock_nova.return_value = fake_nova + fake_cinder = FakeCinderManager() + fake_cinder.volumes = [FakeVolume(id=5678, + attachments=attachments, + bootable='true')] + self.mock_cinder.return_value = fake_cinder + + generator = TemplateGenerator('x', 'x', 'x', 'x', True) + generator.extract_vm_details(False, False, True) + expected = { 'heat_template_version': datetime.date(2013, 5, 23), 'description': 'Generated template', @@ -1678,7 +1708,7 @@ class ServerTests(base.TestCase): }, } } - generator.extract_servers() + generator._extract_servers() self.assertEqual(expected, generator.template) def test_volume_attached(self): @@ -1686,16 +1716,25 @@ class ServerTests(base.TestCase): 'server_id': '777', 'id': '5678', 'host_name': None, - 'volume_id': '5678'}] - self.cinder_manager.volumes = [FakeVolume(id=5678, - attachments=attachments, - bootable='false')] - server_args = { - "id": 777, - "os-extended-volumes:volumes_attached": [{'id': 5678}]} - server = FakeServer(**server_args) - self.nova_manager.servers = [server] - generator = TemplateGenerator(False, False, False) + 'volume_id': '5678'}, ] + fake_cinder = FakeCinderManager() + fake_cinder.volumes = [FakeVolume(id=5678, attachments=attachments, + bootable='false'), ] + self.mock_cinder.return_value = fake_cinder + server_args = {"id": 777, + "os-extended-volumes:volumes_attached": [{'id': 5678}]} + fake_nova = FakeNovaManager() + fake_nova.servers = [FakeServer(**server_args), ] + self.mock_nova.return_value = fake_nova + fake_cinder = FakeCinderManager() + fake_cinder.volumes = [FakeVolume(id=5678, + attachments=attachments, + bootable='false'), ] + self.mock_cinder.return_value = fake_cinder + + generator = TemplateGenerator('x', 'x', 'x', 'x', True) + generator.extract_vm_details(False, False, True) + expected = { 'heat_template_version': datetime.date(2013, 5, 23), 'description': 'Generated template', @@ -1726,17 +1765,23 @@ class ServerTests(base.TestCase): }, } } - generator.extract_servers() + generator._extract_servers() self.assertEqual(expected, generator.template) def test_security_groups(self): - self.neutron_manager.groups = [ - {"name": "group1", "id": "1", "security_group_rules": [], - "description": "Group"} - ] - self.nova_manager.groups = {'server1': [FakeSecurityGroup()]} - self.nova_manager.servers = [FakeServer()] - generator = TemplateGenerator(False, False, False) + fake_neutron = FakeNeutronManager() + fake_neutron.groups = [{"name": "group1", + "id": "1", + "security_group_rules": [], + "description": "Group"}, ] + self.mock_neutron.return_value = fake_neutron + fake_nova = FakeNovaManager() + fake_nova.groups = {'server1': [FakeSecurityGroup(), ]} + self.mock_nova.return_value = fake_nova + + generator = TemplateGenerator('x', 'x', 'x', 'x', True) + generator.extract_vm_details(False, False, True) + expected = { 'heat_template_version': datetime.date(2013, 5, 23), 'description': 'Generated template', @@ -1777,13 +1822,18 @@ class ServerTests(base.TestCase): } } } - generator.extract_secgroups() - generator.extract_servers() + generator._extract_secgroups() + generator._extract_servers() self.assertEqual(expected, generator.template) def test_config_drive(self): - self.nova_manager.servers = [FakeServer(config_drive="True")] - generator = TemplateGenerator(False, False, False) + fake_nova = FakeNovaManager() + fake_nova.servers = [FakeServer(config_drive="True"), ] + self.mock_nova.return_value = fake_nova + + generator = TemplateGenerator('x', 'x', 'x', 'x', True) + generator.extract_vm_details(False, False, True) + expected = { 'heat_template_version': datetime.date(2013, 5, 23), 'description': 'Generated template', @@ -1812,12 +1862,17 @@ class ServerTests(base.TestCase): } } } - generator.extract_servers() + generator._extract_servers() self.assertEqual(expected, generator.template) def test_metadata(self): - self.nova_manager.servers = [FakeServer(metadata={"key": "value"})] - generator = TemplateGenerator(False, False, False) + fake_nova = FakeNovaManager() + fake_nova.servers = [FakeServer(metadata={"key": "value"}), ] + self.mock_nova.return_value = fake_nova + + generator = TemplateGenerator('x', 'x', 'x', 'x', True) + generator.extract_vm_details(False, False, True) + expected = { 'heat_template_version': datetime.date(2013, 5, 23), 'description': 'Generated template', @@ -1846,7 +1901,7 @@ class ServerTests(base.TestCase): } } } - generator.extract_servers() + generator._extract_servers() self.assertEqual(expected, generator.template) def test_networks(self): @@ -1860,14 +1915,18 @@ class ServerTests(base.TestCase): "enable_dhcp": True, "host_routes": [], "ip_version": 4} - self.neutron_manager.subnets = [subnet] - network = { - "id": "1234", - "name": "private"} - self.neutron_manager.networks = [network] + fake_neutron = FakeNeutronManager() + fake_neutron.subnets = [subnet] + fake_neutron.networks = [{"id": "1234", "name": "private"}, ] + self.mock_neutron.return_value = fake_neutron + fake_nova = FakeNovaManager() addresses = {"private": [{"addr": "10.0.0.2"}]} - self.nova_manager.servers = [FakeServer(addresses=addresses)] - generator = TemplateGenerator(False, False, False) + fake_nova.servers = [FakeServer(addresses=addresses)] + self.mock_nova.return_value = fake_nova + + generator = TemplateGenerator('x', 'x', 'x', 'x', True) + generator.extract_vm_details(False, False, True) + expected = { 'heat_template_version': datetime.date(2013, 5, 23), 'description': 'Generated template', @@ -1897,7 +1956,7 @@ class ServerTests(base.TestCase): } } } - generator.extract_servers() + generator._extract_servers() self.assertEqual(expected, generator.template) def test_excluded_volume_attached(self): @@ -1906,15 +1965,19 @@ class ServerTests(base.TestCase): 'id': '5678', 'host_name': None, 'volume_id': '5678'}] - self.cinder_manager.volumes = [FakeVolume(id=5678, - attachments=attachments, - bootable='false')] - server_args = { - "id": 777, - "os-extended-volumes:volumes_attached": [{'id': 5678}]} - server = FakeServer(**server_args) - self.nova_manager.servers = [server] - generator = TemplateGenerator(False, True, False) + fake_cinder = FakeCinderManager() + fake_cinder.volumes = [FakeVolume(id=5678, attachments=attachments, + bootable='false'), ] + self.mock_cinder.return_value = fake_cinder + server_args = {"id": 777, + "os-extended-volumes:volumes_attached": [{'id': 5678}]} + fake_nova = FakeNovaManager() + fake_nova.servers = [FakeServer(**server_args), ] + self.mock_nova.return_value = fake_nova + + generator = TemplateGenerator('x', 'x', 'x', 'x', True) + generator.extract_vm_details(False, True, False) + expected = { 'heat_template_version': datetime.date(2013, 5, 23), 'description': 'Generated template', @@ -1951,5 +2014,5 @@ class ServerTests(base.TestCase): } } } - generator.extract_servers() + generator._extract_servers() self.assertEqual(expected, generator.template) diff --git a/setup.cfg b/setup.cfg index 77e5277..d40b826 100644 --- a/setup.cfg +++ b/setup.cfg @@ -3,9 +3,9 @@ name = python-flameclient summary = Automatic Heat template generation description-file = README.rst -author = OpenStack -author-email = openstack-dev@lists.openstack.org -home-page = http://www.openstack.org/ +author = CloudWatt +author-email = info@cloudwatt.com +home-page = http://www.cloudwatt.com/ classifier = Environment :: OpenStack Intended Audience :: Information Technology @@ -16,8 +16,6 @@ classifier = Programming Language :: Python :: 2 Programming Language :: Python :: 2.7 Programming Language :: Python :: 2.6 - Programming Language :: Python :: 3 - Programming Language :: Python :: 3.3 [files] packages = @@ -27,6 +25,10 @@ packages = setup-hooks = pbr.hooks.setup_hook +[entry_points] +console_scripts = + flame = flameclient.cmd:main + [build_sphinx] source-dir = doc/source build-dir = doc/build @@ -49,9 +51,5 @@ keywords = _ gettext ngettext l_ lazy_gettext mapping_file = babel.cfg output_file = flameclient/locale/python-flameclient.pot -[entry_points] -console_scripts = - flame = flameclient.cmd:main - [wheel] universal = 1 \ No newline at end of file diff --git a/test-requirements.txt b/test-requirements.txt index aaae73b..27ae44c 100644 --- a/test-requirements.txt +++ b/test-requirements.txt @@ -2,10 +2,11 @@ hacking>=0.9.2,<0.10 coverage>=3.6 discover +mock>=1.0 fixtures>=0.3.14 python-subunit sphinx>=1.1.2 oslosphinx testrepository>=0.0.18 testscenarios>=0.4 -testtools>=0.9.34 \ No newline at end of file +testtools>=0.9.34