def test_create_instance_from_bootable_volume(host): """Test to verify that a bootable volume can be created based on a Glance image Args: host(testinfra.host.Host): A hostname in dynamic_inventory.json/molecule.yml """ volume_id = helpers.get_id_by_name('volume', volume_name, host) assert volume_id is not None network_id = helpers.get_id_by_name('network', network_name, host) assert network_id is not None cmd = "{} openstack server create --volume {} --flavor {} --nic net-id={} {}'".format( utility_container, volume_id, flavor, network_id, instance_name) host.run_expect([0], cmd) instances = helpers.get_resource_list_by_name('server', host) assert instances instance_names = [x['Name'] for x in instances] assert instance_name in instance_names assert (helpers.get_expected_value('server', instance_name, 'status', 'ACTIVE', host)) assert (helpers.get_expected_value('server', instance_name, 'OS-EXT-STS:power_state', 'Running', host)) # Tear down helpers.delete_instance(instance_name, host) helpers.delete_volume(volume_name, host)
def test_create_snapshot_of_an_instance(host): """Create an instance and then create snapshot on it""" data_image = { "instance_name": instance_name, "from_source": 'image', "source_name": image_name, "flavor": flavor, "network_name": private_net, } helpers.create_instance(data_image, host) # Verify the new instance is ACTIVE. assert (helpers.get_expected_value('server', instance_name, 'status', 'ACTIVE', host, 20)) # TODO: will find out a better way to avoid implicit sleep. 'status' is 'ACTIVE' is not enough to ensure the # TODO: instance is ready, there are many instance statuses that might cause the test failed. # TODO: run `openstack server show <instance-ID> -f json` to see all the states sleep(120) # Create snapshot from newly created/shutdown instance helpers.create_snapshot_from_instance(snapshot_name, instance_name, host) # Verify the snapshot is successfully created: assert (helpers.get_expected_value('image', snapshot_name, 'status', 'active', host, 20))
def attach_volume_to_server(volume, server, run_on_host): cmd = "{} server add volume \ {} \ {} {}".format(os_pre, server, volume, os_post) run_on_host.run(cmd) return helpers.get_expected_value('volume', volume, 'status', 'in-use', run_on_host)
def test_create_floating_ip(host): """Create floating IP""" global floating_ip floating_ip = create_floating_ip(gateway_net, host) assert floating_ip # Before being assigned, the floating IP status should be 'DOWN' assert (helpers.get_expected_value('floating ip', floating_ip, 'status', 'DOWN', host))
def test_assign_floating_ip_to_instance(host): """Assign floating IP to an instance/server""" # Creating an instance from image data = { "instance_name": instance_name, "from_source": 'image', "source_name": image_name, "flavor": flavor, "network_name": private_net, } helpers.create_instance(data, host) # TODO: will find out a better way to avoid implicit sleep. 'status' is 'ACTIVE' is not enough to ensure the # TODO: instance is ready, there are many instance statuses that might cause the test failed. # TODO: run `openstack server show <instance-ID> -f json` to see all the states sleep(120) # Verify the new instance is ACTIVE and Running. assert (helpers.get_expected_value('server', instance_name, 'status', 'ACTIVE', host, 20)) assert (helpers.get_expected_value('server', instance_name, 'OS-EXT-STS:power_state', 'Running', host, 20)) assert floating_ip instance_id = helpers.get_id_by_name('server', instance_name, host) assert instance_id cmd = "{} openstack server add floating ip {} {}'".format(utility_container, instance_id, floating_ip) host.run_expect([0], cmd) # After being assigned, the floating IP status should be 'ACTIVE' assert (helpers.get_expected_value('floating ip', floating_ip, 'status', 'ACTIVE', host)) # Ensure the IP can be pinged from infra1 cmd = "ping -c1 {}".format(floating_ip) assert (host.run_expect([0], cmd))
def test_create_bootable_volume(host): """Test to verify that a bootable volume can be created based on a Glance image Args: host(testinfra.host.Host): A hostname in dynamic_inventory.json/molecule.yml """ image_id = helpers.get_id_by_name('image', image_name, host) assert image_id is not None cmd = "{} openstack volume create --size 1 --image {} --bootable {}'".format( utility_container, image_id, volume_name) host.run_expect([0], cmd) assert volume_name in helpers.openstack_name_list('volume', host) assert (helpers.get_expected_value('volume', volume_name, 'status', 'available', host))
def test_create_instance_from_snapshot(host): data_snapshot = { "instance_name": new_instance_name, "from_source": 'image', "source_name": snapshot_name, "flavor": flavor, "network_name": private_net, } # Boot new instance using the newly created snapshot: helpers.create_instance(data_snapshot, host) # Verify the new instance is successfully booted using the snapshot assert (helpers.get_expected_value('server', new_instance_name, 'status', 'ACTIVE', host, 20)) # Cleaning up: Delete newly created snapshot helpers.delete_it('image', snapshot_name, host)
def test_hypervisor_vms(host): """ASC-241: Per network, spin up an instance on each hypervisor, perform external ping, and tear-down """ ssh = "ssh -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null \ -i ~/.ssh/rpc_support ubuntu@{}" vars = host.ansible('include_vars', 'file=./vars/main.yml')['ansible_facts'] flavor_name = vars['flavor']['name'] image_name = vars['image']['name'] server_list = [] testable_networks = [] # get image id (sounds like a helper, or register it as an ansible value) cmd = "{} image list -f json {}".format(os_pre, os_post) res = host.run(cmd) images = json.loads(res.stdout) assert len(images) > 0 filtered_images = list(filter(lambda d: d['Name'] == image_name, images)) assert len(filtered_images) > 0 image = filtered_images[-1] # neutron_agent connection lookup na_list = testinfra.utils.ansible_runner.AnsibleRunner( os.environ['MOLECULE_INVENTORY_FILE']).get_hosts('neutron_agent') hostname = host.check_output('hostname') na_list = [x for x in na_list if hostname in x] neutron_agent = next(iter(na_list), None) assert neutron_agent if 'container' in neutron_agent: # lxc na_pre = "lxc-attach -n {} -- bash -c ".format(neutron_agent) else: # ssh na_pre = "ssh -o StrictHostKeyChecking=no \ -o UserKnownHostsFile=/dev/null \ {} ".format(neutron_agent) r = random.randint(1111, 9999) # get list of internal networks net_cmd = "{} network list -f json {}".format(os_pre, os_post) net_res = host.run(net_cmd) networks = json.loads(net_res.stdout) for network in networks: cmd = "{} network show {} -f json {}".format(os_pre, network['ID'], os_post) res = host.run(cmd) network_detail = json.loads(res.stdout) if network_detail['router:external'] == 'External': continue testable_networks.append(network_detail) if not testable_networks: pytest.skip("No testable networks found") # iterate over internal networks for network in testable_networks: # spin up instance per hypervisor cmd = "{} compute service list -f json {}".format(os_pre, os_post) res = host.run(cmd) computes = json.loads(res.stdout) for compute in computes: if compute['Binary'] == 'nova-compute': instance_name = "rpctest-{}-{}-{}".format( r, compute['Host'], network['name']) server = create_server_on(host, image['ID'], flavor_name, network['id'], compute['Zone'], instance_name) assert helpers.get_expected_value('server', server['id'], 'status', 'ACTIVE', host, 15) server_list.append(server['id']) for server in server_list: # test ssh print "DEBUG OUTPUT" print server cmd = "{} server show {} -f json {}".format(os_pre, server, os_post) res = host.run(cmd) server_detail = json.loads(res.stdout) network_name, ip = server_detail['addresses'].split('=') # get network detail (again) # This will include network id and subnets. cmd = "{} network show {} -f json {}".format(os_pre, network_name, os_post) res = host.run(cmd) network = json.loads(res.stdout) # confirm SSH port access cmd = "{} 'ip netns exec \ qdhcp-{} nc -w1 {} 22'".format(na_pre, network['id'], ip) for attempt in range(10): res = host.run(cmd) try: assert 'SSH' in res.stdout except AssertionError: sleep(10) else: break else: assert 'SSH' in res.stdout # get gateway ip via subnet detail cmd = "{} subnet show {} -f json {}".format(os_pre, network['subnets'], os_post) res = host.run(cmd) sub = json.loads(res.stdout) if sub['gateway_ip']: # ping out cmd = "{} 'ip netns exec \ qdhcp-{} {} ping -c1 -w2 8.8.8.8'".format( na_pre, network['id'], ssh.format(ip)) host.run_expect([0], cmd)