diff options
Diffstat (limited to 'openstackclient/tests')
54 files changed, 5533 insertions, 1548 deletions
diff --git a/openstackclient/tests/functional/common/test_help.py b/openstackclient/tests/functional/common/test_help.py index 3a9aef9e..c55741f1 100644 --- a/openstackclient/tests/functional/common/test_help.py +++ b/openstackclient/tests/functional/common/test_help.py @@ -43,7 +43,7 @@ class HelpTests(base.TestCase): ('server resize', 'Scale server to a new flavor'), ('server resume', 'Resume server(s)'), ('server set', 'Set server properties'), - ('server shelve', 'Shelve server(s)'), + ('server shelve', 'Shelve and optionally offload server(s)'), ('server show', 'Show server details'), ('server ssh', 'SSH to server'), ('server start', 'Start server(s).'), diff --git a/openstackclient/tests/functional/common/test_quota.py b/openstackclient/tests/functional/common/test_quota.py index 4c2fc0e3..9c057460 100644 --- a/openstackclient/tests/functional/common/test_quota.py +++ b/openstackclient/tests/functional/common/test_quota.py @@ -165,47 +165,3 @@ class QuotaTests(base.TestCase): # returned attributes self.assertTrue(cmd_output["key-pairs"] >= 0) self.assertTrue(cmd_output["snapshots"] >= 0) - - def test_quota_set_force(self): - """Test to set instance value by force """ - json_output = json.loads(self.openstack( - 'quota list -f json --detail --compute' - )) - in_use = limit = None - for j in json_output: - if j["Resource"] == "instances": - in_use = j["In Use"] - limit = j["Limit"] - - # Reduce count of in_use - in_use = in_use - 1 - # cannot have negative instances limit - if in_use < 0: - in_use = 0 - - # set the limit by force now - self.openstack( - 'quota set ' + self.PROJECT_NAME + - '--instances ' + str(in_use) + ' --force' - ) - cmd_output = json.loads(self.openstack( - 'quota show -f json ' + self.PROJECT_NAME - )) - self.assertIsNotNone(cmd_output) - self.assertEqual( - in_use, - cmd_output["instances"] - ) - - # Set instances limit to original limit now - self.openstack( - 'quota set ' + self.PROJECT_NAME + '--instances ' + str(limit) - ) - cmd_output = json.loads(self.openstack( - 'quota show -f json ' + self.PROJECT_NAME - )) - self.assertIsNotNone(cmd_output) - self.assertEqual( - limit, - cmd_output["instances"] - ) diff --git a/openstackclient/tests/functional/compute/v2/test_agent.py b/openstackclient/tests/functional/compute/v2/test_agent.py deleted file mode 100644 index 25d8c868..00000000 --- a/openstackclient/tests/functional/compute/v2/test_agent.py +++ /dev/null @@ -1,196 +0,0 @@ -# Licensed under the Apache License, Version 2.0 (the "License"); you may -# not use this file except in compliance with the License. You may obtain -# a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations -# under the License. - -import hashlib -import json - -from openstackclient.tests.functional import base - - -class ComputeAgentTests(base.TestCase): - """Functional tests for compute agent.""" - - # Generate two different md5hash - MD5HASH1 = hashlib.md5() - MD5HASH1.update('agent_1'.encode('utf-8')) - MD5HASH1 = MD5HASH1.hexdigest() - MD5HASH2 = hashlib.md5() - MD5HASH2.update('agent_2'.encode('utf-8')) - MD5HASH2 = MD5HASH2.hexdigest() - - def test_compute_agent_delete(self): - """Test compute agent create, delete multiple""" - os1 = "os_1" - arch1 = "x86_64" - ver1 = "v1" - url1 = "http://localhost" - md5hash1 = self.MD5HASH1 - hyper1 = "kvm" - cmd1 = ' '.join((os1, arch1, ver1, url1, md5hash1, hyper1)) - - cmd_output = json.loads(self.openstack( - 'compute agent create -f json ' + - cmd1 - )) - agent_id1 = str(cmd_output["agent_id"]) - - os2 = "os_2" - arch2 = "x86" - ver2 = "v2" - url2 = "http://openstack" - md5hash2 = self.MD5HASH2 - hyper2 = "xen" - cmd2 = ' '.join((os2, arch2, ver2, url2, md5hash2, hyper2)) - - cmd_output = json.loads(self.openstack( - 'compute agent create -f json ' + - cmd2 - )) - agent_id2 = str(cmd_output["agent_id"]) - - # Test compute agent delete - del_output = self.openstack( - 'compute agent delete ' + - agent_id1 + ' ' + agent_id2 - ) - self.assertOutput('', del_output) - - def test_compute_agent_list(self): - """Test compute agent create and list""" - os1 = "os_1" - arch1 = "x86_64" - ver1 = "v1" - url1 = "http://localhost" - md5hash1 = self.MD5HASH1 - hyper1 = "kvm" - cmd1 = ' '.join((os1, arch1, ver1, url1, md5hash1, hyper1)) - - cmd_output = json.loads(self.openstack( - 'compute agent create -f json ' + - cmd1 - )) - agent_id1 = str(cmd_output["agent_id"]) - self.addCleanup(self.openstack, 'compute agent delete ' + agent_id1) - - os2 = "os_2" - arch2 = "x86" - ver2 = "v2" - url2 = "http://openstack" - md5hash2 = self.MD5HASH2 - hyper2 = "xen" - cmd2 = ' '.join((os2, arch2, ver2, url2, md5hash2, hyper2)) - - cmd_output = json.loads(self.openstack( - 'compute agent create -f json ' + - cmd2 - )) - agent_id2 = str(cmd_output["agent_id"]) - self.addCleanup(self.openstack, 'compute agent delete ' + agent_id2) - - # Test compute agent list - cmd_output = json.loads(self.openstack( - 'compute agent list -f json' - )) - - hypervisors = [x["Hypervisor"] for x in cmd_output] - self.assertIn(hyper1, hypervisors) - self.assertIn(hyper2, hypervisors) - - os = [x['OS'] for x in cmd_output] - self.assertIn(os1, os) - self.assertIn(os2, os) - - archs = [x['Architecture'] for x in cmd_output] - self.assertIn(arch1, archs) - self.assertIn(arch2, archs) - - versions = [x['Version'] for x in cmd_output] - self.assertIn(ver1, versions) - self.assertIn(ver2, versions) - - md5hashes = [x['Md5Hash'] for x in cmd_output] - self.assertIn(md5hash1, md5hashes) - self.assertIn(md5hash2, md5hashes) - - urls = [x['URL'] for x in cmd_output] - self.assertIn(url1, urls) - self.assertIn(url2, urls) - - # Test compute agent list --hypervisor - cmd_output = json.loads(self.openstack( - 'compute agent list -f json ' + - '--hypervisor kvm' - )) - - hypervisors = [x["Hypervisor"] for x in cmd_output] - self.assertIn(hyper1, hypervisors) - self.assertNotIn(hyper2, hypervisors) - - os = [x['OS'] for x in cmd_output] - self.assertIn(os1, os) - self.assertNotIn(os2, os) - - archs = [x['Architecture'] for x in cmd_output] - self.assertIn(arch1, archs) - self.assertNotIn(arch2, archs) - - versions = [x['Version'] for x in cmd_output] - self.assertIn(ver1, versions) - self.assertNotIn(ver2, versions) - - md5hashes = [x['Md5Hash'] for x in cmd_output] - self.assertIn(md5hash1, md5hashes) - self.assertNotIn(md5hash2, md5hashes) - - urls = [x['URL'] for x in cmd_output] - self.assertIn(url1, urls) - self.assertNotIn(url2, urls) - - def test_compute_agent_set(self): - """Test compute agent set""" - os1 = "os_1" - arch1 = "x86_64" - ver1 = "v1" - ver2 = "v2" - url1 = "http://localhost" - url2 = "http://openstack" - md5hash1 = self.MD5HASH1 - md5hash2 = self.MD5HASH2 - hyper1 = "kvm" - cmd = ' '.join((os1, arch1, ver1, url1, md5hash1, hyper1)) - - cmd_output = json.loads(self.openstack( - 'compute agent create -f json ' + - cmd - )) - agent_id = str(cmd_output["agent_id"]) - self.assertEqual(ver1, cmd_output["version"]) - self.assertEqual(url1, cmd_output["url"]) - self.assertEqual(md5hash1, cmd_output["md5hash"]) - - self.addCleanup(self.openstack, 'compute agent delete ' + agent_id) - - raw_output = self.openstack( - 'compute agent set ' + - agent_id + ' ' + - '--agent-version ' + ver2 + ' ' + - '--url ' + url2 + ' ' + - '--md5hash ' + md5hash2 - ) - self.assertOutput('', raw_output) - - cmd_output = json.loads(self.openstack( - 'compute agent list -f json' - )) - self.assertEqual(ver2, cmd_output[0]["Version"]) - self.assertEqual(url2, cmd_output[0]["URL"]) - self.assertEqual(md5hash2, cmd_output[0]["Md5Hash"]) diff --git a/openstackclient/tests/functional/compute/v2/test_server.py b/openstackclient/tests/functional/compute/v2/test_server.py index 44d9c61f..9cf2fc7f 100644 --- a/openstackclient/tests/functional/compute/v2/test_server.py +++ b/openstackclient/tests/functional/compute/v2/test_server.py @@ -10,6 +10,7 @@ # License for the specific language governing permissions and limitations # under the License. +import itertools import json import time import uuid @@ -346,6 +347,14 @@ class ServerTests(common.ComputeTestCase): # DevStack without cells. self.skipTest("No Network service present") + def _chain_addresses(addresses): + # Flatten a dict of lists mapping network names to IP addresses, + # returning only the IP addresses + # + # >>> _chain_addresses({'private': ['10.1.0.32', '172.24.5.41']}) + # ['10.1.0.32', '172.24.5.41'] + return itertools.chain(*[*addresses.values()]) + cmd_output = self.server_create() name = cmd_output['name'] self.wait_for_status(name, "ACTIVE") @@ -387,7 +396,7 @@ class ServerTests(common.ComputeTestCase): 'server show -f json ' + name )) - if floating_ip not in cmd_output['addresses']: + if floating_ip not in _chain_addresses(cmd_output['addresses']): # Hang out for a bit and try again print('retrying floating IP check') wait_time += 10 @@ -397,7 +406,7 @@ class ServerTests(common.ComputeTestCase): self.assertIn( floating_ip, - cmd_output['addresses'], + _chain_addresses(cmd_output['addresses']), ) # detach ip @@ -417,7 +426,7 @@ class ServerTests(common.ComputeTestCase): 'server show -f json ' + name )) - if floating_ip in cmd_output['addresses']: + if floating_ip in _chain_addresses(cmd_output['addresses']): # Hang out for a bit and try again print('retrying floating IP check') wait_time += 10 @@ -431,7 +440,7 @@ class ServerTests(common.ComputeTestCase): )) self.assertNotIn( floating_ip, - cmd_output['addresses'], + _chain_addresses(cmd_output['addresses']), ) def test_server_reboot(self): @@ -565,7 +574,90 @@ class ServerTests(common.ComputeTestCase): cmd_output['status'], ) - def test_server_boot_with_bdm_snapshot(self): + def _test_server_boot_with_bdm_volume(self, use_legacy): + """Test server create from volume, server delete""" + # get volume status wait function + volume_wait_for = volume_common.BaseVolumeTests.wait_for_status + + # create source empty volume + volume_name = uuid.uuid4().hex + cmd_output = json.loads(self.openstack( + 'volume create -f json ' + + '--size 1 ' + + volume_name + )) + volume_id = cmd_output["id"] + self.assertIsNotNone(volume_id) + self.addCleanup(self.openstack, 'volume delete ' + volume_name) + self.assertEqual(volume_name, cmd_output['name']) + volume_wait_for("volume", volume_name, "available") + + if use_legacy: + bdm_arg = f'--block-device-mapping vdb={volume_name}' + else: + bdm_arg = ( + f'--block-device ' + f'device_name=vdb,source_type=volume,boot_index=1,' + f'uuid={volume_id}' + ) + + # create server + server_name = uuid.uuid4().hex + server = json.loads(self.openstack( + 'server create -f json ' + + '--flavor ' + self.flavor_name + ' ' + + '--image ' + self.image_name + ' ' + + bdm_arg + ' ' + + self.network_arg + ' ' + + '--wait ' + + server_name + )) + self.assertIsNotNone(server["id"]) + self.addCleanup(self.openstack, 'server delete --wait ' + server_name) + self.assertEqual( + server_name, + server['name'], + ) + + # check server volumes_attached, format is + # {"volumes_attached": "id='2518bc76-bf0b-476e-ad6b-571973745bb5'",} + cmd_output = json.loads(self.openstack( + 'server show -f json ' + + server_name + )) + volumes_attached = cmd_output['volumes_attached'] + self.assertIsNotNone(volumes_attached) + + # check volumes + cmd_output = json.loads(self.openstack( + 'volume show -f json ' + + volume_name + )) + attachments = cmd_output['attachments'] + self.assertEqual( + 1, + len(attachments), + ) + self.assertEqual( + server['id'], + attachments[0]['server_id'], + ) + self.assertEqual( + "in-use", + cmd_output['status'], + ) + + def test_server_boot_with_bdm_volume(self): + """Test server create from image with bdm volume, server delete""" + self._test_server_boot_with_bdm_volume(use_legacy=False) + + # TODO(stephenfin): Remove when we drop support for the + # '--block-device-mapping' option + def test_server_boot_with_bdm_volume_legacy(self): + """Test server create from image with bdm volume, server delete""" + self._test_server_boot_with_bdm_volume(use_legacy=True) + + def _test_server_boot_with_bdm_snapshot(self, use_legacy): """Test server create from image with bdm snapshot, server delete""" # get volume status wait function volume_wait_for = volume_common.BaseVolumeTests.wait_for_status @@ -579,12 +671,8 @@ class ServerTests(common.ComputeTestCase): empty_volume_name )) self.assertIsNotNone(cmd_output["id"]) - self.addCleanup(self.openstack, - 'volume delete ' + empty_volume_name) - self.assertEqual( - empty_volume_name, - cmd_output['name'], - ) + self.addCleanup(self.openstack, 'volume delete ' + empty_volume_name) + self.assertEqual(empty_volume_name, cmd_output['name']) volume_wait_for("volume", empty_volume_name, "available") # create snapshot of source empty volume @@ -594,7 +682,8 @@ class ServerTests(common.ComputeTestCase): '--volume ' + empty_volume_name + ' ' + empty_snapshot_name )) - self.assertIsNotNone(cmd_output["id"]) + empty_snapshot_id = cmd_output["id"] + self.assertIsNotNone(empty_snapshot_id) # Deleting volume snapshot take time, so we need to wait until the # snapshot goes. Entries registered by self.addCleanup will be called # in the reverse order, so we need to register wait_for_delete first. @@ -608,14 +697,26 @@ class ServerTests(common.ComputeTestCase): ) volume_wait_for("volume snapshot", empty_snapshot_name, "available") + if use_legacy: + bdm_arg = ( + f'--block-device-mapping ' + f'vdb={empty_snapshot_name}:snapshot:1:true' + ) + else: + bdm_arg = ( + f'--block-device ' + f'device_name=vdb,uuid={empty_snapshot_id},' + f'source_type=snapshot,volume_size=1,' + f'delete_on_termination=true,boot_index=1' + ) + # create server with bdm snapshot server_name = uuid.uuid4().hex server = json.loads(self.openstack( 'server create -f json ' + '--flavor ' + self.flavor_name + ' ' + '--image ' + self.image_name + ' ' + - '--block-device-mapping ' - 'vdb=' + empty_snapshot_name + ':snapshot:1:true ' + + bdm_arg + ' ' + self.network_arg + ' ' + '--wait ' + server_name @@ -672,7 +773,17 @@ class ServerTests(common.ComputeTestCase): # the attached volume had been deleted pass - def test_server_boot_with_bdm_image(self): + def test_server_boot_with_bdm_snapshot(self): + """Test server create from image with bdm snapshot, server delete""" + self._test_server_boot_with_bdm_snapshot(use_legacy=False) + + # TODO(stephenfin): Remove when we drop support for the + # '--block-device-mapping' option + def test_server_boot_with_bdm_snapshot_legacy(self): + """Test server create from image with bdm snapshot, server delete""" + self._test_server_boot_with_bdm_snapshot(use_legacy=True) + + def _test_server_boot_with_bdm_image(self, use_legacy): # Tests creating a server where the root disk is backed by the given # --image but a --block-device-mapping with type=image is provided so # that the compute service creates a volume from that image and @@ -680,6 +791,32 @@ class ServerTests(common.ComputeTestCase): # marked as delete_on_termination=True so it will be automatically # deleted when the server is deleted. + if use_legacy: + # This means create a 1GB volume from the specified image, attach + # it to the server at /dev/vdb and delete the volume when the + # server is deleted. + bdm_arg = ( + f'--block-device-mapping ' + f'vdb={self.image_name}:image:1:true ' + ) + else: + # get image ID + cmd_output = json.loads(self.openstack( + 'image show -f json ' + + self.image_name + )) + image_id = cmd_output['id'] + + # This means create a 1GB volume from the specified image, attach + # it to the server at /dev/vdb and delete the volume when the + # server is deleted. + bdm_arg = ( + f'--block-device ' + f'device_name=vdb,uuid={image_id},' + f'source_type=image,volume_size=1,' + f'delete_on_termination=true,boot_index=1' + ) + # create server with bdm type=image # NOTE(mriedem): This test is a bit unrealistic in that specifying the # same image in the block device as the --image option does not really @@ -691,11 +828,7 @@ class ServerTests(common.ComputeTestCase): 'server create -f json ' + '--flavor ' + self.flavor_name + ' ' + '--image ' + self.image_name + ' ' + - '--block-device-mapping ' - # This means create a 1GB volume from the specified image, attach - # it to the server at /dev/vdb and delete the volume when the - # server is deleted. - 'vdb=' + self.image_name + ':image:1:true ' + + bdm_arg + ' ' + self.network_arg + ' ' + '--wait ' + server_name @@ -759,6 +892,14 @@ class ServerTests(common.ComputeTestCase): # the attached volume had been deleted pass + def test_server_boot_with_bdm_image(self): + self._test_server_boot_with_bdm_image(use_legacy=False) + + # TODO(stephenfin): Remove when we drop support for the + # '--block-device-mapping' option + def test_server_boot_with_bdm_image_legacy(self): + self._test_server_boot_with_bdm_image(use_legacy=True) + def test_boot_from_volume(self): # Tests creating a server using --image and --boot-from-volume where # the compute service will create a root volume of the specified size @@ -856,8 +997,7 @@ class ServerTests(common.ComputeTestCase): server = json.loads(self.openstack( 'server show -f json ' + server_name )) - self.assertIsNotNone(server['addresses']) - self.assertEqual('', server['addresses']) + self.assertEqual({}, server['addresses']) def test_server_create_with_security_group(self): """Test server create with security group ID and name""" diff --git a/openstackclient/tests/functional/compute/v2/test_server_group.py b/openstackclient/tests/functional/compute/v2/test_server_group.py index 44ecda1d..3dff3dcd 100644 --- a/openstackclient/tests/functional/compute/v2/test_server_group.py +++ b/openstackclient/tests/functional/compute/v2/test_server_group.py @@ -33,7 +33,7 @@ class ServerGroupTests(base.TestCase): cmd_output['name'] ) self.assertEqual( - 'affinity', + ['affinity'], cmd_output['policies'] ) @@ -47,7 +47,7 @@ class ServerGroupTests(base.TestCase): cmd_output['name'] ) self.assertEqual( - 'anti-affinity', + ['anti-affinity'], cmd_output['policies'] ) @@ -74,7 +74,7 @@ class ServerGroupTests(base.TestCase): cmd_output['name'] ) self.assertEqual( - 'affinity', + ['affinity'], cmd_output['policies'] ) @@ -91,7 +91,7 @@ class ServerGroupTests(base.TestCase): cmd_output['name'] ) self.assertEqual( - 'anti-affinity', + ['anti-affinity'], cmd_output['policies'] ) @@ -102,5 +102,5 @@ class ServerGroupTests(base.TestCase): self.assertIn(name1, names) self.assertIn(name2, names) policies = [x["Policies"] for x in cmd_output] - self.assertIn('affinity', policies) - self.assertIn('anti-affinity', policies) + self.assertIn(['affinity'], policies) + self.assertIn(['anti-affinity'], policies) diff --git a/openstackclient/tests/functional/image/v2/test_image.py b/openstackclient/tests/functional/image/v2/test_image.py index 264ba519..0a3a7360 100644 --- a/openstackclient/tests/functional/image/v2/test_image.py +++ b/openstackclient/tests/functional/image/v2/test_image.py @@ -119,6 +119,7 @@ class ImageTests(base.BaseImageTests): 'image set ' + '--property a=b ' + '--property c=d ' + + '--property hw_rng_model=virtio ' + '--public ' + self.name ) @@ -133,6 +134,7 @@ class ImageTests(base.BaseImageTests): 'image unset ' + '--property a ' + '--property c ' + + '--property hw_rng_model ' + self.name ) json_output = json.loads(self.openstack( diff --git a/openstackclient/tests/functional/network/v2/test_address_group.py b/openstackclient/tests/functional/network/v2/test_address_group.py new file mode 100644 index 00000000..52c628a3 --- /dev/null +++ b/openstackclient/tests/functional/network/v2/test_address_group.py @@ -0,0 +1,177 @@ +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. + +import json +import uuid + +from openstackclient.tests.functional.network.v2 import common + + +class AddressGroupTests(common.NetworkTests): + """Functional tests for address group""" + + def setUp(self): + super(AddressGroupTests, self).setUp() + # Nothing in this class works with Nova Network + if not self.haz_network: + self.skipTest("No Network service present") + if not self.is_extension_enabled('address-group'): + self.skipTest("No address-group extension present") + + def test_address_group_create_and_delete(self): + """Test create, delete multiple""" + name1 = uuid.uuid4().hex + cmd_output = json.loads(self.openstack( + 'address group create -f json ' + + name1 + )) + self.assertEqual( + name1, + cmd_output['name'], + ) + + name2 = uuid.uuid4().hex + cmd_output = json.loads(self.openstack( + 'address group create -f json ' + + name2 + )) + self.assertEqual( + name2, + cmd_output['name'], + ) + + raw_output = self.openstack( + 'address group delete ' + name1 + ' ' + name2, + ) + self.assertOutput('', raw_output) + + def test_address_group_list(self): + """Test create, list filters, delete""" + # Get project IDs + cmd_output = json.loads(self.openstack('token issue -f json ')) + auth_project_id = cmd_output['project_id'] + + cmd_output = json.loads(self.openstack('project list -f json ')) + admin_project_id = None + demo_project_id = None + for p in cmd_output: + if p['Name'] == 'admin': + admin_project_id = p['ID'] + if p['Name'] == 'demo': + demo_project_id = p['ID'] + + # Verify assumptions: + # * admin and demo projects are present + # * demo and admin are distinct projects + # * tests run as admin + self.assertIsNotNone(admin_project_id) + self.assertIsNotNone(demo_project_id) + self.assertNotEqual(admin_project_id, demo_project_id) + self.assertEqual(admin_project_id, auth_project_id) + + name1 = uuid.uuid4().hex + cmd_output = json.loads(self.openstack( + 'address group create -f json ' + + name1 + )) + self.addCleanup(self.openstack, 'address group delete ' + name1) + self.assertEqual( + admin_project_id, + cmd_output["project_id"], + ) + + name2 = uuid.uuid4().hex + cmd_output = json.loads(self.openstack( + 'address group create -f json ' + + '--project ' + demo_project_id + + ' ' + name2 + )) + self.addCleanup(self.openstack, 'address group delete ' + name2) + self.assertEqual( + demo_project_id, + cmd_output["project_id"], + ) + + # Test list + cmd_output = json.loads(self.openstack( + 'address group list -f json ', + )) + names = [x["Name"] for x in cmd_output] + self.assertIn(name1, names) + self.assertIn(name2, names) + + # Test list --project + cmd_output = json.loads(self.openstack( + 'address group list -f json ' + + '--project ' + demo_project_id + )) + names = [x["Name"] for x in cmd_output] + self.assertNotIn(name1, names) + self.assertIn(name2, names) + + # Test list --name + cmd_output = json.loads(self.openstack( + 'address group list -f json ' + + '--name ' + name1 + )) + names = [x["Name"] for x in cmd_output] + self.assertIn(name1, names) + self.assertNotIn(name2, names) + + def test_address_group_set_unset_and_show(self): + """Tests create options, set, unset, and show""" + name = uuid.uuid4().hex + newname = name + "_" + cmd_output = json.loads(self.openstack( + 'address group create -f json ' + + '--description aaaa ' + + '--address 10.0.0.1 --address 2001::/16 ' + + name + )) + self.addCleanup(self.openstack, 'address group delete ' + newname) + self.assertEqual(name, cmd_output['name']) + self.assertEqual('aaaa', cmd_output['description']) + self.assertEqual(2, len(cmd_output['addresses'])) + + # Test set name, description and address + raw_output = self.openstack( + 'address group set ' + + '--name ' + newname + ' ' + + '--description bbbb ' + + '--address 10.0.0.2 --address 192.0.0.0/8 ' + + name, + ) + self.assertOutput('', raw_output) + + # Show the updated address group + cmd_output = json.loads(self.openstack( + 'address group show -f json ' + + newname, + )) + self.assertEqual(newname, cmd_output['name']) + self.assertEqual('bbbb', cmd_output['description']) + self.assertEqual(4, len(cmd_output['addresses'])) + + # Test unset address + raw_output = self.openstack( + 'address group unset ' + + '--address 10.0.0.1 --address 2001::/16 ' + + '--address 10.0.0.2 --address 192.0.0.0/8 ' + + newname, + ) + self.assertEqual('', raw_output) + + cmd_output = json.loads(self.openstack( + 'address group show -f json ' + + newname, + )) + self.assertEqual(0, len(cmd_output['addresses'])) diff --git a/openstackclient/tests/unit/common/test_progressbar.py b/openstackclient/tests/unit/common/test_progressbar.py new file mode 100644 index 00000000..7bc0b6ba --- /dev/null +++ b/openstackclient/tests/unit/common/test_progressbar.py @@ -0,0 +1,77 @@ +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. +# + +import sys + +import six + +from openstackclient.common import progressbar +from openstackclient.tests.unit import utils + + +class TestProgressBarWrapper(utils.TestCase): + + def test_iter_file_display_progress_bar(self): + size = 98304 + file_obj = six.StringIO('X' * size) + saved_stdout = sys.stdout + try: + sys.stdout = output = FakeTTYStdout() + file_obj = progressbar.VerboseFileWrapper(file_obj, size) + chunksize = 1024 + chunk = file_obj.read(chunksize) + while chunk: + chunk = file_obj.read(chunksize) + self.assertEqual( + '[%s>] 100%%\n' % ('=' * 29), + output.getvalue() + ) + finally: + sys.stdout = saved_stdout + + def test_iter_file_no_tty(self): + size = 98304 + file_obj = six.StringIO('X' * size) + saved_stdout = sys.stdout + try: + sys.stdout = output = FakeNoTTYStdout() + file_obj = progressbar.VerboseFileWrapper(file_obj, size) + chunksize = 1024 + chunk = file_obj.read(chunksize) + while chunk: + chunk = file_obj.read(chunksize) + # If stdout is not a tty progress bar should do nothing. + self.assertEqual('', output.getvalue()) + finally: + sys.stdout = saved_stdout + + +class FakeTTYStdout(six.StringIO): + """A Fake stdout that try to emulate a TTY device as much as possible.""" + + def isatty(self): + return True + + def write(self, data): + # When a CR (carriage return) is found reset file. + if data.startswith('\r'): + self.seek(0) + data = data[1:] + return six.StringIO.write(self, data) + + +class FakeNoTTYStdout(FakeTTYStdout): + """A Fake stdout that is not a TTY device.""" + + def isatty(self): + return False diff --git a/openstackclient/tests/unit/common/test_project_cleanup.py b/openstackclient/tests/unit/common/test_project_cleanup.py new file mode 100644 index 00000000..d235aeb0 --- /dev/null +++ b/openstackclient/tests/unit/common/test_project_cleanup.py @@ -0,0 +1,183 @@ +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. + +from io import StringIO +from unittest import mock + +from openstackclient.common import project_cleanup +from openstackclient.tests.unit.identity.v3 import fakes as identity_fakes +from openstackclient.tests.unit import utils as tests_utils + + +class TestProjectCleanupBase(tests_utils.TestCommand): + + def setUp(self): + super(TestProjectCleanupBase, self).setUp() + + self.app.client_manager.sdk_connection = mock.Mock() + + +class TestProjectCleanup(TestProjectCleanupBase): + + project = identity_fakes.FakeProject.create_one_project() + + def setUp(self): + super(TestProjectCleanup, self).setUp() + self.cmd = project_cleanup.ProjectCleanup(self.app, None) + + self.project_cleanup_mock = mock.Mock() + self.sdk_connect_as_project_mock = \ + mock.Mock(return_value=self.app.client_manager.sdk_connection) + self.app.client_manager.sdk_connection.project_cleanup = \ + self.project_cleanup_mock + self.app.client_manager.sdk_connection.identity.find_project = \ + mock.Mock(return_value=self.project) + self.app.client_manager.sdk_connection.connect_as_project = \ + self.sdk_connect_as_project_mock + + def test_project_no_options(self): + arglist = [] + verifylist = [] + + self.assertRaises(tests_utils.ParserException, self.check_parser, + self.cmd, arglist, verifylist) + + def test_project_cleanup_with_filters(self): + arglist = [ + '--project', self.project.id, + '--created-before', '2200-01-01', + '--updated-before', '2200-01-02' + ] + verifylist = [ + ('dry_run', False), + ('auth_project', False), + ('project', self.project.id), + ('created_before', '2200-01-01'), + ('updated_before', '2200-01-02') + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + result = None + + with mock.patch('sys.stdin', StringIO('y')): + result = self.cmd.take_action(parsed_args) + + self.sdk_connect_as_project_mock.assert_called_with( + self.project) + filters = { + 'created_at': '2200-01-01', + 'updated_at': '2200-01-02' + } + + calls = [ + mock.call(dry_run=True, status_queue=mock.ANY, filters=filters), + mock.call(dry_run=False, status_queue=mock.ANY, filters=filters) + ] + self.project_cleanup_mock.assert_has_calls(calls) + + self.assertIsNone(result) + + def test_project_cleanup_with_project(self): + arglist = [ + '--project', self.project.id, + ] + verifylist = [ + ('dry_run', False), + ('auth_project', False), + ('project', self.project.id), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + result = None + + with mock.patch('sys.stdin', StringIO('y')): + result = self.cmd.take_action(parsed_args) + + self.sdk_connect_as_project_mock.assert_called_with( + self.project) + calls = [ + mock.call(dry_run=True, status_queue=mock.ANY, filters={}), + mock.call(dry_run=False, status_queue=mock.ANY, filters={}) + ] + self.project_cleanup_mock.assert_has_calls(calls) + + self.assertIsNone(result) + + def test_project_cleanup_with_project_abort(self): + arglist = [ + '--project', self.project.id, + ] + verifylist = [ + ('dry_run', False), + ('auth_project', False), + ('project', self.project.id), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + result = None + + with mock.patch('sys.stdin', StringIO('n')): + result = self.cmd.take_action(parsed_args) + + self.sdk_connect_as_project_mock.assert_called_with( + self.project) + calls = [ + mock.call(dry_run=True, status_queue=mock.ANY, filters={}), + ] + self.project_cleanup_mock.assert_has_calls(calls) + + self.assertIsNone(result) + + def test_project_cleanup_with_dry_run(self): + arglist = [ + '--dry-run', + '--project', self.project.id, + ] + verifylist = [ + ('dry_run', True), + ('auth_project', False), + ('project', self.project.id), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + result = None + + result = self.cmd.take_action(parsed_args) + + self.sdk_connect_as_project_mock.assert_called_with( + self.project) + self.project_cleanup_mock.assert_called_once_with( + dry_run=True, status_queue=mock.ANY, filters={}) + + self.assertIsNone(result) + + def test_project_cleanup_with_auth_project(self): + self.app.client_manager.auth_ref = mock.Mock() + self.app.client_manager.auth_ref.project_id = self.project.id + arglist = [ + '--auth-project', + ] + verifylist = [ + ('dry_run', False), + ('auth_project', True), + ('project', None), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + result = None + + with mock.patch('sys.stdin', StringIO('y')): + result = self.cmd.take_action(parsed_args) + + self.sdk_connect_as_project_mock.assert_not_called() + calls = [ + mock.call(dry_run=True, status_queue=mock.ANY, filters={}), + mock.call(dry_run=False, status_queue=mock.ANY, filters={}) + ] + self.project_cleanup_mock.assert_has_calls(calls) + + self.assertIsNone(result) diff --git a/openstackclient/tests/unit/common/test_quota.py b/openstackclient/tests/unit/common/test_quota.py index 6504c5b0..8771359c 100644 --- a/openstackclient/tests/unit/common/test_quota.py +++ b/openstackclient/tests/unit/common/test_quota.py @@ -1087,3 +1087,26 @@ class TestQuotaShow(TestQuota): identity_fakes.project_id, details=False ) self.assertNotCalled(self.network.get_quota_default) + + def test_network_quota_show_remove_empty(self): + arglist = [ + self.projects[0].name, + ] + verifylist = [ + ('project', self.projects[0].name), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + # First check that all regular values are returned + result = self.cmd.get_network_quota(parsed_args) + self.assertEqual(len(network_fakes.QUOTA), len(result)) + + # set 1 of the values to None, and verify it is not returned + orig_get_quota = self.network.get_quota + network_quotas = copy.copy(network_fakes.QUOTA) + network_quotas['healthmonitor'] = None + self.network.get_quota = mock.Mock(return_value=network_quotas) + result = self.cmd.get_network_quota(parsed_args) + self.assertEqual(len(network_fakes.QUOTA) - 1, len(result)) + # Go back to default mock + self.network.get_quota = orig_get_quota diff --git a/openstackclient/tests/unit/compute/v2/fakes.py b/openstackclient/tests/unit/compute/v2/fakes.py index 3a06d271..4a2a44de 100644 --- a/openstackclient/tests/unit/compute/v2/fakes.py +++ b/openstackclient/tests/unit/compute/v2/fakes.py @@ -19,6 +19,7 @@ from unittest import mock import uuid from novaclient import api_versions +from openstack.compute.v2 import flavor as _flavor from openstackclient.api import compute_v2 from openstackclient.tests.unit import fakes @@ -164,7 +165,6 @@ class FakeComputev2Client(object): self.extensions.resource_class = fakes.FakeResource(None, {}) self.flavors = mock.Mock() - self.flavors.resource_class = fakes.FakeResource(None, {}) self.flavor_access = mock.Mock() self.flavor_access.resource_class = fakes.FakeResource(None, {}) @@ -777,27 +777,13 @@ class FakeFlavor(object): 'os-flavor-access:is_public': True, 'description': 'description', 'OS-FLV-EXT-DATA:ephemeral': 0, - 'properties': {'property': 'value'}, + 'extra_specs': {'property': 'value'}, } # Overwrite default attributes. flavor_info.update(attrs) - # Set default methods. - flavor_methods = { - 'set_keys': None, - 'unset_keys': None, - 'get_keys': {'property': 'value'}, - } - - flavor = fakes.FakeResource(info=copy.deepcopy(flavor_info), - methods=flavor_methods, - loaded=True) - - # Set attributes with special mappings in nova client. - flavor.disabled = flavor_info['OS-FLV-DISABLED:disabled'] - flavor.is_public = flavor_info['os-flavor-access:is_public'] - flavor.ephemeral = flavor_info['OS-FLV-EXT-DATA:ephemeral'] + flavor = _flavor.Flavor(**flavor_info) return flavor @@ -1580,12 +1566,12 @@ class FakeRateLimit(object): self.next_available = next_available -class FakeServerMigration(object): - """Fake one or more server migrations.""" +class FakeMigration(object): + """Fake one or more migrations.""" @staticmethod - def create_one_server_migration(attrs=None, methods=None): - """Create a fake server migration. + def create_one_migration(attrs=None, methods=None): + """Create a fake migration. :param Dictionary attrs: A dictionary with all attributes @@ -1626,41 +1612,135 @@ class FakeServerMigration(object): return migration @staticmethod - def create_server_migrations(attrs=None, methods=None, count=2): - """Create multiple fake server migrations. + def create_migrations(attrs=None, methods=None, count=2): + """Create multiple fake migrations. :param Dictionary attrs: A dictionary with all attributes :param Dictionary methods: A dictionary with all methods :param int count: - The number of server migrations to fake + The number of migrations to fake :return: - A list of FakeResource objects faking the server migrations + A list of FakeResource objects faking the migrations """ migrations = [] for i in range(0, count): migrations.append( - FakeServerMigration.create_one_server_migration( + FakeMigration.create_one_migration( attrs, methods)) return migrations + +class FakeServerMigration(object): + """Fake one or more server migrations.""" + @staticmethod - def get_server_migrations(migrations=None, count=2): - """Get an iterable MagicMock object with a list of faked migrations. + def create_one_server_migration(attrs=None, methods=None): + """Create a fake server migration. - If server migrations list is provided, then initialize the Mock object - with the list. Otherwise create one. + :param Dictionary attrs: + A dictionary with all attributes + :param Dictionary methods: + A dictionary with all methods + :return: + A FakeResource object, with id, type, and so on + """ + attrs = attrs or {} + methods = methods or {} + + # Set default attributes. + + migration_info = { + "created_at": "2016-01-29T13:42:02.000000", + "dest_compute": "compute2", + "dest_host": "1.2.3.4", + "dest_node": "node2", + "id": random.randint(1, 999), + "server_uuid": uuid.uuid4().hex, + "source_compute": "compute1", + "source_node": "node1", + "status": "running", + "memory_total_bytes": random.randint(1, 99999), + "memory_processed_bytes": random.randint(1, 99999), + "memory_remaining_bytes": random.randint(1, 99999), + "disk_total_bytes": random.randint(1, 99999), + "disk_processed_bytes": random.randint(1, 99999), + "disk_remaining_bytes": random.randint(1, 99999), + "updated_at": "2016-01-29T13:42:02.000000", + # added in 2.59 + "uuid": uuid.uuid4().hex, + # added in 2.80 + "user_id": uuid.uuid4().hex, + "project_id": uuid.uuid4().hex, + } + + # Overwrite default attributes. + migration_info.update(attrs) - :param List migrations: - A list of FakeResource objects faking server migrations + migration = fakes.FakeResource( + info=copy.deepcopy(migration_info), + methods=methods, + loaded=True) + return migration + + +class FakeVolumeAttachment(object): + """Fake one or more volume attachments (BDMs).""" + + @staticmethod + def create_one_volume_attachment(attrs=None, methods=None): + """Create a fake volume attachment. + + :param Dictionary attrs: + A dictionary with all attributes + :param Dictionary methods: + A dictionary with all methods + :return: + A FakeResource object, with id, device, and so on + """ + attrs = attrs or {} + methods = methods or {} + + # Set default attributes. + volume_attachment_info = { + "id": uuid.uuid4().hex, + "device": "/dev/sdb", + "serverId": uuid.uuid4().hex, + "volumeId": uuid.uuid4().hex, + # introduced in API microversion 2.70 + "tag": "foo", + # introduced in API microversion 2.79 + "delete_on_termination": True, + } + + # Overwrite default attributes. + volume_attachment_info.update(attrs) + + volume_attachment = fakes.FakeResource( + info=copy.deepcopy(volume_attachment_info), + methods=methods, + loaded=True) + return volume_attachment + + @staticmethod + def create_volume_attachments(attrs=None, methods=None, count=2): + """Create multiple fake volume attachments (BDMs). + + :param Dictionary attrs: + A dictionary with all attributes + :param Dictionary methods: + A dictionary with all methods :param int count: - The number of server migrations to fake + The number of volume attachments to fake :return: - An iterable Mock object with side_effect set to a list of faked - server migrations + A list of FakeResource objects faking the volume attachments. """ - if migrations is None: - migrations = FakeServerMigration.create_server_migrations(count) - return mock.Mock(side_effect=migrations) + volume_attachments = [] + for i in range(0, count): + volume_attachments.append( + FakeVolumeAttachment.create_one_volume_attachment( + attrs, methods)) + + return volume_attachments diff --git a/openstackclient/tests/unit/compute/v2/test_aggregate.py b/openstackclient/tests/unit/compute/v2/test_aggregate.py index cd0c1525..8563f988 100644 --- a/openstackclient/tests/unit/compute/v2/test_aggregate.py +++ b/openstackclient/tests/unit/compute/v2/test_aggregate.py @@ -16,12 +16,14 @@ from unittest import mock from unittest.mock import call +from openstack import exceptions as sdk_exceptions +from openstack import utils as sdk_utils from osc_lib.cli import format_columns from osc_lib import exceptions -from osc_lib import utils from openstackclient.compute.v2 import aggregate from openstackclient.tests.unit.compute.v2 import fakes as compute_fakes +from openstackclient.tests.unit.image.v2 import fakes as image_fakes class TestAggregate(compute_fakes.TestComputev2): @@ -48,8 +50,17 @@ class TestAggregate(compute_fakes.TestComputev2): super(TestAggregate, self).setUp() # Get a shortcut to the AggregateManager Mock - self.aggregate_mock = self.app.client_manager.compute.aggregates - self.aggregate_mock.reset_mock() + self.app.client_manager.sdk_connection = mock.Mock() + self.app.client_manager.sdk_connection.compute = mock.Mock() + self.sdk_client = self.app.client_manager.sdk_connection.compute + self.sdk_client.aggregates = mock.Mock() + self.sdk_client.find_aggregate = mock.Mock() + self.sdk_client.create_aggregate = mock.Mock() + self.sdk_client.update_aggregate = mock.Mock() + self.sdk_client.update_aggregate = mock.Mock() + self.sdk_client.set_aggregate_metadata = mock.Mock() + self.sdk_client.add_host_to_aggregate = mock.Mock() + self.sdk_client.remove_host_from_aggregate = mock.Mock() class TestAggregateAddHost(TestAggregate): @@ -57,8 +68,8 @@ class TestAggregateAddHost(TestAggregate): def setUp(self): super(TestAggregateAddHost, self).setUp() - self.aggregate_mock.get.return_value = self.fake_ag - self.aggregate_mock.add_host.return_value = self.fake_ag + self.sdk_client.find_aggregate.return_value = self.fake_ag + self.sdk_client.add_host_to_aggregate.return_value = self.fake_ag self.cmd = aggregate.AddAggregateHost(self.app, None) def test_aggregate_add_host(self): @@ -72,11 +83,12 @@ class TestAggregateAddHost(TestAggregate): ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) columns, data = self.cmd.take_action(parsed_args) - self.aggregate_mock.get.assert_called_once_with(parsed_args.aggregate) - self.aggregate_mock.add_host.assert_called_once_with(self.fake_ag, - parsed_args.host) + self.sdk_client.find_aggregate.assert_called_once_with( + parsed_args.aggregate, ignore_missing=False) + self.sdk_client.add_host_to_aggregate.assert_called_once_with( + self.fake_ag.id, parsed_args.host) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, data) + self.assertItemsEqual(self.data, data) class TestAggregateCreate(TestAggregate): @@ -84,8 +96,8 @@ class TestAggregateCreate(TestAggregate): def setUp(self): super(TestAggregateCreate, self).setUp() - self.aggregate_mock.create.return_value = self.fake_ag - self.aggregate_mock.set_metadata.return_value = self.fake_ag + self.sdk_client.create_aggregate.return_value = self.fake_ag + self.sdk_client.set_aggregate_metadata.return_value = self.fake_ag self.cmd = aggregate.CreateAggregate(self.app, None) def test_aggregate_create(self): @@ -97,10 +109,10 @@ class TestAggregateCreate(TestAggregate): ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) columns, data = self.cmd.take_action(parsed_args) - self.aggregate_mock.create.assert_called_once_with(parsed_args.name, - None) + self.sdk_client.create_aggregate.assert_called_once_with( + name=parsed_args.name) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, data) + self.assertItemsEqual(self.data, data) def test_aggregate_create_with_zone(self): arglist = [ @@ -114,10 +126,10 @@ class TestAggregateCreate(TestAggregate): parsed_args = self.check_parser(self.cmd, arglist, verifylist) columns, data = self.cmd.take_action(parsed_args) - self.aggregate_mock.create.assert_called_once_with(parsed_args.name, - parsed_args.zone) + self.sdk_client.create_aggregate.assert_called_once_with( + name=parsed_args.name, availability_zone=parsed_args.zone) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, data) + self.assertItemsEqual(self.data, data) def test_aggregate_create_with_property(self): arglist = [ @@ -126,17 +138,17 @@ class TestAggregateCreate(TestAggregate): 'ag1', ] verifylist = [ - ('property', {'key1': 'value1', 'key2': 'value2'}), + ('properties', {'key1': 'value1', 'key2': 'value2'}), ('name', 'ag1'), ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) columns, data = self.cmd.take_action(parsed_args) - self.aggregate_mock.create.assert_called_once_with(parsed_args.name, - None) - self.aggregate_mock.set_metadata.assert_called_once_with( - self.fake_ag, parsed_args.property) + self.sdk_client.create_aggregate.assert_called_once_with( + name=parsed_args.name) + self.sdk_client.set_aggregate_metadata.assert_called_once_with( + self.fake_ag.id, parsed_args.properties) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, data) + self.assertItemsEqual(self.data, data) class TestAggregateDelete(TestAggregate): @@ -146,7 +158,7 @@ class TestAggregateDelete(TestAggregate): def setUp(self): super(TestAggregateDelete, self).setUp() - self.aggregate_mock.get = ( + self.sdk_client.find_aggregate = ( compute_fakes.FakeAggregate.get_aggregates(self.fake_ags)) self.cmd = aggregate.DeleteAggregate(self.app, None) @@ -158,10 +170,11 @@ class TestAggregateDelete(TestAggregate): ('aggregate', [self.fake_ags[0].id]), ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) - result = self.cmd.take_action(parsed_args) - self.aggregate_mock.get.assert_called_once_with(self.fake_ags[0].id) - self.aggregate_mock.delete.assert_called_once_with(self.fake_ags[0].id) - self.assertIsNone(result) + self.cmd.take_action(parsed_args) + self.sdk_client.find_aggregate.assert_called_once_with( + self.fake_ags[0].id, ignore_missing=False) + self.sdk_client.delete_aggregate.assert_called_once_with( + self.fake_ags[0].id, ignore_missing=False) def test_delete_multiple_aggregates(self): arglist = [] @@ -172,13 +185,13 @@ class TestAggregateDelete(TestAggregate): ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) - result = self.cmd.take_action(parsed_args) + self.cmd.take_action(parsed_args) calls = [] for a in self.fake_ags: - calls.append(call(a.id)) - self.aggregate_mock.delete.assert_has_calls(calls) - self.assertIsNone(result) + calls.append(call(a.id, ignore_missing=False)) + self.sdk_client.find_aggregate.assert_has_calls(calls) + self.sdk_client.delete_aggregate.assert_has_calls(calls) def test_delete_multiple_agggregates_with_exception(self): arglist = [ @@ -191,23 +204,21 @@ class TestAggregateDelete(TestAggregate): parsed_args = self.check_parser(self.cmd, arglist, verifylist) - find_mock_result = [self.fake_ags[0], exceptions.CommandError] - with mock.patch.object(utils, 'find_resource', - side_effect=find_mock_result) as find_mock: - try: - self.cmd.take_action(parsed_args) - self.fail('CommandError should be raised.') - except exceptions.CommandError as e: - self.assertEqual('1 of 2 aggregates failed to delete.', - str(e)) - - find_mock.assert_any_call(self.aggregate_mock, self.fake_ags[0].id) - find_mock.assert_any_call(self.aggregate_mock, 'unexist_aggregate') + self.sdk_client.find_aggregate.side_effect = [ + self.fake_ags[0], sdk_exceptions.NotFoundException] + try: + self.cmd.take_action(parsed_args) + self.fail('CommandError should be raised.') + except exceptions.CommandError as e: + self.assertEqual('1 of 2 aggregates failed to delete.', + str(e)) - self.assertEqual(2, find_mock.call_count) - self.aggregate_mock.delete.assert_called_once_with( - self.fake_ags[0].id - ) + calls = [] + for a in arglist: + calls.append(call(a, ignore_missing=False)) + self.sdk_client.find_aggregate.assert_has_calls(calls) + self.sdk_client.delete_aggregate.assert_called_with( + self.fake_ags[0].id, ignore_missing=False) class TestAggregateList(TestAggregate): @@ -245,7 +256,7 @@ class TestAggregateList(TestAggregate): def setUp(self): super(TestAggregateList, self).setUp() - self.aggregate_mock.list.return_value = [self.fake_ag] + self.sdk_client.aggregates.return_value = [self.fake_ag] self.cmd = aggregate.ListAggregate(self.app, None) def test_aggregate_list(self): @@ -254,7 +265,7 @@ class TestAggregateList(TestAggregate): columns, data = self.cmd.take_action(parsed_args) self.assertEqual(self.list_columns, columns) - self.assertItemEqual(self.list_data, tuple(data)) + self.assertItemsEqual(self.list_data, tuple(data)) def test_aggregate_list_with_long(self): arglist = [ @@ -267,7 +278,7 @@ class TestAggregateList(TestAggregate): columns, data = self.cmd.take_action(parsed_args) self.assertEqual(self.list_columns_long, columns) - self.assertListItemEqual(self.list_data_long, tuple(data)) + self.assertItemsEqual(self.list_data_long, tuple(data)) class TestAggregateRemoveHost(TestAggregate): @@ -275,11 +286,11 @@ class TestAggregateRemoveHost(TestAggregate): def setUp(self): super(TestAggregateRemoveHost, self).setUp() - self.aggregate_mock.get.return_value = self.fake_ag - self.aggregate_mock.remove_host.return_value = self.fake_ag + self.sdk_client.find_aggregate.return_value = self.fake_ag + self.sdk_client.remove_host_from_aggregate.return_value = self.fake_ag self.cmd = aggregate.RemoveAggregateHost(self.app, None) - def test_aggregate_add_host(self): + def test_aggregate_remove_host(self): arglist = [ 'ag1', 'host1', @@ -290,11 +301,12 @@ class TestAggregateRemoveHost(TestAggregate): ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) columns, data = self.cmd.take_action(parsed_args) - self.aggregate_mock.get.assert_called_once_with(parsed_args.aggregate) - self.aggregate_mock.remove_host.assert_called_once_with( - self.fake_ag, parsed_args.host) + self.sdk_client.find_aggregate.assert_called_once_with( + parsed_args.aggregate, ignore_missing=False) + self.sdk_client.remove_host_from_aggregate.assert_called_once_with( + self.fake_ag.id, parsed_args.host) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, data) + self.assertItemsEqual(self.data, data) class TestAggregateSet(TestAggregate): @@ -302,7 +314,7 @@ class TestAggregateSet(TestAggregate): def setUp(self): super(TestAggregateSet, self).setUp() - self.aggregate_mock.get.return_value = self.fake_ag + self.sdk_client.find_aggregate.return_value = self.fake_ag self.cmd = aggregate.SetAggregate(self.app, None) def test_aggregate_set_no_option(self): @@ -315,9 +327,10 @@ class TestAggregateSet(TestAggregate): parsed_args = self.check_parser(self.cmd, arglist, verifylist) result = self.cmd.take_action(parsed_args) - self.aggregate_mock.get.assert_called_once_with(parsed_args.aggregate) - self.assertNotCalled(self.aggregate_mock.update) - self.assertNotCalled(self.aggregate_mock.set_metadata) + self.sdk_client.find_aggregate.assert_called_once_with( + parsed_args.aggregate, ignore_missing=False) + self.assertNotCalled(self.sdk_client.update_aggregate) + self.assertNotCalled(self.sdk_client.set_aggregate_metadata) self.assertIsNone(result) def test_aggregate_set_with_name(self): @@ -332,10 +345,11 @@ class TestAggregateSet(TestAggregate): parsed_args = self.check_parser(self.cmd, arglist, verifylist) result = self.cmd.take_action(parsed_args) - self.aggregate_mock.get.assert_called_once_with(parsed_args.aggregate) - self.aggregate_mock.update.assert_called_once_with( - self.fake_ag, {'name': parsed_args.name}) - self.assertNotCalled(self.aggregate_mock.set_metadata) + self.sdk_client.find_aggregate.assert_called_once_with( + parsed_args.aggregate, ignore_missing=False) + self.sdk_client.update_aggregate.assert_called_once_with( + self.fake_ag.id, name=parsed_args.name) + self.assertNotCalled(self.sdk_client.set_aggregate_metadata) self.assertIsNone(result) def test_aggregate_set_with_zone(self): @@ -350,10 +364,11 @@ class TestAggregateSet(TestAggregate): parsed_args = self.check_parser(self.cmd, arglist, verifylist) result = self.cmd.take_action(parsed_args) - self.aggregate_mock.get.assert_called_once_with(parsed_args.aggregate) - self.aggregate_mock.update.assert_called_once_with( - self.fake_ag, {'availability_zone': parsed_args.zone}) - self.assertNotCalled(self.aggregate_mock.set_metadata) + self.sdk_client.find_aggregate.assert_called_once_with( + parsed_args.aggregate, ignore_missing=False) + self.sdk_client.update_aggregate.assert_called_once_with( + self.fake_ag.id, availability_zone=parsed_args.zone) + self.assertNotCalled(self.sdk_client.set_aggregate_metadata) self.assertIsNone(result) def test_aggregate_set_with_property(self): @@ -363,16 +378,17 @@ class TestAggregateSet(TestAggregate): 'ag1', ] verifylist = [ - ('property', {'key1': 'value1', 'key2': 'value2'}), + ('properties', {'key1': 'value1', 'key2': 'value2'}), ('aggregate', 'ag1'), ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) result = self.cmd.take_action(parsed_args) - self.aggregate_mock.get.assert_called_once_with(parsed_args.aggregate) - self.assertNotCalled(self.aggregate_mock.update) - self.aggregate_mock.set_metadata.assert_called_once_with( - self.fake_ag, parsed_args.property) + self.sdk_client.find_aggregate.assert_called_once_with( + parsed_args.aggregate, ignore_missing=False) + self.assertNotCalled(self.sdk_client.update_aggregate) + self.sdk_client.set_aggregate_metadata.assert_called_once_with( + self.fake_ag.id, parsed_args.properties) self.assertIsNone(result) def test_aggregate_set_with_no_property_and_property(self): @@ -383,15 +399,16 @@ class TestAggregateSet(TestAggregate): ] verifylist = [ ('no_property', True), - ('property', {'key2': 'value2'}), + ('properties', {'key2': 'value2'}), ('aggregate', 'ag1'), ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) result = self.cmd.take_action(parsed_args) - self.aggregate_mock.get.assert_called_once_with(parsed_args.aggregate) - self.assertNotCalled(self.aggregate_mock.update) - self.aggregate_mock.set_metadata.assert_called_once_with( - self.fake_ag, {'key1': None, 'key2': 'value2'}) + self.sdk_client.find_aggregate.assert_called_once_with( + parsed_args.aggregate, ignore_missing=False) + self.assertNotCalled(self.sdk_client.update_aggregate) + self.sdk_client.set_aggregate_metadata.assert_called_once_with( + self.fake_ag.id, {'key1': None, 'key2': 'value2'}) self.assertIsNone(result) def test_aggregate_set_with_no_property(self): @@ -405,10 +422,11 @@ class TestAggregateSet(TestAggregate): ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) result = self.cmd.take_action(parsed_args) - self.aggregate_mock.get.assert_called_once_with(parsed_args.aggregate) - self.assertNotCalled(self.aggregate_mock.update) - self.aggregate_mock.set_metadata.assert_called_once_with( - self.fake_ag, {'key1': None}) + self.sdk_client.find_aggregate.assert_called_once_with( + parsed_args.aggregate, ignore_missing=False) + self.assertNotCalled(self.sdk_client.update_aggregate) + self.sdk_client.set_aggregate_metadata.assert_called_once_with( + self.fake_ag.id, {'key1': None}) self.assertIsNone(result) def test_aggregate_set_with_zone_and_no_property(self): @@ -424,11 +442,12 @@ class TestAggregateSet(TestAggregate): ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) result = self.cmd.take_action(parsed_args) - self.aggregate_mock.get.assert_called_once_with(parsed_args.aggregate) - self.aggregate_mock.update.assert_called_once_with( - self.fake_ag, {'availability_zone': parsed_args.zone}) - self.aggregate_mock.set_metadata.assert_called_once_with( - self.fake_ag, {'key1': None}) + self.sdk_client.find_aggregate.assert_called_once_with( + parsed_args.aggregate, ignore_missing=False) + self.sdk_client.update_aggregate.assert_called_once_with( + self.fake_ag.id, availability_zone=parsed_args.zone) + self.sdk_client.set_aggregate_metadata.assert_called_once_with( + self.fake_ag.id, {'key1': None}) self.assertIsNone(result) @@ -457,7 +476,7 @@ class TestAggregateShow(TestAggregate): def setUp(self): super(TestAggregateShow, self).setUp() - self.aggregate_mock.get.return_value = self.fake_ag + self.sdk_client.find_aggregate.return_value = self.fake_ag self.cmd = aggregate.ShowAggregate(self.app, None) def test_aggregate_show(self): @@ -469,10 +488,11 @@ class TestAggregateShow(TestAggregate): ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) columns, data = self.cmd.take_action(parsed_args) - self.aggregate_mock.get.assert_called_once_with(parsed_args.aggregate) + self.sdk_client.find_aggregate.assert_called_once_with( + parsed_args.aggregate, ignore_missing=False) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, tuple(data)) + self.assertItemsEqual(self.data, tuple(data)) class TestAggregateUnset(TestAggregate): @@ -480,7 +500,7 @@ class TestAggregateUnset(TestAggregate): def setUp(self): super(TestAggregateUnset, self).setUp() - self.aggregate_mock.get.return_value = self.fake_ag + self.sdk_client.find_aggregate.return_value = self.fake_ag self.cmd = aggregate.UnsetAggregate(self.app, None) def test_aggregate_unset(self): @@ -489,14 +509,14 @@ class TestAggregateUnset(TestAggregate): 'ag1', ] verifylist = [ - ('property', ['unset_key']), + ('properties', ['unset_key']), ('aggregate', 'ag1'), ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) result = self.cmd.take_action(parsed_args) - self.aggregate_mock.set_metadata.assert_called_once_with( - self.fake_ag, {'unset_key': None}) + self.sdk_client.set_aggregate_metadata.assert_called_once_with( + self.fake_ag.id, {'unset_key': None}) self.assertIsNone(result) def test_aggregate_unset_multiple_properties(self): @@ -506,14 +526,14 @@ class TestAggregateUnset(TestAggregate): 'ag1', ] verifylist = [ - ('property', ['unset_key1', 'unset_key2']), + ('properties', ['unset_key1', 'unset_key2']), ('aggregate', 'ag1'), ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) result = self.cmd.take_action(parsed_args) - self.aggregate_mock.set_metadata.assert_called_once_with( - self.fake_ag, {'unset_key1': None, 'unset_key2': None}) + self.sdk_client.set_aggregate_metadata.assert_called_once_with( + self.fake_ag.id, {'unset_key1': None, 'unset_key2': None}) self.assertIsNone(result) def test_aggregate_unset_no_option(self): @@ -521,10 +541,77 @@ class TestAggregateUnset(TestAggregate): 'ag1', ] verifylist = [ - ('property', None), + ('properties', []), ('aggregate', 'ag1'), ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) result = self.cmd.take_action(parsed_args) - self.assertNotCalled(self.aggregate_mock.set_metadata) + self.assertNotCalled(self.sdk_client.set_aggregate_metadata) self.assertIsNone(result) + + +class TestAggregateCacheImage(TestAggregate): + + images = image_fakes.FakeImage.create_images(count=2) + + def setUp(self): + super(TestAggregateCacheImage, self).setUp() + + self.sdk_client.find_aggregate.return_value = self.fake_ag + self.find_image_mock = mock.Mock(side_effect=self.images) + self.app.client_manager.sdk_connection.image.find_image = \ + self.find_image_mock + + self.cmd = aggregate.CacheImageForAggregate(self.app, None) + + @mock.patch.object(sdk_utils, 'supports_microversion', return_value=False) + def test_aggregate_not_supported(self, sm_mock): + arglist = [ + 'ag1', + 'im1' + ] + verifylist = [ + ('aggregate', 'ag1'), + ('image', ['im1']), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + self.assertRaises( + exceptions.CommandError, + self.cmd.take_action, + parsed_args + ) + + @mock.patch.object(sdk_utils, 'supports_microversion', return_value=True) + def test_aggregate_add_single_image(self, sm_mock): + arglist = [ + 'ag1', + 'im1' + ] + verifylist = [ + ('aggregate', 'ag1'), + ('image', ['im1']), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + self.cmd.take_action(parsed_args) + self.sdk_client.find_aggregate.assert_called_once_with( + parsed_args.aggregate, ignore_missing=False) + self.sdk_client.aggregate_precache_images.assert_called_once_with( + self.fake_ag.id, [self.images[0].id]) + + @mock.patch.object(sdk_utils, 'supports_microversion', return_value=True) + def test_aggregate_add_multiple_images(self, sm_mock): + arglist = [ + 'ag1', + 'im1', + 'im2', + ] + verifylist = [ + ('aggregate', 'ag1'), + ('image', ['im1', 'im2']), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + self.cmd.take_action(parsed_args) + self.sdk_client.find_aggregate.assert_called_once_with( + parsed_args.aggregate, ignore_missing=False) + self.sdk_client.aggregate_precache_images.assert_called_once_with( + self.fake_ag.id, [self.images[0].id, self.images[1].id]) diff --git a/openstackclient/tests/unit/compute/v2/test_flavor.py b/openstackclient/tests/unit/compute/v2/test_flavor.py index 2828d74e..ee4479b0 100644 --- a/openstackclient/tests/unit/compute/v2/test_flavor.py +++ b/openstackclient/tests/unit/compute/v2/test_flavor.py @@ -12,11 +12,11 @@ # License for the specific language governing permissions and limitations # under the License. # - from unittest import mock -from unittest.mock import call -import novaclient +from openstack.compute.v2 import flavor as _flavor +from openstack import exceptions as sdk_exceptions +from openstack import utils as sdk_utils from osc_lib.cli import format_columns from osc_lib import exceptions @@ -31,13 +31,19 @@ class TestFlavor(compute_fakes.TestComputev2): def setUp(self): super(TestFlavor, self).setUp() - # Get a shortcut to the FlavorManager Mock - self.flavors_mock = self.app.client_manager.compute.flavors - self.flavors_mock.reset_mock() - - # Get a shortcut to the FlavorAccessManager Mock - self.flavor_access_mock = self.app.client_manager.compute.flavor_access - self.flavor_access_mock.reset_mock() + # SDK mock + self.app.client_manager.sdk_connection = mock.Mock() + self.app.client_manager.sdk_connection.compute = mock.Mock() + self.sdk_client = self.app.client_manager.sdk_connection.compute + self.sdk_client.flavors = mock.Mock() + self.sdk_client.find_flavor = mock.Mock() + self.sdk_client.delete_flavor = mock.Mock() + self.sdk_client.update_flavor = mock.Mock() + self.sdk_client.flavor_add_tenant_access = mock.Mock() + self.sdk_client.flavor_remove_tenant_access = mock.Mock() + self.sdk_client.create_flavor_extra_specs = mock.Mock() + self.sdk_client.update_flavor_extra_specs_property = mock.Mock() + self.sdk_client.delete_flavor_extra_specs_property = mock.Mock() self.projects_mock = self.app.client_manager.identity.projects self.projects_mock.reset_mock() @@ -48,6 +54,7 @@ class TestFlavorCreate(TestFlavor): flavor = compute_fakes.FakeFlavor.create_one_flavor( attrs={'links': 'flavor-links'}) project = identity_fakes.FakeProject.create_one_project() + columns = ( 'OS-FLV-DISABLED:disabled', 'OS-FLV-EXT-DATA:ephemeral', @@ -60,17 +67,32 @@ class TestFlavorCreate(TestFlavor): 'ram', 'rxtx_factor', 'swap', - 'vcpus', + 'vcpus' ) + data = ( - flavor.disabled, + flavor.is_disabled, flavor.ephemeral, flavor.description, flavor.disk, flavor.id, flavor.name, flavor.is_public, - format_columns.DictColumn(flavor.properties), + format_columns.DictColumn(flavor.extra_specs), + flavor.ram, + flavor.rxtx_factor, + flavor.swap, + flavor.vcpus, + ) + data_private = ( + flavor.is_disabled, + flavor.ephemeral, + flavor.description, + flavor.disk, + flavor.id, + flavor.name, + False, + format_columns.DictColumn(flavor.extra_specs), flavor.ram, flavor.rxtx_factor, flavor.swap, @@ -82,7 +104,7 @@ class TestFlavorCreate(TestFlavor): # Return a project self.projects_mock.get.return_value = self.project - self.flavors_mock.create.return_value = self.flavor + self.sdk_client.create_flavor.return_value = self.flavor self.cmd = flavor.CreateFlavor(self.app, None) def test_flavor_create_default_options(self): @@ -95,23 +117,23 @@ class TestFlavorCreate(TestFlavor): ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) - default_args = ( - self.flavor.name, - 256, - 1, - 0, - 'auto', - 0, - 0, - 1.0, - True, - None, - ) + default_args = { + 'name': self.flavor.name, + 'ram': 256, + 'vcpus': 1, + 'disk': 0, + 'id': None, + 'ephemeral': 0, + 'swap': 0, + 'rxtx_factor': 1.0, + 'is_public': True, + } + columns, data = self.cmd.take_action(parsed_args) - self.flavors_mock.create.assert_called_once_with(*default_args) + self.sdk_client.create_flavor.assert_called_once_with(**default_args) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, data) + self.assertItemsEqual(self.data, data) def test_flavor_create_all_options(self): @@ -138,34 +160,49 @@ class TestFlavorCreate(TestFlavor): ('rxtx_factor', self.flavor.rxtx_factor), ('public', True), ('description', self.flavor.description), - ('property', {'property': 'value'}), + ('properties', {'property': 'value'}), ('name', self.flavor.name), ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) - args = ( - self.flavor.name, - self.flavor.ram, - self.flavor.vcpus, - self.flavor.disk, - self.flavor.id, - self.flavor.ephemeral, - self.flavor.swap, - self.flavor.rxtx_factor, - self.flavor.is_public, - self.flavor.description, - ) - self.app.client_manager.compute.api_version = 2.55 - with mock.patch.object(novaclient.api_versions, - 'APIVersion', - return_value=2.55): + args = { + 'name': self.flavor.name, + 'ram': self.flavor.ram, + 'vcpus': self.flavor.vcpus, + 'disk': self.flavor.disk, + 'id': self.flavor.id, + 'ephemeral': self.flavor.ephemeral, + 'swap': self.flavor.swap, + 'rxtx_factor': self.flavor.rxtx_factor, + 'is_public': self.flavor.is_public, + 'description': self.flavor.description + } + + props = {'property': 'value'} + + # SDK updates the flavor object instance. In order to make the + # verification clear and preciese let's create new flavor and change + # expected props this way + create_flavor = _flavor.Flavor(**self.flavor) + expected_flavor = _flavor.Flavor(**self.flavor) + expected_flavor.extra_specs = props + # convert expected data tuple to list to be able to modify it + cmp_data = list(self.data) + cmp_data[7] = format_columns.DictColumn(props) + self.sdk_client.create_flavor.return_value = create_flavor + self.sdk_client.create_flavor_extra_specs.return_value = \ + expected_flavor + + with mock.patch.object(sdk_utils, 'supports_microversion', + return_value=True): columns, data = self.cmd.take_action(parsed_args) - self.flavors_mock.create.assert_called_once_with(*args) - self.flavor.set_keys.assert_called_once_with({'property': 'value'}) - self.flavor.get_keys.assert_called_once_with() + self.sdk_client.create_flavor.assert_called_once_with(**args) + self.sdk_client.create_flavor_extra_specs.assert_called_once_with( + create_flavor, props) + self.sdk_client.get_flavor_access.assert_not_called() self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, data) + self.assertItemsEqual(tuple(cmp_data), data) def test_flavor_create_other_options(self): @@ -195,38 +232,52 @@ class TestFlavorCreate(TestFlavor): ('public', False), ('description', 'description'), ('project', self.project.id), - ('property', {'key1': 'value1', 'key2': 'value2'}), + ('properties', {'key1': 'value1', 'key2': 'value2'}), ('name', self.flavor.name), ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) - args = ( - self.flavor.name, - self.flavor.ram, - self.flavor.vcpus, - self.flavor.disk, - 'auto', - self.flavor.ephemeral, - self.flavor.swap, - self.flavor.rxtx_factor, - self.flavor.is_public, - self.flavor.description, - ) - self.app.client_manager.compute.api_version = 2.55 - with mock.patch.object(novaclient.api_versions, - 'APIVersion', - return_value=2.55): + args = { + 'name': self.flavor.name, + 'ram': self.flavor.ram, + 'vcpus': self.flavor.vcpus, + 'disk': self.flavor.disk, + 'id': 'auto', + 'ephemeral': self.flavor.ephemeral, + 'swap': self.flavor.swap, + 'rxtx_factor': self.flavor.rxtx_factor, + 'is_public': False, + 'description': self.flavor.description + } + + props = {'key1': 'value1', 'key2': 'value2'} + + # SDK updates the flavor object instance. In order to make the + # verification clear and preciese let's create new flavor and change + # expected props this way + create_flavor = _flavor.Flavor(**self.flavor) + expected_flavor = _flavor.Flavor(**self.flavor) + expected_flavor.extra_specs = props + expected_flavor.is_public = False + # convert expected data tuple to list to be able to modify it + cmp_data = list(self.data_private) + cmp_data[7] = format_columns.DictColumn(props) + self.sdk_client.create_flavor.return_value = create_flavor + self.sdk_client.create_flavor_extra_specs.return_value = \ + expected_flavor + + with mock.patch.object(sdk_utils, 'supports_microversion', + return_value=True): columns, data = self.cmd.take_action(parsed_args) - self.flavors_mock.create.assert_called_once_with(*args) - self.flavor_access_mock.add_tenant_access.assert_called_with( + self.sdk_client.create_flavor.assert_called_once_with(**args) + self.sdk_client.flavor_add_tenant_access.assert_called_with( self.flavor.id, self.project.id, ) - self.flavor.set_keys.assert_called_with( - {'key1': 'value1', 'key2': 'value2'}) - self.flavor.get_keys.assert_called_with() + self.sdk_client.create_flavor_extra_specs.assert_called_with( + create_flavor, props) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, data) + self.assertItemsEqual(cmp_data, data) def test_public_flavor_create_with_project(self): arglist = [ @@ -278,29 +329,28 @@ class TestFlavorCreate(TestFlavor): ('name', self.flavor.name), ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) - self.app.client_manager.compute.api_version = 2.55 - with mock.patch.object(novaclient.api_versions, - 'APIVersion', - return_value=2.55): + with mock.patch.object(sdk_utils, 'supports_microversion', + return_value=True): + columns, data = self.cmd.take_action(parsed_args) - args = ( - self.flavor.name, - self.flavor.ram, - self.flavor.vcpus, - self.flavor.disk, - self.flavor.id, - self.flavor.ephemeral, - self.flavor.swap, - self.flavor.rxtx_factor, - False, - 'fake description', - ) + args = { + 'name': self.flavor.name, + 'ram': self.flavor.ram, + 'vcpus': self.flavor.vcpus, + 'disk': self.flavor.disk, + 'id': self.flavor.id, + 'ephemeral': self.flavor.ephemeral, + 'swap': self.flavor.swap, + 'rxtx_factor': self.flavor.rxtx_factor, + 'is_public': self.flavor.is_public, + 'description': 'fake description' + } - self.flavors_mock.create.assert_called_once_with(*args) + self.sdk_client.create_flavor.assert_called_once_with(**args) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, data) + self.assertItemsEqual(self.data_private, data) def test_flavor_create_with_description_api_older(self): arglist = [ @@ -318,10 +368,8 @@ class TestFlavorCreate(TestFlavor): ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) - self.app.client_manager.compute.api_version = 2.54 - with mock.patch.object(novaclient.api_versions, - 'APIVersion', - return_value=2.55): + with mock.patch.object(sdk_utils, 'supports_microversion', + return_value=False): self.assertRaises(exceptions.CommandError, self.cmd.take_action, parsed_args) @@ -333,9 +381,7 @@ class TestFlavorDelete(TestFlavor): def setUp(self): super(TestFlavorDelete, self).setUp() - self.flavors_mock.get = ( - compute_fakes.FakeFlavor.get_flavors(self.flavors)) - self.flavors_mock.delete.return_value = None + self.sdk_client.delete_flavor.return_value = None self.cmd = flavor.DeleteFlavor(self.app, None) @@ -348,9 +394,13 @@ class TestFlavorDelete(TestFlavor): ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) + self.sdk_client.find_flavor.return_value = self.flavors[0] + result = self.cmd.take_action(parsed_args) - self.flavors_mock.delete.assert_called_with(self.flavors[0].id) + self.sdk_client.find_flavor.assert_called_with(self.flavors[0].id, + ignore_missing=False) + self.sdk_client.delete_flavor.assert_called_with(self.flavors[0].id) self.assertIsNone(result) def test_delete_multiple_flavors(self): @@ -362,12 +412,17 @@ class TestFlavorDelete(TestFlavor): ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + self.sdk_client.find_flavor.side_effect = self.flavors + result = self.cmd.take_action(parsed_args) - calls = [] - for f in self.flavors: - calls.append(call(f.id)) - self.flavors_mock.delete.assert_has_calls(calls) + find_calls = [ + mock.call(i.id, ignore_missing=False) for i in self.flavors + ] + delete_calls = [mock.call(i.id) for i in self.flavors] + self.sdk_client.find_flavor.assert_has_calls(find_calls) + self.sdk_client.delete_flavor.assert_has_calls(delete_calls) self.assertIsNone(result) def test_multi_flavors_delete_with_exception(self): @@ -380,11 +435,10 @@ class TestFlavorDelete(TestFlavor): ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) - find_mock_result = [self.flavors[0], exceptions.CommandError] - self.flavors_mock.get = ( - mock.Mock(side_effect=find_mock_result) - ) - self.flavors_mock.find.side_effect = exceptions.NotFound(None) + self.sdk_client.find_flavor.side_effect = [ + self.flavors[0], + sdk_exceptions.ResourceNotFound + ] try: self.cmd.take_action(parsed_args) @@ -392,15 +446,18 @@ class TestFlavorDelete(TestFlavor): except exceptions.CommandError as e: self.assertEqual('1 of 2 flavors failed to delete.', str(e)) - self.flavors_mock.get.assert_any_call(self.flavors[0].id) - self.flavors_mock.get.assert_any_call('unexist_flavor') - self.flavors_mock.delete.assert_called_once_with(self.flavors[0].id) + find_calls = [ + mock.call(self.flavors[0].id, ignore_missing=False), + mock.call('unexist_flavor', ignore_missing=False), + ] + delete_calls = [mock.call(self.flavors[0].id)] + self.sdk_client.find_flavor.assert_has_calls(find_calls) + self.sdk_client.delete_flavor.assert_has_calls(delete_calls) class TestFlavorList(TestFlavor): - # Return value of self.flavors_mock.list(). - flavors = compute_fakes.FakeFlavor.create_flavors(count=1) + _flavor = compute_fakes.FakeFlavor.create_one_flavor() columns = ( 'ID', @@ -418,24 +475,27 @@ class TestFlavorList(TestFlavor): ) data = (( - flavors[0].id, - flavors[0].name, - flavors[0].ram, - flavors[0].disk, - flavors[0].ephemeral, - flavors[0].vcpus, - flavors[0].is_public, - ), ) + _flavor.id, + _flavor.name, + _flavor.ram, + _flavor.disk, + _flavor.ephemeral, + _flavor.vcpus, + _flavor.is_public, + ),) data_long = (data[0] + ( - flavors[0].swap, - flavors[0].rxtx_factor, - format_columns.DictColumn(flavors[0].properties) + _flavor.swap, + _flavor.rxtx_factor, + format_columns.DictColumn(_flavor.extra_specs) ), ) def setUp(self): super(TestFlavorList, self).setUp() - self.flavors_mock.list.return_value = self.flavors + self.api_mock = mock.Mock() + self.api_mock.side_effect = [[self._flavor], [], ] + + self.sdk_client.flavors = self.api_mock # Get the command object to test self.cmd = flavor.ListFlavor(self.app, None) @@ -458,16 +518,14 @@ class TestFlavorList(TestFlavor): # Set expected values kwargs = { 'is_public': True, - 'limit': None, - 'marker': None } - self.flavors_mock.list.assert_called_with( + self.sdk_client.flavors.assert_called_with( **kwargs ) self.assertEqual(self.columns, columns) - self.assertEqual(tuple(self.data), tuple(data)) + self.assertEqual(self.data, tuple(data)) def test_flavor_list_all_flavors(self): arglist = [ @@ -487,16 +545,14 @@ class TestFlavorList(TestFlavor): # Set expected values kwargs = { 'is_public': None, - 'limit': None, - 'marker': None } - self.flavors_mock.list.assert_called_with( + self.sdk_client.flavors.assert_called_with( **kwargs ) self.assertEqual(self.columns, columns) - self.assertEqual(tuple(self.data), tuple(data)) + self.assertEqual(self.data, tuple(data)) def test_flavor_list_private_flavors(self): arglist = [ @@ -516,16 +572,14 @@ class TestFlavorList(TestFlavor): # Set expected values kwargs = { 'is_public': False, - 'limit': None, - 'marker': None } - self.flavors_mock.list.assert_called_with( + self.sdk_client.flavors.assert_called_with( **kwargs ) self.assertEqual(self.columns, columns) - self.assertEqual(tuple(self.data), tuple(data)) + self.assertEqual(self.data, tuple(data)) def test_flavor_list_public_flavors(self): arglist = [ @@ -545,16 +599,14 @@ class TestFlavorList(TestFlavor): # Set expected values kwargs = { 'is_public': True, - 'limit': None, - 'marker': None } - self.flavors_mock.list.assert_called_with( + self.sdk_client.flavors.assert_called_with( **kwargs ) self.assertEqual(self.columns, columns) - self.assertEqual(tuple(self.data), tuple(data)) + self.assertEqual(self.data, tuple(data)) def test_flavor_list_long(self): arglist = [ @@ -574,21 +626,50 @@ class TestFlavorList(TestFlavor): # Set expected values kwargs = { 'is_public': True, - 'limit': None, - 'marker': None } - self.flavors_mock.list.assert_called_with( + self.sdk_client.flavors.assert_called_with( **kwargs ) self.assertEqual(self.columns_long, columns) - self.assertListItemEqual(self.data_long, tuple(data)) + self.assertItemsEqual(self.data_long, tuple(data)) + + def test_flavor_list_min_disk_min_ram(self): + arglist = [ + '--min-disk', '10', + '--min-ram', '2048', + ] + verifylist = [ + ('min_disk', 10), + ('min_ram', 2048), + ] + + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + # In base command class Lister in cliff, abstract method take_action() + # returns a tuple containing the column names and an iterable + # containing the data to be listed. + columns, data = self.cmd.take_action(parsed_args) + + # Set expected values + kwargs = { + 'is_public': True, + 'min_disk': 10, + 'min_ram': 2048, + } + + self.sdk_client.flavors.assert_called_with( + **kwargs + ) + + self.assertEqual(self.columns, columns) + self.assertEqual(tuple(self.data), tuple(data)) class TestFlavorSet(TestFlavor): - # Return value of self.flavors_mock.find(). + # Return value of self.sdk_client.find_flavor(). flavor = compute_fakes.FakeFlavor.create_one_flavor( attrs={'os-flavor-access:is_public': False}) project = identity_fakes.FakeProject.create_one_project() @@ -596,8 +677,7 @@ class TestFlavorSet(TestFlavor): def setUp(self): super(TestFlavorSet, self).setUp() - self.flavors_mock.find.return_value = self.flavor - self.flavors_mock.get.side_effect = exceptions.NotFound(None) + self.sdk_client.find_flavor.return_value = self.flavor # Return a project self.projects_mock.get.return_value = self.project self.cmd = flavor.SetFlavor(self.app, None) @@ -608,15 +688,20 @@ class TestFlavorSet(TestFlavor): 'baremetal' ] verifylist = [ - ('property', {'FOO': '"B A R"'}), + ('properties', {'FOO': '"B A R"'}), ('flavor', 'baremetal') ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) result = self.cmd.take_action(parsed_args) - self.flavors_mock.find.assert_called_with(name=parsed_args.flavor, - is_public=None) - self.flavor.set_keys.assert_called_with({'FOO': '"B A R"'}) + self.sdk_client.find_flavor.assert_called_with( + parsed_args.flavor, + get_extra_specs=True, + ignore_missing=False + ) + self.sdk_client.create_flavor_extra_specs.assert_called_with( + self.flavor.id, + {'FOO': '"B A R"'}) self.assertIsNone(result) def test_flavor_set_no_property(self): @@ -631,9 +716,13 @@ class TestFlavorSet(TestFlavor): parsed_args = self.check_parser(self.cmd, arglist, verifylist) result = self.cmd.take_action(parsed_args) - self.flavors_mock.find.assert_called_with(name=parsed_args.flavor, - is_public=None) - self.flavor.unset_keys.assert_called_with(['property']) + self.sdk_client.find_flavor.assert_called_with( + parsed_args.flavor, + get_extra_specs=True, + ignore_missing=False + ) + self.sdk_client.delete_flavor_extra_specs_property.assert_called_with( + self.flavor.id, 'property') self.assertIsNone(result) def test_flavor_set_project(self): @@ -649,13 +738,16 @@ class TestFlavorSet(TestFlavor): result = self.cmd.take_action(parsed_args) - self.flavors_mock.find.assert_called_with(name=parsed_args.flavor, - is_public=None) - self.flavor_access_mock.add_tenant_access.assert_called_with( + self.sdk_client.find_flavor.assert_called_with( + parsed_args.flavor, + get_extra_specs=True, + ignore_missing=False + ) + self.sdk_client.flavor_add_tenant_access.assert_called_with( self.flavor.id, self.project.id, ) - self.flavor.set_keys.assert_not_called() + self.sdk_client.create_flavor_extra_specs.assert_not_called() self.assertIsNone(result) def test_flavor_set_no_project(self): @@ -681,8 +773,9 @@ class TestFlavorSet(TestFlavor): self.cmd, arglist, verifylist) def test_flavor_set_with_unexist_flavor(self): - self.flavors_mock.get.side_effect = exceptions.NotFound(None) - self.flavors_mock.find.side_effect = exceptions.NotFound(None) + self.sdk_client.find_flavor.side_effect = [ + sdk_exceptions.ResourceNotFound() + ] arglist = [ '--project', self.project.id, @@ -708,9 +801,12 @@ class TestFlavorSet(TestFlavor): parsed_args = self.check_parser(self.cmd, arglist, verifylist) result = self.cmd.take_action(parsed_args) - self.flavors_mock.find.assert_called_with(name=parsed_args.flavor, - is_public=None) - self.flavor_access_mock.add_tenant_access.assert_not_called() + self.sdk_client.find_flavor.assert_called_with( + parsed_args.flavor, + get_extra_specs=True, + ignore_missing=False + ) + self.sdk_client.flavor_add_tenant_access.assert_not_called() self.assertIsNone(result) def test_flavor_set_description_api_newer(self): @@ -724,11 +820,11 @@ class TestFlavorSet(TestFlavor): ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) self.app.client_manager.compute.api_version = 2.55 - with mock.patch.object(novaclient.api_versions, - 'APIVersion', - return_value=2.55): + with mock.patch.object(sdk_utils, + 'supports_microversion', + return_value=True): result = self.cmd.take_action(parsed_args) - self.flavors_mock.update.assert_called_with( + self.sdk_client.update_flavor.assert_called_with( flavor=self.flavor.id, description='description') self.assertIsNone(result) @@ -743,9 +839,9 @@ class TestFlavorSet(TestFlavor): ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) self.app.client_manager.compute.api_version = 2.54 - with mock.patch.object(novaclient.api_versions, - 'APIVersion', - return_value=2.55): + with mock.patch.object(sdk_utils, + 'supports_microversion', + return_value=False): self.assertRaises(exceptions.CommandError, self.cmd.take_action, parsed_args) @@ -760,11 +856,12 @@ class TestFlavorSet(TestFlavor): ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) self.app.client_manager.compute.api_version = 2.55 - with mock.patch.object(novaclient.api_versions, - 'APIVersion', - return_value=2.55): + + with mock.patch.object(sdk_utils, + 'supports_microversion', + return_value=True): result = self.cmd.take_action(parsed_args) - self.flavors_mock.update.assert_called_with( + self.sdk_client.update_flavor.assert_called_with( flavor=self.flavor.id, description='description') self.assertIsNone(result) @@ -779,16 +876,17 @@ class TestFlavorSet(TestFlavor): ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) self.app.client_manager.compute.api_version = 2.54 - with mock.patch.object(novaclient.api_versions, - 'APIVersion', - return_value=2.55): + + with mock.patch.object(sdk_utils, + 'supports_microversion', + return_value=False): self.assertRaises(exceptions.CommandError, self.cmd.take_action, parsed_args) class TestFlavorShow(TestFlavor): - # Return value of self.flavors_mock.find(). + # Return value of self.sdk_client.find_flavor(). flavor_access = compute_fakes.FakeFlavorAccess.create_one_flavor_access() flavor = compute_fakes.FakeFlavor.create_one_flavor() @@ -805,11 +903,11 @@ class TestFlavorShow(TestFlavor): 'ram', 'rxtx_factor', 'swap', - 'vcpus', + 'vcpus' ) data = ( - flavor.disabled, + flavor.is_disabled, flavor.ephemeral, None, flavor.description, @@ -817,7 +915,7 @@ class TestFlavorShow(TestFlavor): flavor.id, flavor.name, flavor.is_public, - format_columns.DictColumn(flavor.get_keys()), + format_columns.DictColumn(flavor.extra_specs), flavor.ram, flavor.rxtx_factor, flavor.swap, @@ -828,9 +926,8 @@ class TestFlavorShow(TestFlavor): super(TestFlavorShow, self).setUp() # Return value of _find_resource() - self.flavors_mock.find.return_value = self.flavor - self.flavors_mock.get.side_effect = exceptions.NotFound(None) - self.flavor_access_mock.list.return_value = [self.flavor_access] + self.sdk_client.find_flavor.return_value = self.flavor + self.sdk_client.get_flavor_access.return_value = [self.flavor_access] self.cmd = flavor.ShowFlavor(self.app, None) def test_show_no_options(self): @@ -854,7 +951,7 @@ class TestFlavorShow(TestFlavor): columns, data = self.cmd.take_action(parsed_args) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, data) + self.assertItemsEqual(self.data, data) def test_private_flavor_show(self): private_flavor = compute_fakes.FakeFlavor.create_one_flavor( @@ -862,7 +959,7 @@ class TestFlavorShow(TestFlavor): 'os-flavor-access:is_public': False, } ) - self.flavors_mock.find.return_value = private_flavor + self.sdk_client.find_flavor.return_value = private_flavor arglist = [ private_flavor.name, @@ -872,7 +969,7 @@ class TestFlavorShow(TestFlavor): ] data_with_project = ( - private_flavor.disabled, + private_flavor.is_disabled, private_flavor.ephemeral, [self.flavor_access.tenant_id], private_flavor.description, @@ -880,7 +977,7 @@ class TestFlavorShow(TestFlavor): private_flavor.id, private_flavor.name, private_flavor.is_public, - format_columns.DictColumn(private_flavor.get_keys()), + format_columns.DictColumn(private_flavor.extra_specs), private_flavor.ram, private_flavor.rxtx_factor, private_flavor.swap, @@ -891,15 +988,15 @@ class TestFlavorShow(TestFlavor): columns, data = self.cmd.take_action(parsed_args) - self.flavor_access_mock.list.assert_called_with( + self.sdk_client.get_flavor_access.assert_called_with( flavor=private_flavor.id) self.assertEqual(self.columns, columns) - self.assertItemEqual(data_with_project, data) + self.assertItemsEqual(data_with_project, data) class TestFlavorUnset(TestFlavor): - # Return value of self.flavors_mock.find(). + # Return value of self.sdk_client.find_flavor(). flavor = compute_fakes.FakeFlavor.create_one_flavor( attrs={'os-flavor-access:is_public': False}) project = identity_fakes.FakeProject.create_one_project() @@ -907,30 +1004,68 @@ class TestFlavorUnset(TestFlavor): def setUp(self): super(TestFlavorUnset, self).setUp() - self.flavors_mock.find.return_value = self.flavor - self.flavors_mock.get.side_effect = exceptions.NotFound(None) + self.sdk_client.find_flavor.return_value = self.flavor # Return a project self.projects_mock.get.return_value = self.project self.cmd = flavor.UnsetFlavor(self.app, None) + self.mock_shortcut = self.sdk_client.delete_flavor_extra_specs_property + def test_flavor_unset_property(self): arglist = [ '--property', 'property', 'baremetal' ] verifylist = [ - ('property', ['property']), + ('properties', ['property']), ('flavor', 'baremetal'), ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) result = self.cmd.take_action(parsed_args) - self.flavors_mock.find.assert_called_with(name=parsed_args.flavor, - is_public=None) - self.flavor.unset_keys.assert_called_with(['property']) - self.flavor_access_mock.remove_tenant_access.assert_not_called() + self.sdk_client.find_flavor.assert_called_with( + parsed_args.flavor, + get_extra_specs=True, + ignore_missing=False) + self.mock_shortcut.assert_called_with( + self.flavor.id, 'property') + self.sdk_client.flavor_remove_tenant_access.assert_not_called() self.assertIsNone(result) + def test_flavor_unset_properties(self): + arglist = [ + '--property', 'property1', + '--property', 'property2', + 'baremetal' + ] + verifylist = [ + ('properties', ['property1', 'property2']), + ('flavor', 'baremetal'), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + self.cmd.take_action(parsed_args) + self.sdk_client.find_flavor.assert_called_with( + parsed_args.flavor, + get_extra_specs=True, + ignore_missing=False) + calls = [ + mock.call(self.flavor.id, 'property1'), + mock.call(self.flavor.id, 'property2') + ] + self.mock_shortcut.assert_has_calls( + calls) + + # A bit tricky way to ensure we do not unset other properties + calls.append(mock.call(self.flavor.id, 'property')) + self.assertRaises( + AssertionError, + self.mock_shortcut.assert_has_calls, + calls + ) + + self.sdk_client.flavor_remove_tenant_access.assert_not_called() + def test_flavor_unset_project(self): arglist = [ '--project', self.project.id, @@ -945,13 +1080,14 @@ class TestFlavorUnset(TestFlavor): result = self.cmd.take_action(parsed_args) self.assertIsNone(result) - self.flavors_mock.find.assert_called_with(name=parsed_args.flavor, - is_public=None) - self.flavor_access_mock.remove_tenant_access.assert_called_with( + self.sdk_client.find_flavor.assert_called_with( + parsed_args.flavor, get_extra_specs=True, + ignore_missing=False) + self.sdk_client.flavor_remove_tenant_access.assert_called_with( self.flavor.id, self.project.id, ) - self.flavor.unset_keys.assert_not_called() + self.sdk_client.delete_flavor_extra_specs_proerty.assert_not_called() self.assertIsNone(result) def test_flavor_unset_no_project(self): @@ -977,8 +1113,9 @@ class TestFlavorUnset(TestFlavor): self.cmd, arglist, verifylist) def test_flavor_unset_with_unexist_flavor(self): - self.flavors_mock.get.side_effect = exceptions.NotFound(None) - self.flavors_mock.find.side_effect = exceptions.NotFound(None) + self.sdk_client.find_flavor.side_effect = [ + sdk_exceptions.ResourceNotFound + ] arglist = [ '--project', self.project.id, @@ -1004,4 +1141,4 @@ class TestFlavorUnset(TestFlavor): result = self.cmd.take_action(parsed_args) self.assertIsNone(result) - self.flavor_access_mock.remove_tenant_access.assert_not_called() + self.sdk_client.flavor_remove_tenant_access.assert_not_called() diff --git a/openstackclient/tests/unit/compute/v2/test_hypervisor.py b/openstackclient/tests/unit/compute/v2/test_hypervisor.py index 7200d04e..3220a764 100644 --- a/openstackclient/tests/unit/compute/v2/test_hypervisor.py +++ b/openstackclient/tests/unit/compute/v2/test_hypervisor.py @@ -14,8 +14,11 @@ # import copy +import json +from novaclient import api_versions from novaclient import exceptions as nova_exceptions +from osc_lib.cli import format_columns from osc_lib import exceptions from openstackclient.compute.v2 import hypervisor @@ -170,6 +173,30 @@ class TestHypervisorList(TestHypervisor): self.cmd.take_action, parsed_args) + def test_hypervisor_list_with_matching_and_pagination_options(self): + self.app.client_manager.compute.api_version = \ + api_versions.APIVersion('2.32') + + arglist = [ + '--matching', self.hypervisors[0].hypervisor_hostname, + '--limit', '1', + '--marker', self.hypervisors[0].hypervisor_hostname, + ] + verifylist = [ + ('matching', self.hypervisors[0].hypervisor_hostname), + ('limit', 1), + ('marker', self.hypervisors[0].hypervisor_hostname), + ] + + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + ex = self.assertRaises( + exceptions.CommandError, + self.cmd.take_action, + parsed_args) + + self.assertIn( + '--matching is not compatible with --marker or --limit', str(ex)) + def test_hypervisor_list_long_option(self): arglist = [ '--long', @@ -188,6 +215,78 @@ class TestHypervisorList(TestHypervisor): self.assertEqual(self.columns_long, columns) self.assertEqual(self.data_long, tuple(data)) + def test_hypervisor_list_with_limit(self): + self.app.client_manager.compute.api_version = \ + api_versions.APIVersion('2.33') + + arglist = [ + '--limit', '1', + ] + verifylist = [ + ('limit', 1), + ] + + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + self.cmd.take_action(parsed_args) + + self.hypervisors_mock.list.assert_called_with(limit=1) + + def test_hypervisor_list_with_limit_pre_v233(self): + self.app.client_manager.compute.api_version = \ + api_versions.APIVersion('2.32') + + arglist = [ + '--limit', '1', + ] + verifylist = [ + ('limit', 1), + ] + + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + ex = self.assertRaises( + exceptions.CommandError, + self.cmd.take_action, + parsed_args) + + self.assertIn( + '--os-compute-api-version 2.33 or greater is required', str(ex)) + + def test_hypervisor_list_with_marker(self): + self.app.client_manager.compute.api_version = \ + api_versions.APIVersion('2.33') + + arglist = [ + '--marker', 'test_hyp', + ] + verifylist = [ + ('marker', 'test_hyp'), + ] + + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + self.cmd.take_action(parsed_args) + + self.hypervisors_mock.list.assert_called_with(marker='test_hyp') + + def test_hypervisor_list_with_marker_pre_v233(self): + self.app.client_manager.compute.api_version = \ + api_versions.APIVersion('2.32') + + arglist = [ + '--marker', 'test_hyp', + ] + verifylist = [ + ('marker', 'test_hyp'), + ] + + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + ex = self.assertRaises( + exceptions.CommandError, + self.cmd.take_action, + parsed_args) + + self.assertIn( + '--os-compute-api-version 2.33 or greater is required', str(ex)) + class TestHypervisorShow(TestHypervisor): @@ -247,7 +346,7 @@ class TestHypervisorShow(TestHypervisor): ) self.data = ( [], - {'aaa': 'aaa'}, + format_columns.DictColumn({'aaa': 'aaa'}), 0, 50, 50, @@ -278,6 +377,9 @@ class TestHypervisorShow(TestHypervisor): self.cmd = hypervisor.ShowHypervisor(self.app, None) def test_hypervisor_show(self): + self.app.client_manager.compute.api_version = \ + api_versions.APIVersion('2.28') + arglist = [ self.hypervisor.hypervisor_hostname, ] @@ -292,9 +394,38 @@ class TestHypervisorShow(TestHypervisor): columns, data = self.cmd.take_action(parsed_args) self.assertEqual(self.columns, columns) - self.assertEqual(self.data, data) + self.assertItemsEqual(self.data, data) + + def test_hypervisor_show_pre_v228(self): + self.app.client_manager.compute.api_version = \ + api_versions.APIVersion('2.27') + + # before microversion 2.28, nova returned a stringified version of this + # field + self.hypervisor._info['cpu_info'] = json.dumps( + self.hypervisor._info['cpu_info']) + self.hypervisors_mock.get.return_value = self.hypervisor + + arglist = [ + self.hypervisor.hypervisor_hostname, + ] + verifylist = [ + ('hypervisor', self.hypervisor.hypervisor_hostname), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + # In base command class ShowOne in cliff, abstract method take_action() + # returns a two-part tuple with a tuple of column names and a tuple of + # data to be shown. + columns, data = self.cmd.take_action(parsed_args) + + self.assertEqual(self.columns, columns) + self.assertItemsEqual(self.data, data) + + def test_hypervisor_show_uptime_not_implemented(self): + self.app.client_manager.compute.api_version = \ + api_versions.APIVersion('2.28') - def test_hyprvisor_show_uptime_not_implemented(self): arglist = [ self.hypervisor.hypervisor_hostname, ] @@ -337,7 +468,7 @@ class TestHypervisorShow(TestHypervisor): ) expected_data = ( [], - {'aaa': 'aaa'}, + format_columns.DictColumn({'aaa': 'aaa'}), 0, 50, 50, @@ -361,4 +492,4 @@ class TestHypervisorShow(TestHypervisor): ) self.assertEqual(expected_columns, columns) - self.assertEqual(expected_data, data) + self.assertItemsEqual(expected_data, data) diff --git a/openstackclient/tests/unit/compute/v2/test_keypair.py b/openstackclient/tests/unit/compute/v2/test_keypair.py index 9632a667..65d9396a 100644 --- a/openstackclient/tests/unit/compute/v2/test_keypair.py +++ b/openstackclient/tests/unit/compute/v2/test_keypair.py @@ -19,8 +19,8 @@ from unittest.mock import call import uuid from novaclient import api_versions +from openstack import utils as sdk_utils from osc_lib import exceptions -from osc_lib import utils from openstackclient.compute.v2 import keypair from openstackclient.tests.unit.compute.v2 import fakes as compute_fakes @@ -34,10 +34,6 @@ class TestKeypair(compute_fakes.TestComputev2): def setUp(self): super(TestKeypair, self).setUp() - # Get a shortcut to the KeypairManager Mock - self.keypairs_mock = self.app.client_manager.compute.keypairs - self.keypairs_mock.reset_mock() - # Initialize the user mock self.users_mock = self.app.client_manager.identity.users self.users_mock.reset_mock() @@ -47,6 +43,14 @@ class TestKeypair(compute_fakes.TestComputev2): loaded=True, ) + self.app.client_manager.sdk_connection = mock.Mock() + self.app.client_manager.sdk_connection.compute = mock.Mock() + self.sdk_client = self.app.client_manager.sdk_connection.compute + self.sdk_client.keypairs = mock.Mock() + self.sdk_client.create_keypair = mock.Mock() + self.sdk_client.delete_keypair = mock.Mock() + self.sdk_client.find_keypair = mock.Mock() + class TestKeypairCreate(TestKeypair): @@ -71,7 +75,7 @@ class TestKeypairCreate(TestKeypair): # Get the command object to test self.cmd = keypair.CreateKeypair(self.app, None) - self.keypairs_mock.create.return_value = self.keypair + self.sdk_client.create_keypair.return_value = self.keypair def test_key_pair_create_no_options(self): @@ -85,9 +89,8 @@ class TestKeypairCreate(TestKeypair): columns, data = self.cmd.take_action(parsed_args) - self.keypairs_mock.create.assert_called_with( - name=self.keypair.name, - public_key=None + self.sdk_client.create_keypair.assert_called_with( + name=self.keypair.name ) self.assertEqual({}, columns) @@ -97,7 +100,7 @@ class TestKeypairCreate(TestKeypair): # overwrite the setup one because we want to omit private_key self.keypair = compute_fakes.FakeKeypair.create_one_keypair( no_pri=True) - self.keypairs_mock.create.return_value = self.keypair + self.sdk_client.create_keypair.return_value = self.keypair self.data = ( self.keypair.fingerprint, @@ -124,7 +127,7 @@ class TestKeypairCreate(TestKeypair): columns, data = self.cmd.take_action(parsed_args) - self.keypairs_mock.create.assert_called_with( + self.sdk_client.create_keypair.assert_called_with( name=self.keypair.name, public_key=self.keypair.public_key, ) @@ -151,9 +154,8 @@ class TestKeypairCreate(TestKeypair): columns, data = self.cmd.take_action(parsed_args) - self.keypairs_mock.create.assert_called_with( + self.sdk_client.create_keypair.assert_called_with( name=self.keypair.name, - public_key=None, ) mock_open.assert_called_once_with(tmp_pk_file, 'w+') @@ -162,14 +164,12 @@ class TestKeypairCreate(TestKeypair): self.assertEqual(self.columns, columns) self.assertEqual(self.data, data) - def test_keypair_create_with_key_type(self): - self.app.client_manager.compute.api_version = api_versions.APIVersion( - '2.2') - + @mock.patch.object(sdk_utils, 'supports_microversion', return_value=True) + def test_keypair_create_with_key_type(self, sm_mock): for key_type in ['x509', 'ssh']: self.keypair = compute_fakes.FakeKeypair.create_one_keypair( no_pri=True) - self.keypairs_mock.create.return_value = self.keypair + self.sdk_client.create_keypair.return_value = self.keypair self.data = ( self.keypair.fingerprint, @@ -195,7 +195,7 @@ class TestKeypairCreate(TestKeypair): m_file.read.return_value = 'dummy' columns, data = self.cmd.take_action(parsed_args) - self.keypairs_mock.create.assert_called_with( + self.sdk_client.create_keypair.assert_called_with( name=self.keypair.name, public_key=self.keypair.public_key, key_type=key_type, @@ -204,10 +204,8 @@ class TestKeypairCreate(TestKeypair): self.assertEqual(self.columns, columns) self.assertEqual(self.data, data) - def test_keypair_create_with_key_type_pre_v22(self): - self.app.client_manager.compute.api_version = api_versions.APIVersion( - '2.1') - + @mock.patch.object(sdk_utils, 'supports_microversion', return_value=False) + def test_keypair_create_with_key_type_pre_v22(self, sm_mock): for key_type in ['x509', 'ssh']: arglist = [ '--public-key', self.keypair.public_key, @@ -235,11 +233,8 @@ class TestKeypairCreate(TestKeypair): '--os-compute-api-version 2.2 or greater is required', str(ex)) - def test_key_pair_create_with_user(self): - - self.app.client_manager.compute.api_version = \ - api_versions.APIVersion('2.10') - + @mock.patch.object(sdk_utils, 'supports_microversion', return_value=True) + def test_key_pair_create_with_user(self, sm_mock): arglist = [ '--user', identity_fakes.user_name, self.keypair.name, @@ -252,20 +247,16 @@ class TestKeypairCreate(TestKeypair): columns, data = self.cmd.take_action(parsed_args) - self.keypairs_mock.create.assert_called_with( + self.sdk_client.create_keypair.assert_called_with( name=self.keypair.name, - public_key=None, user_id=identity_fakes.user_id, ) self.assertEqual({}, columns) self.assertEqual({}, data) - def test_key_pair_create_with_user_pre_v210(self): - - self.app.client_manager.compute.api_version = \ - api_versions.APIVersion('2.9') - + @mock.patch.object(sdk_utils, 'supports_microversion', return_value=False) + def test_key_pair_create_with_user_pre_v210(self, sm_mock): arglist = [ '--user', identity_fakes.user_name, self.keypair.name, @@ -291,10 +282,6 @@ class TestKeypairDelete(TestKeypair): def setUp(self): super(TestKeypairDelete, self).setUp() - self.keypairs_mock.get = compute_fakes.FakeKeypair.get_keypairs( - self.keypairs) - self.keypairs_mock.delete.return_value = None - self.cmd = keypair.DeleteKeypair(self.app, None) def test_keypair_delete(self): @@ -310,7 +297,8 @@ class TestKeypairDelete(TestKeypair): ret = self.cmd.take_action(parsed_args) self.assertIsNone(ret) - self.keypairs_mock.delete.assert_called_with(self.keypairs[0].name) + self.sdk_client.delete_keypair.assert_called_with( + self.keypairs[0].name, ignore_missing=False) def test_delete_multiple_keypairs(self): arglist = [] @@ -325,8 +313,8 @@ class TestKeypairDelete(TestKeypair): calls = [] for k in self.keypairs: - calls.append(call(k.name)) - self.keypairs_mock.delete.assert_has_calls(calls) + calls.append(call(k.name, ignore_missing=False)) + self.sdk_client.delete_keypair.assert_has_calls(calls) self.assertIsNone(result) def test_delete_multiple_keypairs_with_exception(self): @@ -340,29 +328,21 @@ class TestKeypairDelete(TestKeypair): parsed_args = self.check_parser(self.cmd, arglist, verifylist) - find_mock_result = [self.keypairs[0], exceptions.CommandError] - with mock.patch.object(utils, 'find_resource', - side_effect=find_mock_result) as find_mock: - try: - self.cmd.take_action(parsed_args) - self.fail('CommandError should be raised.') - except exceptions.CommandError as e: - self.assertEqual('1 of 2 keys failed to delete.', str(e)) - - find_mock.assert_any_call( - self.keypairs_mock, self.keypairs[0].name) - find_mock.assert_any_call(self.keypairs_mock, 'unexist_keypair') - - self.assertEqual(2, find_mock.call_count) - self.keypairs_mock.delete.assert_called_once_with( - self.keypairs[0].name - ) - - def test_keypair_delete_with_user(self): + self.sdk_client.delete_keypair.side_effect = [ + None, exceptions.CommandError] + try: + self.cmd.take_action(parsed_args) + self.fail('CommandError should be raised.') + except exceptions.CommandError as e: + self.assertEqual('1 of 2 keys failed to delete.', str(e)) - self.app.client_manager.compute.api_version = \ - api_versions.APIVersion('2.10') + calls = [] + for k in arglist: + calls.append(call(k, ignore_missing=False)) + self.sdk_client.delete_keypair.assert_has_calls(calls) + @mock.patch.object(sdk_utils, 'supports_microversion', return_value=True) + def test_keypair_delete_with_user(self, sm_mock): arglist = [ '--user', identity_fakes.user_name, self.keypairs[0].name @@ -376,12 +356,14 @@ class TestKeypairDelete(TestKeypair): ret = self.cmd.take_action(parsed_args) self.assertIsNone(ret) - self.keypairs_mock.delete.assert_called_with( + self.sdk_client.delete_keypair.assert_called_with( self.keypairs[0].name, user_id=identity_fakes.user_id, + ignore_missing=False ) - def test_keypair_delete_with_user_pre_v210(self): + @mock.patch.object(sdk_utils, 'supports_microversion', return_value=False) + def test_keypair_delete_with_user_pre_v210(self, sm_mock): self.app.client_manager.compute.api_version = \ api_versions.APIVersion('2.9') @@ -406,18 +388,19 @@ class TestKeypairDelete(TestKeypair): class TestKeypairList(TestKeypair): - # Return value of self.keypairs_mock.list(). + # Return value of self.sdk_client.keypairs(). keypairs = compute_fakes.FakeKeypair.create_keypairs(count=1) def setUp(self): super(TestKeypairList, self).setUp() - self.keypairs_mock.list.return_value = self.keypairs + self.sdk_client.keypairs.return_value = self.keypairs # Get the command object to test self.cmd = keypair.ListKeypair(self.app, None) - def test_keypair_list_no_options(self): + @mock.patch.object(sdk_utils, 'supports_microversion', return_value=False) + def test_keypair_list_no_options(self, sm_mock): arglist = [] verifylist = [] @@ -430,7 +413,7 @@ class TestKeypairList(TestKeypair): # Set expected values - self.keypairs_mock.list.assert_called_with() + self.sdk_client.keypairs.assert_called_with() self.assertEqual(('Name', 'Fingerprint'), columns) self.assertEqual( @@ -438,10 +421,8 @@ class TestKeypairList(TestKeypair): tuple(data) ) - def test_keypair_list_v22(self): - self.app.client_manager.compute.api_version = \ - api_versions.APIVersion('2.2') - + @mock.patch.object(sdk_utils, 'supports_microversion', return_value=True) + def test_keypair_list_v22(self, sm_mock): arglist = [] verifylist = [] @@ -454,7 +435,7 @@ class TestKeypairList(TestKeypair): # Set expected values - self.keypairs_mock.list.assert_called_with() + self.sdk_client.keypairs.assert_called_with() self.assertEqual(('Name', 'Fingerprint', 'Type'), columns) self.assertEqual( @@ -466,11 +447,8 @@ class TestKeypairList(TestKeypair): tuple(data) ) - def test_keypair_list_with_user(self): - - # Filtering by user is support for nova api 2.10 or above - self.app.client_manager.compute.api_version = \ - api_versions.APIVersion('2.10') + @mock.patch.object(sdk_utils, 'supports_microversion', return_value=True) + def test_keypair_list_with_user(self, sm_mock): users_mock = self.app.client_manager.identity.users users_mock.reset_mock() @@ -491,7 +469,7 @@ class TestKeypairList(TestKeypair): columns, data = self.cmd.take_action(parsed_args) users_mock.get.assert_called_with(identity_fakes.user_name) - self.keypairs_mock.list.assert_called_with( + self.sdk_client.keypairs.assert_called_with( user_id=identity_fakes.user_id, ) @@ -505,10 +483,8 @@ class TestKeypairList(TestKeypair): tuple(data) ) - def test_keypair_list_with_user_pre_v210(self): - - self.app.client_manager.compute.api_version = \ - api_versions.APIVersion('2.9') + @mock.patch.object(sdk_utils, 'supports_microversion', return_value=False) + def test_keypair_list_with_user_pre_v210(self, sm_mock): arglist = [ '--user', identity_fakes.user_name, @@ -525,11 +501,8 @@ class TestKeypairList(TestKeypair): self.assertIn( '--os-compute-api-version 2.10 or greater is required', str(ex)) - def test_keypair_list_with_project(self): - - # Filtering by user is support for nova api 2.10 or above - self.app.client_manager.compute.api_version = \ - api_versions.APIVersion('2.10') + @mock.patch.object(sdk_utils, 'supports_microversion', return_value=True) + def test_keypair_list_with_project(self, sm_mock): projects_mock = self.app.client_manager.identity.tenants projects_mock.reset_mock() @@ -557,7 +530,7 @@ class TestKeypairList(TestKeypair): projects_mock.get.assert_called_with(identity_fakes.project_name) users_mock.list.assert_called_with(tenant_id=identity_fakes.project_id) - self.keypairs_mock.list.assert_called_with( + self.sdk_client.keypairs.assert_called_with( user_id=identity_fakes.user_id, ) @@ -571,10 +544,8 @@ class TestKeypairList(TestKeypair): tuple(data) ) - def test_keypair_list_with_project_pre_v210(self): - - self.app.client_manager.compute.api_version = \ - api_versions.APIVersion('2.9') + @mock.patch.object(sdk_utils, 'supports_microversion', return_value=False) + def test_keypair_list_with_project_pre_v210(self, sm_mock): arglist = ['--project', identity_fakes.project_name] verifylist = [('project', identity_fakes.project_name)] @@ -589,10 +560,6 @@ class TestKeypairList(TestKeypair): def test_keypair_list_conflicting_user_options(self): - # Filtering by user is support for nova api 2.10 or above - self.app.client_manager.compute.api_version = \ - api_versions.APIVersion('2.10') - arglist = [ '--user', identity_fakes.user_name, '--project', identity_fakes.project_name, @@ -602,6 +569,74 @@ class TestKeypairList(TestKeypair): tests_utils.ParserException, self.check_parser, self.cmd, arglist, None) + @mock.patch.object( + sdk_utils, 'supports_microversion', new=mock.Mock(return_value=True)) + def test_keypair_list_with_limit(self): + arglist = [ + '--limit', '1', + ] + verifylist = [ + ('limit', 1), + ] + + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + self.cmd.take_action(parsed_args) + + self.sdk_client.keypairs.assert_called_with(limit=1) + + @mock.patch.object( + sdk_utils, 'supports_microversion', new=mock.Mock(return_value=False)) + def test_keypair_list_with_limit_pre_v235(self): + arglist = [ + '--limit', '1', + ] + verifylist = [ + ('limit', 1), + ] + + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + ex = self.assertRaises( + exceptions.CommandError, + self.cmd.take_action, + parsed_args) + + self.assertIn( + '--os-compute-api-version 2.35 or greater is required', str(ex)) + + @mock.patch.object( + sdk_utils, 'supports_microversion', new=mock.Mock(return_value=True)) + def test_keypair_list_with_marker(self): + arglist = [ + '--marker', 'test_kp', + ] + verifylist = [ + ('marker', 'test_kp'), + ] + + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + self.cmd.take_action(parsed_args) + + self.sdk_client.keypairs.assert_called_with(marker='test_kp') + + @mock.patch.object( + sdk_utils, 'supports_microversion', new=mock.Mock(return_value=False)) + def test_keypair_list_with_marker_pre_v235(self): + arglist = [ + '--marker', 'test_kp', + ] + verifylist = [ + ('marker', 'test_kp'), + ] + + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + ex = self.assertRaises( + exceptions.CommandError, + self.cmd.take_action, + parsed_args) + + self.assertIn( + '--os-compute-api-version 2.35 or greater is required', str(ex)) + class TestKeypairShow(TestKeypair): @@ -610,7 +645,7 @@ class TestKeypairShow(TestKeypair): def setUp(self): super(TestKeypairShow, self).setUp() - self.keypairs_mock.get.return_value = self.keypair + self.sdk_client.find_keypair.return_value = self.keypair self.cmd = keypair.ShowKeypair(self.app, None) @@ -641,7 +676,7 @@ class TestKeypairShow(TestKeypair): # overwrite the setup one because we want to omit private_key self.keypair = compute_fakes.FakeKeypair.create_one_keypair( no_pri=True) - self.keypairs_mock.get.return_value = self.keypair + self.sdk_client.find_keypair.return_value = self.keypair self.data = ( self.keypair.fingerprint, @@ -660,8 +695,9 @@ class TestKeypairShow(TestKeypair): columns, data = self.cmd.take_action(parsed_args) - self.keypairs_mock.get.assert_called_with( + self.sdk_client.find_keypair.assert_called_with( self.keypair.name, + ignore_missing=False ) self.assertEqual(self.columns, columns) @@ -685,12 +721,13 @@ class TestKeypairShow(TestKeypair): self.assertEqual({}, columns) self.assertEqual({}, data) - def test_keypair_show_with_user(self): + @mock.patch.object(sdk_utils, 'supports_microversion', return_value=True) + def test_keypair_show_with_user(self, sm_mock): # overwrite the setup one because we want to omit private_key self.keypair = compute_fakes.FakeKeypair.create_one_keypair( no_pri=True) - self.keypairs_mock.get.return_value = self.keypair + self.sdk_client.find_keypair.return_value = self.keypair self.data = ( self.keypair.fingerprint, @@ -699,9 +736,6 @@ class TestKeypairShow(TestKeypair): self.keypair.user_id ) - self.app.client_manager.compute.api_version = \ - api_versions.APIVersion('2.10') - arglist = [ '--user', identity_fakes.user_name, self.keypair.name, @@ -715,14 +749,17 @@ class TestKeypairShow(TestKeypair): columns, data = self.cmd.take_action(parsed_args) self.users_mock.get.assert_called_with(identity_fakes.user_name) - self.keypairs_mock.get.assert_called_with( + self.sdk_client.find_keypair.assert_called_with( self.keypair.name, + ignore_missing=False, + user_id=identity_fakes.user_id ) self.assertEqual(self.columns, columns) self.assertEqual(self.data, data) - def test_keypair_show_with_user_pre_v210(self): + @mock.patch.object(sdk_utils, 'supports_microversion', return_value=False) + def test_keypair_show_with_user_pre_v210(self, sm_mock): arglist = [ '--user', identity_fakes.user_name, diff --git a/openstackclient/tests/unit/compute/v2/test_server.py b/openstackclient/tests/unit/compute/v2/test_server.py index 15cdbf16..c6dff5a8 100644 --- a/openstackclient/tests/unit/compute/v2/test_server.py +++ b/openstackclient/tests/unit/compute/v2/test_server.py @@ -16,23 +16,50 @@ import argparse import collections import copy import getpass +import json +import tempfile from unittest import mock from unittest.mock import call import iso8601 from novaclient import api_versions from openstack import exceptions as sdk_exceptions +from osc_lib.cli import format_columns from osc_lib import exceptions from osc_lib import utils as common_utils from openstackclient.compute.v2 import server from openstackclient.tests.unit.compute.v2 import fakes as compute_fakes +from openstackclient.tests.unit.identity.v3 import fakes as identity_fakes from openstackclient.tests.unit.image.v2 import fakes as image_fakes from openstackclient.tests.unit.network.v2 import fakes as network_fakes from openstackclient.tests.unit import utils from openstackclient.tests.unit.volume.v2 import fakes as volume_fakes +class TestPowerStateColumn(utils.TestCase): + + def test_human_readable(self): + self.assertEqual( + 'NOSTATE', server.PowerStateColumn(0x00).human_readable()) + self.assertEqual( + 'Running', server.PowerStateColumn(0x01).human_readable()) + self.assertEqual( + '', server.PowerStateColumn(0x02).human_readable()) + self.assertEqual( + 'Paused', server.PowerStateColumn(0x03).human_readable()) + self.assertEqual( + 'Shutdown', server.PowerStateColumn(0x04).human_readable()) + self.assertEqual( + '', server.PowerStateColumn(0x05).human_readable()) + self.assertEqual( + 'Crashed', server.PowerStateColumn(0x06).human_readable()) + self.assertEqual( + 'Suspended', server.PowerStateColumn(0x07).human_readable()) + self.assertEqual( + 'N/A', server.PowerStateColumn(0x08).human_readable()) + + class TestServer(compute_fakes.TestComputev2): def setUp(self): @@ -1015,15 +1042,15 @@ class TestServerCreate(TestServer): def datalist(self): datalist = ( - server._format_servers_list_power_state( + server.PowerStateColumn( getattr(self.new_server, 'OS-EXT-STS:power_state')), - '', + format_columns.DictListColumn({}), self.flavor.name + ' (' + self.new_server.flavor.get('id') + ')', self.new_server.id, self.image.name + ' (' + self.new_server.image.get('id') + ')', self.new_server.name, self.new_server.networks, - '', + format_columns.DictColumn(self.new_server.metadata), ) return datalist @@ -1135,7 +1162,7 @@ class TestServerCreate(TestServer): ('image', 'image1'), ('flavor', 'flavor1'), ('key_name', 'keyname'), - ('property', {'Beta': 'b'}), + ('properties', {'Beta': 'b'}), ('security_group', ['securitygroup']), ('hint', {'a': ['b', 'c']}), ('config_drive', True), @@ -1286,8 +1313,28 @@ class TestServerCreate(TestServer): verifylist = [ ('image', 'image1'), ('flavor', 'flavor1'), - ('nic', ['net-id=net1', 'net-id=net1,v4-fixed-ip=10.0.0.2', - 'port-id=port1', 'net-id=net1', 'port-id=port2']), + ('nics', [ + { + 'net-id': 'net1', 'port-id': '', + 'v4-fixed-ip': '', 'v6-fixed-ip': '', + }, + { + 'net-id': 'net1', 'port-id': '', + 'v4-fixed-ip': '10.0.0.2', 'v6-fixed-ip': '', + }, + { + 'net-id': '', 'port-id': 'port1', + 'v4-fixed-ip': '', 'v6-fixed-ip': '', + }, + { + 'net-id': 'net1', 'port-id': '', + 'v4-fixed-ip': '', 'v6-fixed-ip': '', + }, + { + 'net-id': '', 'port-id': 'port2', + 'v4-fixed-ip': '', 'v6-fixed-ip': '', + }, + ]), ('config_drive', False), ('server_name', self.new_server.name), ] @@ -1378,6 +1425,113 @@ class TestServerCreate(TestServer): self.assertEqual(self.columns, columns) self.assertEqual(self.datalist(), data) + def test_server_create_with_network_tag(self): + self.app.client_manager.compute.api_version = api_versions.APIVersion( + '2.43') + + arglist = [ + '--image', 'image1', + '--flavor', 'flavor1', + '--nic', 'net-id=net1,tag=foo', + self.new_server.name, + ] + verifylist = [ + ('image', 'image1'), + ('flavor', 'flavor1'), + ('nics', [ + { + 'net-id': 'net1', 'port-id': '', + 'v4-fixed-ip': '', 'v6-fixed-ip': '', + 'tag': 'foo', + }, + ]), + ('server_name', self.new_server.name), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + find_network = mock.Mock() + network_client = self.app.client_manager.network + network_client.find_network = find_network + network_resource = mock.Mock(id='net1_uuid') + find_network.return_value = network_resource + + # Mock sdk APIs. + _network = mock.Mock(id='net1_uuid') + find_network = mock.Mock() + find_network.return_value = _network + self.app.client_manager.network.find_network = find_network + + # In base command class ShowOne in cliff, abstract method take_action() + # returns a two-part tuple with a tuple of column names and a tuple of + # data to be shown. + columns, data = self.cmd.take_action(parsed_args) + + # Set expected values + kwargs = dict( + meta=None, + files={}, + reservation_id=None, + min_count=1, + max_count=1, + security_groups=[], + userdata=None, + key_name=None, + availability_zone=None, + admin_pass=None, + block_device_mapping_v2=[], + nics=[ + { + 'net-id': 'net1_uuid', + 'v4-fixed-ip': '', + 'v6-fixed-ip': '', + 'port-id': '', + 'tag': 'foo', + }, + ], + scheduler_hints={}, + config_drive=None, + ) + # ServerManager.create(name, image, flavor, **kwargs) + self.servers_mock.create.assert_called_with( + self.new_server.name, + self.image, + self.flavor, + **kwargs + ) + + self.assertEqual(self.columns, columns) + self.assertEqual(self.datalist(), data) + + network_client.find_network.assert_called_once() + self.app.client_manager.network.find_network.assert_called_once() + + def test_server_create_with_network_tag_pre_v243(self): + self.app.client_manager.compute.api_version = api_versions.APIVersion( + '2.42') + + arglist = [ + '--image', 'image1', + '--flavor', 'flavor1', + '--nic', 'net-id=net1,tag=foo', + self.new_server.name, + ] + verifylist = [ + ('image', 'image1'), + ('flavor', 'flavor1'), + ('nics', [ + { + 'net-id': 'net1', 'port-id': '', + 'v4-fixed-ip': '', 'v6-fixed-ip': '', + 'tag': 'foo', + }, + ]), + ('server_name', self.new_server.name), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + self.assertRaises( + exceptions.CommandError, self.cmd.take_action, parsed_args) + def test_server_create_with_auto_network(self): arglist = [ '--image', 'image1', @@ -1388,7 +1542,7 @@ class TestServerCreate(TestServer): verifylist = [ ('image', 'image1'), ('flavor', 'flavor1'), - ('nic', ['auto']), + ('nics', ['auto']), ('config_drive', False), ('server_name', self.new_server.name), ] @@ -1484,7 +1638,7 @@ class TestServerCreate(TestServer): verifylist = [ ('image', 'image1'), ('flavor', 'flavor1'), - ('nic', ['none']), + ('nics', ['none']), ('config_drive', False), ('server_name', self.new_server.name), ] @@ -1532,7 +1686,14 @@ class TestServerCreate(TestServer): verifylist = [ ('image', 'image1'), ('flavor', 'flavor1'), - ('nic', ['none', 'auto', 'port-id=port1']), + ('nics', [ + 'none', + 'auto', + { + 'net-id': '', 'port-id': 'port1', + 'v4-fixed-ip': '', 'v6-fixed-ip': '', + }, + ]), ('config_drive', False), ('server_name', self.new_server.name), ] @@ -1562,17 +1723,10 @@ class TestServerCreate(TestServer): '--nic', 'abcdefgh', self.new_server.name, ] - verifylist = [ - ('image', 'image1'), - ('flavor', 'flavor1'), - ('nic', ['abcdefgh']), - ('config_drive', False), - ('server_name', self.new_server.name), - ] - parsed_args = self.check_parser(self.cmd, arglist, verifylist) - - self.assertRaises(exceptions.CommandError, - self.cmd.take_action, parsed_args) + self.assertRaises( + argparse.ArgumentTypeError, + self.check_parser, + self.cmd, arglist, []) self.assertNotCalled(self.servers_mock.create) def test_server_create_with_invalid_network_key(self): @@ -1582,17 +1736,10 @@ class TestServerCreate(TestServer): '--nic', 'abcdefgh=12324', self.new_server.name, ] - verifylist = [ - ('image', 'image1'), - ('flavor', 'flavor1'), - ('nic', ['abcdefgh=12324']), - ('config_drive', False), - ('server_name', self.new_server.name), - ] - parsed_args = self.check_parser(self.cmd, arglist, verifylist) - - self.assertRaises(exceptions.CommandError, - self.cmd.take_action, parsed_args) + self.assertRaises( + argparse.ArgumentTypeError, + self.check_parser, + self.cmd, arglist, []) self.assertNotCalled(self.servers_mock.create) def test_server_create_with_empty_network_key_value(self): @@ -1602,17 +1749,10 @@ class TestServerCreate(TestServer): '--nic', 'net-id=', self.new_server.name, ] - verifylist = [ - ('image', 'image1'), - ('flavor', 'flavor1'), - ('nic', ['net-id=']), - ('config_drive', False), - ('server_name', self.new_server.name), - ] - parsed_args = self.check_parser(self.cmd, arglist, verifylist) - - self.assertRaises(exceptions.CommandError, - self.cmd.take_action, parsed_args) + self.assertRaises( + argparse.ArgumentTypeError, + self.check_parser, + self.cmd, arglist, []) self.assertNotCalled(self.servers_mock.create) def test_server_create_with_only_network_key(self): @@ -1622,17 +1762,11 @@ class TestServerCreate(TestServer): '--nic', 'net-id', self.new_server.name, ] - verifylist = [ - ('image', 'image1'), - ('flavor', 'flavor1'), - ('nic', ['net-id']), - ('config_drive', False), - ('server_name', self.new_server.name), - ] - parsed_args = self.check_parser(self.cmd, arglist, verifylist) + self.assertRaises( + argparse.ArgumentTypeError, + self.check_parser, + self.cmd, arglist, []) - self.assertRaises(exceptions.CommandError, - self.cmd.take_action, parsed_args) self.assertNotCalled(self.servers_mock.create) @mock.patch.object(common_utils, 'wait_for_status', return_value=True) @@ -1793,6 +1927,430 @@ class TestServerCreate(TestServer): self.assertEqual(self.columns, columns) self.assertEqual(self.datalist(), data) + def test_server_create_with_volume(self): + arglist = [ + '--flavor', self.flavor.id, + '--volume', self.volume.name, + self.new_server.name, + ] + verifylist = [ + ('flavor', self.flavor.id), + ('volume', self.volume.name), + ('server_name', self.new_server.name), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + # CreateServer.take_action() returns two tuples + columns, data = self.cmd.take_action(parsed_args) + + # Set expected values + kwargs = { + 'meta': None, + 'files': {}, + 'reservation_id': None, + 'min_count': 1, + 'max_count': 1, + 'security_groups': [], + 'userdata': None, + 'key_name': None, + 'availability_zone': None, + 'admin_pass': None, + 'block_device_mapping_v2': [{ + 'uuid': self.volume.id, + 'boot_index': '0', + 'source_type': 'volume', + 'destination_type': 'volume', + }], + 'nics': [], + 'scheduler_hints': {}, + 'config_drive': None, + } + # ServerManager.create(name, image, flavor, **kwargs) + self.servers_mock.create.assert_called_with( + self.new_server.name, + None, + self.flavor, + **kwargs + ) + self.volumes_mock.get.assert_called_once_with( + self.volume.name) + + self.assertEqual(self.columns, columns) + self.assertEqual(self.datalist(), data) + + def test_server_create_with_snapshot(self): + arglist = [ + '--flavor', self.flavor.id, + '--snapshot', self.snapshot.name, + self.new_server.name, + ] + verifylist = [ + ('flavor', self.flavor.id), + ('snapshot', self.snapshot.name), + ('server_name', self.new_server.name), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + # CreateServer.take_action() returns two tuples + columns, data = self.cmd.take_action(parsed_args) + + # Set expected values + kwargs = { + 'meta': None, + 'files': {}, + 'reservation_id': None, + 'min_count': 1, + 'max_count': 1, + 'security_groups': [], + 'userdata': None, + 'key_name': None, + 'availability_zone': None, + 'admin_pass': None, + 'block_device_mapping_v2': [{ + 'uuid': self.snapshot.id, + 'boot_index': '0', + 'source_type': 'snapshot', + 'destination_type': 'volume', + 'delete_on_termination': False, + }], + 'nics': [], + 'scheduler_hints': {}, + 'config_drive': None, + } + # ServerManager.create(name, image, flavor, **kwargs) + self.servers_mock.create.assert_called_with( + self.new_server.name, + None, + self.flavor, + **kwargs + ) + self.snapshots_mock.get.assert_called_once_with( + self.snapshot.name) + + self.assertEqual(self.columns, columns) + self.assertEqual(self.datalist(), data) + + def test_server_create_with_block_device(self): + block_device = f'uuid={self.volume.id},source_type=volume' + arglist = [ + '--image', 'image1', + '--flavor', self.flavor.id, + '--block-device', block_device, + self.new_server.name, + ] + verifylist = [ + ('image', 'image1'), + ('flavor', self.flavor.id), + ('block_devices', [ + { + 'uuid': self.volume.id, + 'source_type': 'volume', + }, + ]), + ('server_name', self.new_server.name), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + # CreateServer.take_action() returns two tuples + columns, data = self.cmd.take_action(parsed_args) + + # Set expected values + kwargs = { + 'meta': None, + 'files': {}, + 'reservation_id': None, + 'min_count': 1, + 'max_count': 1, + 'security_groups': [], + 'userdata': None, + 'key_name': None, + 'availability_zone': None, + 'admin_pass': None, + 'block_device_mapping_v2': [{ + 'uuid': self.volume.id, + 'source_type': 'volume', + 'destination_type': 'volume', + }], + 'nics': [], + 'scheduler_hints': {}, + 'config_drive': None, + } + # ServerManager.create(name, image, flavor, **kwargs) + self.servers_mock.create.assert_called_with( + self.new_server.name, + self.image, + self.flavor, + **kwargs + ) + + self.assertEqual(self.columns, columns) + self.assertEqual(self.datalist(), data) + + def test_server_create_with_block_device_full(self): + self.app.client_manager.compute.api_version = api_versions.APIVersion( + '2.67') + + block_device = ( + f'uuid={self.volume.id},source_type=volume,' + f'destination_type=volume,disk_bus=ide,device_type=disk,' + f'device_name=sdb,guest_format=ext4,volume_size=64,' + f'volume_type=foo,boot_index=1,delete_on_termination=true,' + f'tag=foo' + ) + + arglist = [ + '--image', 'image1', + '--flavor', self.flavor.id, + '--block-device', block_device, + self.new_server.name, + ] + verifylist = [ + ('image', 'image1'), + ('flavor', self.flavor.id), + ('block_devices', [ + { + 'uuid': self.volume.id, + 'source_type': 'volume', + 'destination_type': 'volume', + 'disk_bus': 'ide', + 'device_type': 'disk', + 'device_name': 'sdb', + 'guest_format': 'ext4', + 'volume_size': '64', + 'volume_type': 'foo', + 'boot_index': '1', + 'delete_on_termination': 'true', + 'tag': 'foo', + }, + ]), + ('server_name', self.new_server.name), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + # CreateServer.take_action() returns two tuples + columns, data = self.cmd.take_action(parsed_args) + + # Set expected values + kwargs = { + 'meta': None, + 'files': {}, + 'reservation_id': None, + 'min_count': 1, + 'max_count': 1, + 'security_groups': [], + 'userdata': None, + 'key_name': None, + 'availability_zone': None, + 'admin_pass': None, + 'block_device_mapping_v2': [{ + 'uuid': self.volume.id, + 'source_type': 'volume', + 'destination_type': 'volume', + 'disk_bus': 'ide', + 'device_name': 'sdb', + 'volume_size': '64', + 'guest_format': 'ext4', + 'boot_index': 1, + 'device_type': 'disk', + 'delete_on_termination': True, + 'tag': 'foo', + 'volume_type': 'foo', + }], + 'nics': 'auto', + 'scheduler_hints': {}, + 'config_drive': None, + } + # ServerManager.create(name, image, flavor, **kwargs) + self.servers_mock.create.assert_called_with( + self.new_server.name, + self.image, + self.flavor, + **kwargs + ) + + self.assertEqual(self.columns, columns) + self.assertEqual(self.datalist(), data) + + def test_server_create_with_block_device_from_file(self): + self.app.client_manager.compute.api_version = api_versions.APIVersion( + '2.67') + + block_device = { + 'uuid': self.volume.id, + 'source_type': 'volume', + 'destination_type': 'volume', + 'disk_bus': 'ide', + 'device_type': 'disk', + 'device_name': 'sdb', + 'guest_format': 'ext4', + 'volume_size': 64, + 'volume_type': 'foo', + 'boot_index': 1, + 'delete_on_termination': True, + 'tag': 'foo', + } + + with tempfile.NamedTemporaryFile(mode='w+') as fp: + json.dump(block_device, fp=fp) + fp.flush() + + arglist = [ + '--image', 'image1', + '--flavor', self.flavor.id, + '--block-device', fp.name, + self.new_server.name, + ] + verifylist = [ + ('image', 'image1'), + ('flavor', self.flavor.id), + ('block_devices', [block_device]), + ('server_name', self.new_server.name), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + # CreateServer.take_action() returns two tuples + columns, data = self.cmd.take_action(parsed_args) + + # Set expected values + kwargs = { + 'meta': None, + 'files': {}, + 'reservation_id': None, + 'min_count': 1, + 'max_count': 1, + 'security_groups': [], + 'userdata': None, + 'key_name': None, + 'availability_zone': None, + 'admin_pass': None, + 'block_device_mapping_v2': [{ + 'uuid': self.volume.id, + 'source_type': 'volume', + 'destination_type': 'volume', + 'disk_bus': 'ide', + 'device_name': 'sdb', + 'volume_size': 64, + 'guest_format': 'ext4', + 'boot_index': 1, + 'device_type': 'disk', + 'delete_on_termination': True, + 'tag': 'foo', + 'volume_type': 'foo', + }], + 'nics': 'auto', + 'scheduler_hints': {}, + 'config_drive': None, + } + # ServerManager.create(name, image, flavor, **kwargs) + self.servers_mock.create.assert_called_with( + self.new_server.name, + self.image, + self.flavor, + **kwargs + ) + + self.assertEqual(self.columns, columns) + self.assertEqual(self.datalist(), data) + + def test_server_create_with_block_device_invalid_boot_index(self): + block_device = \ + f'uuid={self.volume.name},source_type=volume,boot_index=foo' + arglist = [ + '--image', 'image1', + '--flavor', self.flavor.id, + '--block-device', block_device, + self.new_server.name, + ] + parsed_args = self.check_parser(self.cmd, arglist, []) + ex = self.assertRaises( + exceptions.CommandError, + self.cmd.take_action, parsed_args) + self.assertIn('The boot_index key of --block-device ', str(ex)) + + def test_server_create_with_block_device_invalid_source_type(self): + block_device = f'uuid={self.volume.name},source_type=foo' + arglist = [ + '--image', 'image1', + '--flavor', self.flavor.id, + '--block-device', block_device, + self.new_server.name, + ] + parsed_args = self.check_parser(self.cmd, arglist, []) + ex = self.assertRaises( + exceptions.CommandError, + self.cmd.take_action, parsed_args) + self.assertIn('The source_type key of --block-device ', str(ex)) + + def test_server_create_with_block_device_invalid_destination_type(self): + block_device = \ + f'uuid={self.volume.name},destination_type=foo' + arglist = [ + '--image', 'image1', + '--flavor', self.flavor.id, + '--block-device', block_device, + self.new_server.name, + ] + parsed_args = self.check_parser(self.cmd, arglist, []) + ex = self.assertRaises( + exceptions.CommandError, + self.cmd.take_action, parsed_args) + self.assertIn('The destination_type key of --block-device ', str(ex)) + + def test_server_create_with_block_device_invalid_shutdown(self): + block_device = \ + f'uuid={self.volume.name},delete_on_termination=foo' + arglist = [ + '--image', 'image1', + '--flavor', self.flavor.id, + '--block-device', block_device, + self.new_server.name, + ] + parsed_args = self.check_parser(self.cmd, arglist, []) + ex = self.assertRaises( + exceptions.CommandError, + self.cmd.take_action, parsed_args) + self.assertIn( + 'The delete_on_termination key of --block-device ', str(ex)) + + def test_server_create_with_block_device_tag_pre_v242(self): + self.app.client_manager.compute.api_version = api_versions.APIVersion( + '2.41') + + block_device = \ + f'uuid={self.volume.name},tag=foo' + arglist = [ + '--image', 'image1', + '--flavor', self.flavor.id, + '--block-device', block_device, + self.new_server.name, + ] + parsed_args = self.check_parser(self.cmd, arglist, []) + ex = self.assertRaises( + exceptions.CommandError, + self.cmd.take_action, parsed_args) + self.assertIn( + '--os-compute-api-version 2.42 or greater is required', + str(ex)) + + def test_server_create_with_block_device_volume_type_pre_v267(self): + self.app.client_manager.compute.api_version = api_versions.APIVersion( + '2.66') + + block_device = f'uuid={self.volume.name},volume_type=foo' + arglist = [ + '--image', 'image1', + '--flavor', self.flavor.id, + '--block-device', block_device, + self.new_server.name, + ] + parsed_args = self.check_parser(self.cmd, arglist, []) + ex = self.assertRaises( + exceptions.CommandError, + self.cmd.take_action, parsed_args) + self.assertIn( + '--os-compute-api-version 2.67 or greater is required', + str(ex)) + def test_server_create_with_block_device_mapping(self): arglist = [ '--image', 'image1', @@ -1803,7 +2361,15 @@ class TestServerCreate(TestServer): verifylist = [ ('image', 'image1'), ('flavor', self.flavor.id), - ('block_device_mapping', {'vda': self.volume.name + ':::false'}), + ('block_device_mapping', [ + { + 'device_name': 'vda', + 'uuid': self.volume.name, + 'source_type': 'volume', + 'destination_type': 'volume', + 'delete_on_termination': 'false', + } + ]), ('config_drive', False), ('server_name', self.new_server.name), ] @@ -1856,7 +2422,14 @@ class TestServerCreate(TestServer): verifylist = [ ('image', 'image1'), ('flavor', self.flavor.id), - ('block_device_mapping', {'vdf': self.volume.name}), + ('block_device_mapping', [ + { + 'device_name': 'vdf', + 'uuid': self.volume.name, + 'source_type': 'volume', + 'destination_type': 'volume', + } + ]), ('config_drive', False), ('server_name', self.new_server.name), ] @@ -1908,7 +2481,14 @@ class TestServerCreate(TestServer): verifylist = [ ('image', 'image1'), ('flavor', self.flavor.id), - ('block_device_mapping', {'vdf': self.volume.name + ':::'}), + ('block_device_mapping', [ + { + 'device_name': 'vdf', + 'uuid': self.volume.name, + 'source_type': 'volume', + 'destination_type': 'volume', + } + ]), ('config_drive', False), ('server_name', self.new_server.name), ] @@ -1961,8 +2541,16 @@ class TestServerCreate(TestServer): verifylist = [ ('image', 'image1'), ('flavor', self.flavor.id), - ('block_device_mapping', - {'vde': self.volume.name + ':volume:3:true'}), + ('block_device_mapping', [ + { + 'device_name': 'vde', + 'uuid': self.volume.name, + 'source_type': 'volume', + 'destination_type': 'volume', + 'volume_size': '3', + 'delete_on_termination': 'true', + } + ]), ('config_drive', False), ('server_name', self.new_server.name), ] @@ -2017,8 +2605,16 @@ class TestServerCreate(TestServer): verifylist = [ ('image', 'image1'), ('flavor', self.flavor.id), - ('block_device_mapping', - {'vds': self.volume.name + ':snapshot:5:true'}), + ('block_device_mapping', [ + { + 'device_name': 'vds', + 'uuid': self.volume.name, + 'source_type': 'snapshot', + 'volume_size': '5', + 'destination_type': 'volume', + 'delete_on_termination': 'true', + } + ]), ('config_drive', False), ('server_name', self.new_server.name), ] @@ -2073,8 +2669,22 @@ class TestServerCreate(TestServer): verifylist = [ ('image', 'image1'), ('flavor', self.flavor.id), - ('block_device_mapping', {'vdb': self.volume.name + ':::false', - 'vdc': self.volume.name + ':::true'}), + ('block_device_mapping', [ + { + 'device_name': 'vdb', + 'uuid': self.volume.name, + 'source_type': 'volume', + 'destination_type': 'volume', + 'delete_on_termination': 'false', + }, + { + 'device_name': 'vdc', + 'uuid': self.volume.name, + 'source_type': 'volume', + 'destination_type': 'volume', + 'delete_on_termination': 'true', + }, + ]), ('config_drive', False), ('server_name', self.new_server.name), ] @@ -2127,26 +2737,29 @@ class TestServerCreate(TestServer): self.assertEqual(self.datalist(), data) def test_server_create_with_block_device_mapping_invalid_format(self): - # 1. block device mapping don't contain equal sign "=" + # block device mapping don't contain equal sign "=" arglist = [ '--image', 'image1', '--flavor', self.flavor.id, '--block-device-mapping', 'not_contain_equal_sign', self.new_server.name, ] - self.assertRaises(argparse.ArgumentTypeError, - self.check_parser, - self.cmd, arglist, []) - # 2. block device mapping don't contain device name "=uuid:::true" + self.assertRaises( + argparse.ArgumentTypeError, + self.check_parser, + self.cmd, arglist, []) + + # block device mapping don't contain device name "=uuid:::true" arglist = [ '--image', 'image1', '--flavor', self.flavor.id, '--block-device-mapping', '=uuid:::true', self.new_server.name, ] - self.assertRaises(argparse.ArgumentTypeError, - self.check_parser, - self.cmd, arglist, []) + self.assertRaises( + argparse.ArgumentTypeError, + self.check_parser, + self.cmd, arglist, []) def test_server_create_with_block_device_mapping_no_uuid(self): arglist = [ @@ -2155,18 +2768,10 @@ class TestServerCreate(TestServer): '--block-device-mapping', 'vdb=', self.new_server.name, ] - verifylist = [ - ('image', 'image1'), - ('flavor', self.flavor.id), - ('block_device_mapping', {'vdb': ''}), - ('config_drive', False), - ('server_name', self.new_server.name), - ] - parsed_args = self.check_parser(self.cmd, arglist, verifylist) - - self.assertRaises(exceptions.CommandError, - self.cmd.take_action, - parsed_args) + self.assertRaises( + argparse.ArgumentTypeError, + self.check_parser, + self.cmd, arglist, []) def test_server_create_volume_boot_from_volume_conflict(self): # Tests that specifying --volume and --boot-from-volume results in @@ -2203,9 +2808,9 @@ class TestServerCreate(TestServer): self.new_server.name, ] verifylist = [ - ('image_property', {'hypervisor_type': 'qemu'}), + ('image_properties', {'hypervisor_type': 'qemu'}), ('flavor', 'flavor1'), - ('nic', ['none']), + ('nics', ['none']), ('config_drive', False), ('server_name', self.new_server.name), ] @@ -2258,10 +2863,10 @@ class TestServerCreate(TestServer): self.new_server.name, ] verifylist = [ - ('image_property', {'hypervisor_type': 'qemu', + ('image_properties', {'hypervisor_type': 'qemu', 'hw_disk_bus': 'ide'}), ('flavor', 'flavor1'), - ('nic', ['none']), + ('nics', ['none']), ('config_drive', False), ('server_name', self.new_server.name), ] @@ -2314,10 +2919,10 @@ class TestServerCreate(TestServer): self.new_server.name, ] verifylist = [ - ('image_property', {'hypervisor_type': 'qemu', + ('image_properties', {'hypervisor_type': 'qemu', 'hw_disk_bus': 'virtio'}), ('flavor', 'flavor1'), - ('nic', ['none']), + ('nics', ['none']), ('config_drive', False), ('server_name', self.new_server.name), ] @@ -2346,10 +2951,10 @@ class TestServerCreate(TestServer): ] verifylist = [ - ('image_property', + ('image_properties', {'owner_specified.openstack.object': 'image/cirros'}), ('flavor', 'flavor1'), - ('nic', ['none']), + ('nics', ['none']), ('server_name', self.new_server.name), ] # create a image_info as the side_effect of the fake image_list() @@ -2396,6 +3001,136 @@ class TestServerCreate(TestServer): self.assertEqual(self.columns, columns) self.assertEqual(self.datalist(), data) + def test_server_create_with_swap(self): + arglist = [ + '--image', 'image1', + '--flavor', self.flavor.id, + '--swap', '1024', + self.new_server.name, + ] + verifylist = [ + ('image', 'image1'), + ('flavor', self.flavor.id), + ('swap', 1024), + ('server_name', self.new_server.name), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + # CreateServer.take_action() returns two tuples + columns, data = self.cmd.take_action(parsed_args) + + # Set expected values + kwargs = { + 'meta': None, + 'files': {}, + 'reservation_id': None, + 'min_count': 1, + 'max_count': 1, + 'security_groups': [], + 'userdata': None, + 'key_name': None, + 'availability_zone': None, + 'admin_pass': None, + 'block_device_mapping_v2': [{ + 'boot_index': -1, + 'source_type': 'blank', + 'destination_type': 'local', + 'guest_format': 'swap', + 'volume_size': 1024, + 'delete_on_termination': True, + }], + 'nics': [], + 'scheduler_hints': {}, + 'config_drive': None, + } + # ServerManager.create(name, image, flavor, **kwargs) + self.servers_mock.create.assert_called_with( + self.new_server.name, + self.image, + self.flavor, + **kwargs + ) + + self.assertEqual(self.columns, columns) + self.assertEqual(self.datalist(), data) + + def test_server_create_with_ephemeral(self): + arglist = [ + '--image', 'image1', + '--flavor', self.flavor.id, + '--ephemeral', 'size=1024,format=ext4', + self.new_server.name, + ] + verifylist = [ + ('image', 'image1'), + ('flavor', self.flavor.id), + ('ephemerals', [{'size': '1024', 'format': 'ext4'}]), + ('server_name', self.new_server.name), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + # CreateServer.take_action() returns two tuples + columns, data = self.cmd.take_action(parsed_args) + + # Set expected values + kwargs = { + 'meta': None, + 'files': {}, + 'reservation_id': None, + 'min_count': 1, + 'max_count': 1, + 'security_groups': [], + 'userdata': None, + 'key_name': None, + 'availability_zone': None, + 'admin_pass': None, + 'block_device_mapping_v2': [{ + 'boot_index': -1, + 'source_type': 'blank', + 'destination_type': 'local', + 'guest_format': 'ext4', + 'volume_size': '1024', + 'delete_on_termination': True, + }], + 'nics': [], + 'scheduler_hints': {}, + 'config_drive': None, + } + # ServerManager.create(name, image, flavor, **kwargs) + self.servers_mock.create.assert_called_with( + self.new_server.name, + self.image, + self.flavor, + **kwargs + ) + + self.assertEqual(self.columns, columns) + self.assertEqual(self.datalist(), data) + + def test_server_create_with_ephemeral_missing_key(self): + arglist = [ + '--image', 'image1', + '--flavor', self.flavor.id, + '--ephemeral', 'format=ext3', + self.new_server.name, + ] + self.assertRaises( + argparse.ArgumentTypeError, + self.check_parser, + self.cmd, arglist, []) + + def test_server_create_with_ephemeral_invalid_key(self): + arglist = [ + '--image', 'image1', + '--flavor', self.flavor.id, + '--ephemeral', 'size=1024,foo=bar', + self.new_server.name, + ] + self.assertRaises( + argparse.ArgumentTypeError, + self.check_parser, + self.cmd, arglist, []) + def test_server_create_invalid_hint(self): # Not a key-value pair arglist = [ @@ -2826,6 +3561,7 @@ class TestServerDelete(TestServer): super(TestServerDelete, self).setUp() self.servers_mock.delete.return_value = None + self.servers_mock.force_delete.return_value = None # Get the command object to test self.cmd = server.DeleteServer(self.app, None) @@ -2844,6 +3580,26 @@ class TestServerDelete(TestServer): result = self.cmd.take_action(parsed_args) self.servers_mock.delete.assert_called_with(servers[0].id) + self.servers_mock.force_delete.assert_not_called() + self.assertIsNone(result) + + def test_server_delete_with_force(self): + servers = self.setup_servers_mock(count=1) + + arglist = [ + servers[0].id, + '--force', + ] + verifylist = [ + ('server', [servers[0].id]), + ('force', True), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + result = self.cmd.take_action(parsed_args) + + self.servers_mock.force_delete.assert_called_with(servers[0].id) + self.servers_mock.delete.assert_not_called() self.assertIsNone(result) def test_server_delete_multi_servers(self): @@ -2867,6 +3623,28 @@ class TestServerDelete(TestServer): self.servers_mock.delete.assert_has_calls(calls) self.assertIsNone(result) + @mock.patch.object(common_utils, 'find_resource') + def test_server_delete_with_all_projects(self, mock_find_resource): + servers = self.setup_servers_mock(count=1) + mock_find_resource.side_effect = compute_fakes.FakeServer.get_servers( + servers, 0, + ) + + arglist = [ + servers[0].id, + '--all-projects', + ] + verifylist = [ + ('server', [servers[0].id]), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + self.cmd.take_action(parsed_args) + + mock_find_resource.assert_called_once_with( + mock.ANY, servers[0].id, all_tenants=True, + ) + @mock.patch.object(common_utils, 'wait_for_delete', return_value=True) def test_server_delete_wait_ok(self, mock_wait_for_delete): servers = self.setup_servers_mock(count=1) @@ -3040,7 +3818,7 @@ class TestServerList(TestServer): s.id, s.name, s.status, - server._format_servers_list_networks(s.networks), + format_columns.DictListColumn(s.networks), # Image will be an empty string if boot-from-volume self.image.name if s.image else server.IMAGE_STRING_FOR_BFV, self.flavor.name, @@ -3050,10 +3828,10 @@ class TestServerList(TestServer): s.name, s.status, getattr(s, 'OS-EXT-STS:task_state'), - server._format_servers_list_power_state( + server.PowerStateColumn( getattr(s, 'OS-EXT-STS:power_state') ), - server._format_servers_list_networks(s.networks), + format_columns.DictListColumn(s.networks), # Image will be an empty string if boot-from-volume self.image.name if s.image else server.IMAGE_STRING_FOR_BFV, s.image['id'] if s.image else server.IMAGE_STRING_FOR_BFV, @@ -3061,13 +3839,13 @@ class TestServerList(TestServer): s.flavor['id'], getattr(s, 'OS-EXT-AZ:availability_zone'), getattr(s, 'OS-EXT-SRV-ATTR:host'), - s.Metadata, + format_columns.DictColumn({}), )) self.data_no_name_lookup.append(( s.id, s.name, s.status, - server._format_servers_list_networks(s.networks), + format_columns.DictListColumn(s.networks), # Image will be an empty string if boot-from-volume s.image['id'] if s.image else server.IMAGE_STRING_FOR_BFV, s.flavor['id'] @@ -3127,7 +3905,26 @@ class TestServerList(TestServer): self.servers_mock.list.assert_called_with(**self.kwargs) self.assertEqual(self.columns_long, columns) - self.assertEqual(tuple(self.data_long), tuple(data)) + self.assertCountEqual(tuple(self.data_long), tuple(data)) + + def test_server_list_column_option(self): + arglist = [ + '-c', 'Project ID', + '-c', 'User ID', + '-c', 'Created At', + '--long' + ] + verifylist = [ + ('long', True), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + columns, data = self.cmd.take_action(parsed_args) + + self.servers_mock.list.assert_called_with(**self.kwargs) + self.assertIn('Project ID', columns) + self.assertIn('User ID', columns) + self.assertIn('Created At', columns) def test_server_list_no_name_lookup_option(self): arglist = [ @@ -3387,7 +4184,7 @@ class TestServerList(TestServer): 'Invalid time value' ) - def test_server_with_changes_before_older_version(self): + def test_server_with_changes_before_pre_v266(self): self.app.client_manager.compute.api_version = ( api_versions.APIVersion('2.65')) @@ -3409,9 +4206,11 @@ class TestServerList(TestServer): def test_server_list_v269_with_partial_constructs(self): self.app.client_manager.compute.api_version = \ api_versions.APIVersion('2.69') + arglist = [] verifylist = [] parsed_args = self.check_parser(self.cmd, arglist, verifylist) + # include "partial results" from non-responsive part of # infrastructure. server_dict = { @@ -3434,10 +4233,10 @@ class TestServerList(TestServer): # it will fail at formatting the networks info later on. "networks": {} } - server = compute_fakes.fakes.FakeResource( + _server = compute_fakes.fakes.FakeResource( info=server_dict, ) - self.servers.append(server) + self.servers.append(_server) columns, data = self.cmd.take_action(parsed_args) # get the first three servers out since our interest is in the partial # server. @@ -3446,8 +4245,13 @@ class TestServerList(TestServer): next(data) partial_server = next(data) expected_row = ( - 'server-id-95a56bfc4xxxxxx28d7e418bfd97813a', '', - 'UNKNOWN', '', '', '') + 'server-id-95a56bfc4xxxxxx28d7e418bfd97813a', + '', + 'UNKNOWN', + format_columns.DictListColumn({}), + '', + '', + ) self.assertEqual(expected_row, partial_server) def test_server_list_with_tag(self): @@ -3536,6 +4340,143 @@ class TestServerList(TestServer): '--os-compute-api-version 2.26 or greater is required', str(ex)) + def test_server_list_with_availability_zone(self): + arglist = [ + '--availability-zone', 'test-az', + ] + verifylist = [ + ('availability_zone', 'test-az'), + ] + + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + columns, data = self.cmd.take_action(parsed_args) + + self.search_opts['availability_zone'] = 'test-az' + self.servers_mock.list.assert_called_with(**self.kwargs) + self.assertEqual(self.columns, columns) + self.assertEqual(tuple(self.data), tuple(data)) + + def test_server_list_with_key_name(self): + arglist = [ + '--key-name', 'test-key', + ] + verifylist = [ + ('key_name', 'test-key'), + ] + + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + columns, data = self.cmd.take_action(parsed_args) + + self.search_opts['key_name'] = 'test-key' + self.servers_mock.list.assert_called_with(**self.kwargs) + self.assertEqual(self.columns, columns) + self.assertEqual(tuple(self.data), tuple(data)) + + def test_server_list_with_config_drive(self): + arglist = [ + '--config-drive', + ] + verifylist = [ + ('has_config_drive', True), + ] + + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + columns, data = self.cmd.take_action(parsed_args) + + self.search_opts['config_drive'] = True + self.servers_mock.list.assert_called_with(**self.kwargs) + self.assertEqual(self.columns, columns) + self.assertEqual(tuple(self.data), tuple(data)) + + def test_server_list_with_no_config_drive(self): + arglist = [ + '--no-config-drive', + ] + verifylist = [ + ('has_config_drive', False), + ] + + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + columns, data = self.cmd.take_action(parsed_args) + + self.search_opts['config_drive'] = False + self.servers_mock.list.assert_called_with(**self.kwargs) + self.assertEqual(self.columns, columns) + self.assertEqual(tuple(self.data), tuple(data)) + + def test_server_list_with_progress(self): + arglist = [ + '--progress', '100', + ] + verifylist = [ + ('progress', 100), + ] + + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + columns, data = self.cmd.take_action(parsed_args) + + self.search_opts['progress'] = '100' + self.servers_mock.list.assert_called_with(**self.kwargs) + self.assertEqual(self.columns, columns) + self.assertEqual(tuple(self.data), tuple(data)) + + def test_server_list_with_progress_invalid(self): + arglist = [ + '--progress', '101', + ] + + self.assertRaises( + utils.ParserException, + self.check_parser, self.cmd, arglist, verify_args=[]) + + def test_server_list_with_vm_state(self): + arglist = [ + '--vm-state', 'active', + ] + verifylist = [ + ('vm_state', 'active'), + ] + + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + columns, data = self.cmd.take_action(parsed_args) + + self.search_opts['vm_state'] = 'active' + self.servers_mock.list.assert_called_with(**self.kwargs) + self.assertEqual(self.columns, columns) + self.assertEqual(tuple(self.data), tuple(data)) + + def test_server_list_with_task_state(self): + arglist = [ + '--task-state', 'deleting', + ] + verifylist = [ + ('task_state', 'deleting'), + ] + + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + columns, data = self.cmd.take_action(parsed_args) + + self.search_opts['task_state'] = 'deleting' + self.servers_mock.list.assert_called_with(**self.kwargs) + self.assertEqual(self.columns, columns) + self.assertEqual(tuple(self.data), tuple(data)) + + def test_server_list_with_power_state(self): + arglist = [ + '--power-state', 'running', + ] + verifylist = [ + ('power_state', 'running'), + ] + + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + columns, data = self.cmd.take_action(parsed_args) + + self.search_opts['power_state'] = 1 + self.servers_mock.list.assert_called_with(**self.kwargs) + self.assertEqual(self.columns, columns) + self.assertEqual(tuple(self.data), tuple(data)) + class TestServerLock(TestServer): @@ -3649,8 +4590,8 @@ class TestServerMigrate(TestServer): self.server.id, ] verifylist = [ - ('live', None), - ('block_migration', False), + ('live_migration', False), + ('block_migration', None), ('disk_overcommit', False), ('wait', False), ] @@ -3670,10 +4611,9 @@ class TestServerMigrate(TestServer): '--host', 'fakehost', self.server.id, ] verifylist = [ - ('live', None), ('live_migration', False), ('host', 'fakehost'), - ('block_migration', False), + ('block_migration', None), ('disk_overcommit', False), ('wait', False), ] @@ -3694,7 +4634,7 @@ class TestServerMigrate(TestServer): '--block-migration', self.server.id, ] verifylist = [ - ('live', None), + ('live_migration', False), ('block_migration', True), ('disk_overcommit', False), ('wait', False), @@ -3713,8 +4653,8 @@ class TestServerMigrate(TestServer): '--disk-overcommit', self.server.id, ] verifylist = [ - ('live', None), - ('block_migration', False), + ('live_migration', False), + ('block_migration', None), ('disk_overcommit', True), ('wait', False), ] @@ -3734,10 +4674,9 @@ class TestServerMigrate(TestServer): '--host', 'fakehost', self.server.id, ] verifylist = [ - ('live', None), ('live_migration', False), ('host', 'fakehost'), - ('block_migration', False), + ('block_migration', None), ('disk_overcommit', False), ('wait', False), ] @@ -3756,101 +4695,38 @@ class TestServerMigrate(TestServer): self.assertNotCalled(self.servers_mock.migrate) def test_server_live_migrate(self): - arglist = [ - '--live', 'fakehost', self.server.id, - ] - verifylist = [ - ('live', 'fakehost'), - ('live_migration', False), - ('host', None), - ('block_migration', False), - ('disk_overcommit', False), - ('wait', False), - ] - parsed_args = self.check_parser(self.cmd, arglist, verifylist) - - self.app.client_manager.compute.api_version = \ - api_versions.APIVersion('2.24') - - with mock.patch.object(self.cmd.log, 'warning') as mock_warning: - result = self.cmd.take_action(parsed_args) - - self.servers_mock.get.assert_called_with(self.server.id) - self.server.live_migrate.assert_called_with(block_migration=False, - disk_over_commit=False, - host='fakehost') - self.assertNotCalled(self.servers_mock.migrate) - self.assertIsNone(result) - # A warning should have been logged for using --live. - mock_warning.assert_called_once() - self.assertIn('The --live option has been deprecated.', - str(mock_warning.call_args[0][0])) - - def test_server_live_migrate_host_pre_2_30(self): - # Tests that the --host option is not supported for --live-migration - # before microversion 2.30 (the test defaults to 2.1). - arglist = [ - '--live-migration', '--host', 'fakehost', self.server.id, - ] - verifylist = [ - ('live', None), - ('live_migration', True), - ('host', 'fakehost'), - ('block_migration', False), - ('disk_overcommit', False), - ('wait', False), - ] - parsed_args = self.check_parser(self.cmd, arglist, verifylist) - - ex = self.assertRaises(exceptions.CommandError, self.cmd.take_action, - parsed_args) - - # Make sure it's the error we expect. - self.assertIn('--os-compute-api-version 2.30 or greater is required ' - 'when using --host', str(ex)) - - self.servers_mock.get.assert_called_with(self.server.id) - self.assertNotCalled(self.servers_mock.live_migrate) - self.assertNotCalled(self.servers_mock.migrate) - - def test_server_live_migrate_no_host(self): # Tests the --live-migration option without --host or --live. arglist = [ '--live-migration', self.server.id, ] verifylist = [ - ('live', None), ('live_migration', True), ('host', None), - ('block_migration', False), + ('block_migration', None), ('disk_overcommit', False), ('wait', False), ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) - with mock.patch.object(self.cmd.log, 'warning') as mock_warning: - result = self.cmd.take_action(parsed_args) + result = self.cmd.take_action(parsed_args) self.servers_mock.get.assert_called_with(self.server.id) - self.server.live_migrate.assert_called_with(block_migration=False, - disk_over_commit=False, - host=None) + self.server.live_migrate.assert_called_with( + block_migration=False, + disk_over_commit=False, + host=None) self.assertNotCalled(self.servers_mock.migrate) self.assertIsNone(result) - # Since --live wasn't used a warning shouldn't have been logged. - mock_warning.assert_not_called() def test_server_live_migrate_with_host(self): - # Tests the --live-migration option with --host but no --live. # This requires --os-compute-api-version >= 2.30 so the test uses 2.30. arglist = [ '--live-migration', '--host', 'fakehost', self.server.id, ] verifylist = [ - ('live', None), ('live_migration', True), ('host', 'fakehost'), - ('block_migration', False), + ('block_migration', None), ('disk_overcommit', False), ('wait', False), ] @@ -3862,58 +4738,49 @@ class TestServerMigrate(TestServer): result = self.cmd.take_action(parsed_args) self.servers_mock.get.assert_called_with(self.server.id) - # No disk_overcommit with microversion >= 2.25. - self.server.live_migrate.assert_called_with(block_migration=False, - host='fakehost') + # No disk_overcommit and block_migration defaults to auto with + # microversion >= 2.25 + self.server.live_migrate.assert_called_with( + block_migration='auto', host='fakehost') self.assertNotCalled(self.servers_mock.migrate) self.assertIsNone(result) - def test_server_live_migrate_without_host_override_live(self): - # Tests the --live-migration option without --host and with --live. - # The --live-migration option will take precedence and a warning is - # logged for using --live. + def test_server_live_migrate_with_host_pre_v230(self): + # Tests that the --host option is not supported for --live-migration + # before microversion 2.30 (the test defaults to 2.1). arglist = [ - '--live', 'fakehost', '--live-migration', self.server.id, + '--live-migration', '--host', 'fakehost', self.server.id, ] verifylist = [ - ('live', 'fakehost'), ('live_migration', True), - ('host', None), - ('block_migration', False), + ('host', 'fakehost'), + ('block_migration', None), ('disk_overcommit', False), ('wait', False), ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) - with mock.patch.object(self.cmd.log, 'warning') as mock_warning: - result = self.cmd.take_action(parsed_args) + ex = self.assertRaises( + exceptions.CommandError, self.cmd.take_action, + parsed_args) + + # Make sure it's the error we expect. + self.assertIn( + '--os-compute-api-version 2.30 or greater is required ' + 'when using --host', str(ex)) self.servers_mock.get.assert_called_with(self.server.id) - self.server.live_migrate.assert_called_with(block_migration=False, - disk_over_commit=False, - host=None) + self.assertNotCalled(self.servers_mock.live_migrate) self.assertNotCalled(self.servers_mock.migrate) - self.assertIsNone(result) - # A warning should have been logged for using --live. - mock_warning.assert_called_once() - self.assertIn('The --live option has been deprecated.', - str(mock_warning.call_args[0][0])) - - def test_server_live_migrate_live_and_host_mutex(self): - # Tests specifying both the --live and --host options which are in a - # mutex group so argparse should fail. - arglist = [ - '--live', 'fakehost', '--host', 'fakehost', self.server.id, - ] - self.assertRaises(utils.ParserException, - self.check_parser, self.cmd, arglist, verify_args=[]) def test_server_block_live_migrate(self): arglist = [ - '--live', 'fakehost', '--block-migration', self.server.id, + '--live-migration', + '--block-migration', + self.server.id, ] verifylist = [ - ('live', 'fakehost'), + ('live_migration', True), ('block_migration', True), ('disk_overcommit', False), ('wait', False), @@ -3926,19 +4793,22 @@ class TestServerMigrate(TestServer): result = self.cmd.take_action(parsed_args) self.servers_mock.get.assert_called_with(self.server.id) - self.server.live_migrate.assert_called_with(block_migration=True, - disk_over_commit=False, - host='fakehost') + self.server.live_migrate.assert_called_with( + block_migration=True, + disk_over_commit=False, + host=None) self.assertNotCalled(self.servers_mock.migrate) self.assertIsNone(result) def test_server_live_migrate_with_disk_overcommit(self): arglist = [ - '--live', 'fakehost', '--disk-overcommit', self.server.id, + '--live-migration', + '--disk-overcommit', + self.server.id, ] verifylist = [ - ('live', 'fakehost'), - ('block_migration', False), + ('live_migration', True), + ('block_migration', None), ('disk_overcommit', True), ('wait', False), ] @@ -3950,44 +4820,23 @@ class TestServerMigrate(TestServer): result = self.cmd.take_action(parsed_args) self.servers_mock.get.assert_called_with(self.server.id) - self.server.live_migrate.assert_called_with(block_migration=False, - disk_over_commit=True, - host='fakehost') + self.server.live_migrate.assert_called_with( + block_migration=False, + disk_over_commit=True, + host=None) self.assertNotCalled(self.servers_mock.migrate) self.assertIsNone(result) - def test_server_live_migrate_with_false_value_options(self): + def test_server_live_migrate_with_disk_overcommit_post_v224(self): arglist = [ - '--live', 'fakehost', '--no-disk-overcommit', - '--shared-migration', self.server.id, - ] - verifylist = [ - ('live', 'fakehost'), - ('block_migration', False), - ('disk_overcommit', False), - ('wait', False), - ] - parsed_args = self.check_parser(self.cmd, arglist, verifylist) - - self.app.client_manager.compute.api_version = \ - api_versions.APIVersion('2.24') - - result = self.cmd.take_action(parsed_args) - - self.servers_mock.get.assert_called_with(self.server.id) - self.server.live_migrate.assert_called_with(block_migration=False, - disk_over_commit=False, - host='fakehost') - self.assertNotCalled(self.servers_mock.migrate) - self.assertIsNone(result) - - def test_server_live_migrate_225(self): - arglist = [ - '--live', 'fakehost', self.server.id, + '--live-migration', + '--disk-overcommit', + self.server.id, ] verifylist = [ - ('live', 'fakehost'), - ('block_migration', False), + ('live_migration', True), + ('block_migration', None), + ('disk_overcommit', True), ('wait', False), ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) @@ -3995,13 +4844,21 @@ class TestServerMigrate(TestServer): self.app.client_manager.compute.api_version = \ api_versions.APIVersion('2.25') - result = self.cmd.take_action(parsed_args) + with mock.patch.object(self.cmd.log, 'warning') as mock_warning: + result = self.cmd.take_action(parsed_args) self.servers_mock.get.assert_called_with(self.server.id) - self.server.live_migrate.assert_called_with(block_migration=False, - host='fakehost') + # There should be no 'disk_over_commit' value present + self.server.live_migrate.assert_called_with( + block_migration='auto', + host=None) self.assertNotCalled(self.servers_mock.migrate) self.assertIsNone(result) + # A warning should have been logged for using --disk-overcommit. + mock_warning.assert_called_once() + self.assertIn( + 'The --disk-overcommit and --no-disk-overcommit options ', + str(mock_warning.call_args[0][0])) @mock.patch.object(common_utils, 'wait_for_status', return_value=True) def test_server_migrate_with_wait(self, mock_wait_for_status): @@ -4009,8 +4866,8 @@ class TestServerMigrate(TestServer): '--wait', self.server.id, ] verifylist = [ - ('live', None), - ('block_migration', False), + ('live_migration', False), + ('block_migration', None), ('disk_overcommit', False), ('wait', True), ] @@ -4029,8 +4886,8 @@ class TestServerMigrate(TestServer): '--wait', self.server.id, ] verifylist = [ - ('live', None), - ('block_migration', False), + ('live_migration', False), + ('block_migration', None), ('disk_overcommit', False), ('wait', True), ] @@ -4058,8 +4915,8 @@ class TestListMigration(TestServer): self.server = compute_fakes.FakeServer.create_one_server() self.servers_mock.get.return_value = self.server - self.migrations = compute_fakes.FakeServerMigration\ - .create_server_migrations(count=3) + self.migrations = compute_fakes.FakeMigration.create_migrations( + count=3) self.migrations_mock.list.return_value = self.migrations self.data = (common_utils.get_item_properties( @@ -4079,7 +4936,6 @@ class TestListMigration(TestServer): kwargs = { 'status': None, 'host': None, - 'server': None, } self.migrations_mock.list.assert_called_with(**kwargs) @@ -4106,10 +4962,11 @@ class TestListMigration(TestServer): kwargs = { 'status': 'migrating', 'host': 'host1', - 'server': 'server1', - 'type': 'migration', + 'instance_uuid': self.server.id, + 'migration_type': 'migration', } + self.servers_mock.get.assert_called_with('server1') self.migrations_mock.list.assert_called_with(**kwargs) self.assertEqual(self.MIGRATION_COLUMNS, columns) @@ -4145,7 +5002,6 @@ class TestListMigrationV223(TestListMigration): kwargs = { 'status': 'migrating', 'host': None, - 'server': None, } self.migrations_mock.list.assert_called_with(**kwargs) @@ -4194,7 +5050,6 @@ class TestListMigrationV259(TestListMigration): 'limit': 1, 'marker': 'test_kp', 'host': None, - 'server': None, 'changes_since': '2019-08-09T08:03:25Z', } @@ -4303,7 +5158,6 @@ class TestListMigrationV266(TestListMigration): 'limit': 1, 'marker': 'test_kp', 'host': None, - 'server': None, 'changes_since': '2019-08-07T08:03:25Z', 'changes_before': '2019-08-09T08:03:25Z', } @@ -4343,9 +5197,21 @@ class TestListMigrationV280(TestListMigration): 'Old Flavor', 'New Flavor', 'Type', 'Created At', 'Updated At' ] + project = identity_fakes.FakeProject.create_one_project() + user = identity_fakes.FakeUser.create_one_user() + def setUp(self): super(TestListMigrationV280, self).setUp() + self.projects_mock = self.app.client_manager.identity.projects + self.projects_mock.reset_mock() + + self.users_mock = self.app.client_manager.identity.users + self.users_mock.reset_mock() + + self.projects_mock.get.return_value = self.project + self.users_mock.get.return_value = self.user + self.app.client_manager.compute.api_version = api_versions.APIVersion( '2.80') @@ -4356,7 +5222,7 @@ class TestListMigrationV280(TestListMigration): '--marker', 'test_kp', '--changes-since', '2019-08-07T08:03:25Z', '--changes-before', '2019-08-09T08:03:25Z', - '--project', '0c2accde-644a-45fa-8c10-e76debc7fbc3' + '--project', self.project.id ] verifylist = [ ('status', 'migrating'), @@ -4364,7 +5230,7 @@ class TestListMigrationV280(TestListMigration): ('marker', 'test_kp'), ('changes_since', '2019-08-07T08:03:25Z'), ('changes_before', '2019-08-09T08:03:25Z'), - ('project_id', '0c2accde-644a-45fa-8c10-e76debc7fbc3') + ('project', self.project.id) ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) columns, data = self.cmd.take_action(parsed_args) @@ -4375,8 +5241,7 @@ class TestListMigrationV280(TestListMigration): 'limit': 1, 'marker': 'test_kp', 'host': None, - 'server': None, - 'project_id': '0c2accde-644a-45fa-8c10-e76debc7fbc3', + 'project_id': self.project.id, 'changes_since': '2019-08-07T08:03:25Z', 'changes_before': "2019-08-09T08:03:25Z", } @@ -4401,7 +5266,7 @@ class TestListMigrationV280(TestListMigration): verifylist = [ ('status', 'migrating'), ('changes_before', '2019-08-09T08:03:25Z'), - ('project_id', '0c2accde-644a-45fa-8c10-e76debc7fbc3') + ('project', '0c2accde-644a-45fa-8c10-e76debc7fbc3') ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) ex = self.assertRaises( @@ -4419,7 +5284,7 @@ class TestListMigrationV280(TestListMigration): '--marker', 'test_kp', '--changes-since', '2019-08-07T08:03:25Z', '--changes-before', '2019-08-09T08:03:25Z', - '--user', 'dd214878-ca12-40fb-b035-fa7d2c1e86d6' + '--user', self.user.id, ] verifylist = [ ('status', 'migrating'), @@ -4427,7 +5292,7 @@ class TestListMigrationV280(TestListMigration): ('marker', 'test_kp'), ('changes_since', '2019-08-07T08:03:25Z'), ('changes_before', '2019-08-09T08:03:25Z'), - ('user_id', 'dd214878-ca12-40fb-b035-fa7d2c1e86d6') + ('user', self.user.id), ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) columns, data = self.cmd.take_action(parsed_args) @@ -4438,8 +5303,7 @@ class TestListMigrationV280(TestListMigration): 'limit': 1, 'marker': 'test_kp', 'host': None, - 'server': None, - 'user_id': 'dd214878-ca12-40fb-b035-fa7d2c1e86d6', + 'user_id': self.user.id, 'changes_since': '2019-08-07T08:03:25Z', 'changes_before': "2019-08-09T08:03:25Z", } @@ -4459,12 +5323,12 @@ class TestListMigrationV280(TestListMigration): arglist = [ '--status', 'migrating', '--changes-before', '2019-08-09T08:03:25Z', - '--user', 'dd214878-ca12-40fb-b035-fa7d2c1e86d6' + '--user', self.user.id, ] verifylist = [ ('status', 'migrating'), ('changes_before', '2019-08-09T08:03:25Z'), - ('user_id', 'dd214878-ca12-40fb-b035-fa7d2c1e86d6') + ('user', self.user.id), ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) ex = self.assertRaises( @@ -4481,16 +5345,16 @@ class TestListMigrationV280(TestListMigration): '--limit', '1', '--changes-since', '2019-08-07T08:03:25Z', '--changes-before', '2019-08-09T08:03:25Z', - '--project', '0c2accde-644a-45fa-8c10-e76debc7fbc3', - '--user', 'dd214878-ca12-40fb-b035-fa7d2c1e86d6' + '--project', self.project.id, + '--user', self.user.id, ] verifylist = [ ('status', 'migrating'), ('limit', 1), ('changes_since', '2019-08-07T08:03:25Z'), ('changes_before', '2019-08-09T08:03:25Z'), - ('project_id', '0c2accde-644a-45fa-8c10-e76debc7fbc3'), - ('user_id', 'dd214878-ca12-40fb-b035-fa7d2c1e86d6') + ('project', self.project.id), + ('user', self.user.id), ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) columns, data = self.cmd.take_action(parsed_args) @@ -4500,9 +5364,8 @@ class TestListMigrationV280(TestListMigration): 'status': 'migrating', 'limit': 1, 'host': None, - 'server': None, - 'project_id': '0c2accde-644a-45fa-8c10-e76debc7fbc3', - 'user_id': 'dd214878-ca12-40fb-b035-fa7d2c1e86d6', + 'project_id': self.project.id, + 'user_id': self.user.id, 'changes_since': '2019-08-07T08:03:25Z', 'changes_before': "2019-08-09T08:03:25Z", } @@ -4525,14 +5388,14 @@ class TestListMigrationV280(TestListMigration): arglist = [ '--status', 'migrating', '--changes-before', '2019-08-09T08:03:25Z', - '--project', '0c2accde-644a-45fa-8c10-e76debc7fbc3', - '--user', 'dd214878-ca12-40fb-b035-fa7d2c1e86d6' + '--project', self.project.id, + '--user', self.user.id, ] verifylist = [ ('status', 'migrating'), ('changes_before', '2019-08-09T08:03:25Z'), - ('project_id', '0c2accde-644a-45fa-8c10-e76debc7fbc3'), - ('user_id', 'dd214878-ca12-40fb-b035-fa7d2c1e86d6') + ('project', self.project.id), + ('user', self.user.id) ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) ex = self.assertRaises( @@ -4544,6 +5407,124 @@ class TestListMigrationV280(TestListMigration): str(ex)) +class TestServerMigrationShow(TestServer): + + def setUp(self): + super().setUp() + + self.server = compute_fakes.FakeServer.create_one_server() + self.servers_mock.get.return_value = self.server + + self.server_migration = compute_fakes.FakeServerMigration\ + .create_one_server_migration() + self.server_migrations_mock.get.return_value = self.server_migration + + self.columns = ( + 'ID', + 'Server UUID', + 'Status', + 'Source Compute', + 'Source Node', + 'Dest Compute', + 'Dest Host', + 'Dest Node', + 'Memory Total Bytes', + 'Memory Processed Bytes', + 'Memory Remaining Bytes', + 'Disk Total Bytes', + 'Disk Processed Bytes', + 'Disk Remaining Bytes', + 'Created At', + 'Updated At', + ) + + self.data = ( + self.server_migration.id, + self.server_migration.server_uuid, + self.server_migration.status, + self.server_migration.source_compute, + self.server_migration.source_node, + self.server_migration.dest_compute, + self.server_migration.dest_host, + self.server_migration.dest_node, + self.server_migration.memory_total_bytes, + self.server_migration.memory_processed_bytes, + self.server_migration.memory_remaining_bytes, + self.server_migration.disk_total_bytes, + self.server_migration.disk_processed_bytes, + self.server_migration.disk_remaining_bytes, + self.server_migration.created_at, + self.server_migration.updated_at, + ) + + # Get the command object to test + self.cmd = server.ShowMigration(self.app, None) + + def _test_server_migration_show(self): + arglist = [ + self.server.id, + '2', # arbitrary migration ID + ] + verifylist = [] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + columns, data = self.cmd.take_action(parsed_args) + + self.assertEqual(self.columns, columns) + self.assertEqual(self.data, data) + + self.servers_mock.get.assert_called_with(self.server.id) + self.server_migrations_mock.get.assert_called_with( + self.server.id, '2',) + + def test_server_migration_show(self): + self.app.client_manager.compute.api_version = api_versions.APIVersion( + '2.24') + + self._test_server_migration_show() + + def test_server_migration_show_v259(self): + self.app.client_manager.compute.api_version = api_versions.APIVersion( + '2.59') + + self.columns += ('UUID',) + self.data += (self.server_migration.uuid,) + + self._test_server_migration_show() + + def test_server_migration_show_v280(self): + self.app.client_manager.compute.api_version = api_versions.APIVersion( + '2.80') + + self.columns += ('UUID', 'User ID', 'Project ID') + self.data += ( + self.server_migration.uuid, + self.server_migration.user_id, + self.server_migration.project_id, + ) + + self._test_server_migration_show() + + def test_server_migration_show_pre_v224(self): + self.app.client_manager.compute.api_version = api_versions.APIVersion( + '2.23') + + arglist = [ + self.server.id, + '2', # arbitrary migration ID + ] + verifylist = [] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + ex = self.assertRaises( + exceptions.CommandError, + self.cmd.take_action, + parsed_args) + self.assertIn( + '--os-compute-api-version 2.24 or greater is required', + str(ex)) + + class TestServerMigrationAbort(TestServer): def setUp(self): @@ -4752,7 +5733,64 @@ class TestServerRebuild(TestServer): self.get_image_mock.assert_called_with(self.image.id) self.server.rebuild.assert_called_with(self.image, None) - def test_rebuild_with_current_image_and_password(self): + def test_rebuild_with_name(self): + name = 'test-server-xxx' + arglist = [ + self.server.id, + '--name', name, + ] + verifylist = [ + ('server', self.server.id), + ('name', name), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + # Get the command object to test + self.cmd.take_action(parsed_args) + + self.servers_mock.get.assert_called_with(self.server.id) + self.get_image_mock.assert_called_with(self.image.id) + self.server.rebuild.assert_called_with(self.image, None, name=name) + + def test_rebuild_with_preserve_ephemeral(self): + arglist = [ + self.server.id, + '--preserve-ephemeral', + ] + verifylist = [ + ('server', self.server.id), + ('preserve_ephemeral', True), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + # Get the command object to test + self.cmd.take_action(parsed_args) + + self.servers_mock.get.assert_called_with(self.server.id) + self.get_image_mock.assert_called_with(self.image.id) + self.server.rebuild.assert_called_with( + self.image, None, preserve_ephemeral=True) + + def test_rebuild_with_no_preserve_ephemeral(self): + arglist = [ + self.server.id, + '--no-preserve-ephemeral', + ] + verifylist = [ + ('server', self.server.id), + ('preserve_ephemeral', False), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + # Get the command object to test + self.cmd.take_action(parsed_args) + + self.servers_mock.get.assert_called_with(self.server.id) + self.get_image_mock.assert_called_with(self.image.id) + self.server.rebuild.assert_called_with( + self.image, None, preserve_ephemeral=False) + + def test_rebuild_with_password(self): password = 'password-xxx' arglist = [ self.server.id, @@ -4771,10 +5809,9 @@ class TestServerRebuild(TestServer): self.get_image_mock.assert_called_with(self.image.id) self.server.rebuild.assert_called_with(self.image, password) - def test_rebuild_with_description_api_older(self): - - # Description is not supported for nova api version below 2.19 - self.server.api_version = 2.18 + def test_rebuild_with_description(self): + self.app.client_manager.compute.api_version = \ + api_versions.APIVersion('2.19') description = 'description1' arglist = [ @@ -4787,16 +5824,16 @@ class TestServerRebuild(TestServer): ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) - with mock.patch.object(api_versions, - 'APIVersion', - return_value=2.19): - self.assertRaises(exceptions.CommandError, self.cmd.take_action, - parsed_args) + self.cmd.take_action(parsed_args) - def test_rebuild_with_description_api_newer(self): + self.servers_mock.get.assert_called_with(self.server.id) + self.get_image_mock.assert_called_with(self.image.id) + self.server.rebuild.assert_called_with(self.image, None, + description=description) - # Description is supported for nova api version 2.19 or above - self.server.api_version = 2.19 + def test_rebuild_with_description_pre_v219(self): + self.app.client_manager.compute.api_version = \ + api_versions.APIVersion('2.18') description = 'description1' arglist = [ @@ -4809,16 +5846,10 @@ class TestServerRebuild(TestServer): ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) - with mock.patch.object(api_versions, - 'APIVersion', - return_value=2.19): - # Get the command object to test - self.cmd.take_action(parsed_args) - - self.servers_mock.get.assert_called_with(self.server.id) - self.get_image_mock.assert_called_with(self.image.id) - self.server.rebuild.assert_called_with(self.image, None, - description=description) + self.assertRaises( + exceptions.CommandError, + self.cmd.take_action, + parsed_args) @mock.patch.object(common_utils, 'wait_for_status', return_value=True) def test_rebuild_with_wait_ok(self, mock_wait_for_status): @@ -4878,10 +5909,10 @@ class TestServerRebuild(TestServer): '--property', 'key1=value1', '--property', 'key2=value2' ] - expected_property = {'key1': 'value1', 'key2': 'value2'} + expected_properties = {'key1': 'value1', 'key2': 'value2'} verifylist = [ ('server', self.server.id), - ('property', expected_property) + ('properties', expected_properties) ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) @@ -4891,9 +5922,12 @@ class TestServerRebuild(TestServer): self.servers_mock.get.assert_called_with(self.server.id) self.get_image_mock.assert_called_with(self.image.id) self.server.rebuild.assert_called_with( - self.image, None, meta=expected_property) + self.image, None, meta=expected_properties) def test_rebuild_with_keypair_name(self): + self.app.client_manager.compute.api_version = \ + api_versions.APIVersion('2.54') + self.server.key_name = 'mykey' arglist = [ self.server.id, @@ -4905,23 +5939,17 @@ class TestServerRebuild(TestServer): ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) - self.app.client_manager.compute.api_version = 2.54 - with mock.patch.object(api_versions, - 'APIVersion', - return_value=2.54): - self.cmd.take_action(parsed_args) - args = ( - self.image, - None, - ) - kwargs = dict( - key_name=self.server.key_name, - ) - self.servers_mock.get.assert_called_with(self.server.id) - self.get_image_mock.assert_called_with(self.image.id) - self.server.rebuild.assert_called_with(*args, **kwargs) + self.cmd.take_action(parsed_args) + + self.servers_mock.get.assert_called_with(self.server.id) + self.get_image_mock.assert_called_with(self.image.id) + self.server.rebuild.assert_called_with( + self.image, None, key_name=self.server.key_name) + + def test_rebuild_with_keypair_name_pre_v254(self): + self.app.client_manager.compute.api_version = \ + api_versions.APIVersion('2.53') - def test_rebuild_with_keypair_name_older_version(self): self.server.key_name = 'mykey' arglist = [ self.server.id, @@ -4933,55 +5961,391 @@ class TestServerRebuild(TestServer): ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) - self.app.client_manager.compute.api_version = 2.53 - with mock.patch.object(api_versions, - 'APIVersion', - return_value=2.54): - self.assertRaises(exceptions.CommandError, - self.cmd.take_action, - parsed_args) + self.assertRaises( + exceptions.CommandError, + self.cmd.take_action, + parsed_args) + + def test_rebuild_with_no_keypair_name(self): + self.app.client_manager.compute.api_version = \ + api_versions.APIVersion('2.54') - def test_rebuild_with_keypair_unset(self): self.server.key_name = 'mykey' arglist = [ self.server.id, - '--key-unset', + '--no-key-name', ] verifylist = [ ('server', self.server.id), ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) - self.app.client_manager.compute.api_version = 2.54 - with mock.patch.object(api_versions, - 'APIVersion', - return_value=2.54): - self.cmd.take_action(parsed_args) - args = ( - self.image, - None, - ) - kwargs = dict( - key_name=None, - ) - self.servers_mock.get.assert_called_with(self.server.id) - self.get_image_mock.assert_called_with(self.image.id) - self.server.rebuild.assert_called_with(*args, **kwargs) + self.cmd.take_action(parsed_args) + self.servers_mock.get.assert_called_with(self.server.id) + self.get_image_mock.assert_called_with(self.image.id) + self.server.rebuild.assert_called_with( + self.image, None, key_name=None) - def test_rebuild_with_key_name_and_unset(self): + def test_rebuild_with_keypair_name_and_unset(self): self.server.key_name = 'mykey' arglist = [ self.server.id, '--key-name', self.server.key_name, - '--key-unset', + '--no-key-name', ] verifylist = [ ('server', self.server.id), ('key_name', self.server.key_name) ] - self.assertRaises(utils.ParserException, - self.check_parser, - self.cmd, arglist, verifylist) + self.assertRaises( + utils.ParserException, + self.check_parser, + self.cmd, arglist, verifylist) + + @mock.patch('openstackclient.compute.v2.server.io.open') + def test_rebuild_with_user_data(self, mock_open): + self.app.client_manager.compute.api_version = \ + api_versions.APIVersion('2.57') + + mock_file = mock.Mock(name='File') + mock_open.return_value = mock_file + mock_open.read.return_value = '#!/bin/sh' + + arglist = [ + self.server.id, + '--user-data', 'userdata.sh', + ] + verifylist = [ + ('server', self.server.id), + ('user_data', 'userdata.sh'), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + self.cmd.take_action(parsed_args) + + # Ensure the userdata file is opened + mock_open.assert_called_with('userdata.sh') + + # Ensure the userdata file is closed + mock_file.close.assert_called_with() + + self.servers_mock.get.assert_called_with(self.server.id) + self.get_image_mock.assert_called_with(self.image.id) + self.server.rebuild.assert_called_with( + self.image, None, + userdata=mock_file,) + + def test_rebuild_with_user_data_pre_257(self): + self.app.client_manager.compute.api_version = \ + api_versions.APIVersion('2.56') + + arglist = [ + self.server.id, + '--user-data', 'userdata.sh', + ] + verifylist = [ + ('server', self.server.id), + ('user_data', 'userdata.sh'), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + self.assertRaises( + exceptions.CommandError, + self.cmd.take_action, + parsed_args) + + def test_rebuild_with_no_user_data(self): + self.app.client_manager.compute.api_version = \ + api_versions.APIVersion('2.54') + + self.server.key_name = 'mykey' + arglist = [ + self.server.id, + '--no-user-data', + ] + verifylist = [ + ('server', self.server.id), + ('no_user_data', True), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + self.cmd.take_action(parsed_args) + self.servers_mock.get.assert_called_with(self.server.id) + self.get_image_mock.assert_called_with(self.image.id) + self.server.rebuild.assert_called_with( + self.image, None, userdata=None) + + def test_rebuild_with_no_user_data_pre_254(self): + self.app.client_manager.compute.api_version = \ + api_versions.APIVersion('2.53') + + arglist = [ + self.server.id, + '--no-user-data', + ] + verifylist = [ + ('server', self.server.id), + ('no_user_data', True), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + self.assertRaises( + exceptions.CommandError, + self.cmd.take_action, + parsed_args) + + def test_rebuild_with_user_data_and_unset(self): + arglist = [ + self.server.id, + '--user-data', 'userdata.sh', + '--no-user-data', + ] + self.assertRaises( + utils.ParserException, + self.check_parser, + self.cmd, arglist, None) + + def test_rebuild_with_trusted_image_cert(self): + self.app.client_manager.compute.api_version = \ + api_versions.APIVersion('2.63') + + arglist = [ + self.server.id, + '--trusted-image-cert', 'foo', + '--trusted-image-cert', 'bar', + ] + verifylist = [ + ('server', self.server.id), + ('trusted_image_certs', ['foo', 'bar']), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + self.cmd.take_action(parsed_args) + + self.servers_mock.get.assert_called_with(self.server.id) + self.get_image_mock.assert_called_with(self.image.id) + self.server.rebuild.assert_called_with( + self.image, None, trusted_image_certificates=['foo', 'bar']) + + def test_rebuild_with_trusted_image_cert_pre_v263(self): + self.app.client_manager.compute.api_version = \ + api_versions.APIVersion('2.62') + + arglist = [ + self.server.id, + '--trusted-image-cert', 'foo', + '--trusted-image-cert', 'bar', + ] + verifylist = [ + ('server', self.server.id), + ('trusted_image_certs', ['foo', 'bar']), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + self.assertRaises( + exceptions.CommandError, + self.cmd.take_action, + parsed_args) + + def test_rebuild_with_no_trusted_image_cert(self): + self.app.client_manager.compute.api_version = \ + api_versions.APIVersion('2.63') + + arglist = [ + self.server.id, + '--no-trusted-image-certs', + ] + verifylist = [ + ('server', self.server.id), + ('no_trusted_image_certs', True), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + self.cmd.take_action(parsed_args) + self.servers_mock.get.assert_called_with(self.server.id) + self.get_image_mock.assert_called_with(self.image.id) + self.server.rebuild.assert_called_with( + self.image, None, trusted_image_certificates=None) + + def test_rebuild_with_no_trusted_image_cert_pre_257(self): + self.app.client_manager.compute.api_version = \ + api_versions.APIVersion('2.62') + + arglist = [ + self.server.id, + '--no-trusted-image-certs', + ] + verifylist = [ + ('server', self.server.id), + ('no_trusted_image_certs', True), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + self.assertRaises( + exceptions.CommandError, + self.cmd.take_action, + parsed_args) + + +class TestEvacuateServer(TestServer): + + def setUp(self): + super(TestEvacuateServer, self).setUp() + # Return value for utils.find_resource for image + self.image = image_fakes.FakeImage.create_one_image() + self.images_mock.get.return_value = self.image + + # Fake the rebuilt new server. + attrs = { + 'image': { + 'id': self.image.id + }, + 'networks': {}, + 'adminPass': 'passw0rd', + } + new_server = compute_fakes.FakeServer.create_one_server(attrs=attrs) + + # Fake the server to be rebuilt. The IDs of them should be the same. + attrs['id'] = new_server.id + methods = { + 'evacuate': new_server, + } + self.server = compute_fakes.FakeServer.create_one_server( + attrs=attrs, + methods=methods + ) + + # Return value for utils.find_resource for server. + self.servers_mock.get.return_value = self.server + + self.cmd = server.EvacuateServer(self.app, None) + + def _test_evacuate(self, args, verify_args, evac_args): + parsed_args = self.check_parser(self.cmd, args, verify_args) + + # Get the command object to test + self.cmd.take_action(parsed_args) + + self.servers_mock.get.assert_called_with(self.server.id) + self.server.evacuate.assert_called_with(**evac_args) + + def test_evacuate(self): + args = [ + self.server.id, + ] + verify_args = [ + ('server', self.server.id), + ] + evac_args = { + 'host': None, 'on_shared_storage': False, 'password': None, + } + self._test_evacuate(args, verify_args, evac_args) + + def test_evacuate_with_password(self): + args = [ + self.server.id, + '--password', 'password', + ] + verify_args = [ + ('server', self.server.id), + ('password', 'password'), + ] + evac_args = { + 'host': None, 'on_shared_storage': False, 'password': 'password', + } + self._test_evacuate(args, verify_args, evac_args) + + def test_evacuate_with_host(self): + self.app.client_manager.compute.api_version = \ + api_versions.APIVersion('2.29') + + host = 'target-host' + args = [ + self.server.id, + '--host', 'target-host', + ] + verify_args = [ + ('server', self.server.id), + ('host', 'target-host'), + ] + evac_args = {'host': host, 'password': None} + + self._test_evacuate(args, verify_args, evac_args) + + def test_evacuate_with_host_pre_v229(self): + self.app.client_manager.compute.api_version = \ + api_versions.APIVersion('2.28') + + args = [ + self.server.id, + '--host', 'target-host', + ] + verify_args = [ + ('server', self.server.id), + ('host', 'target-host'), + ] + parsed_args = self.check_parser(self.cmd, args, verify_args) + + self.assertRaises( + exceptions.CommandError, + self.cmd.take_action, + parsed_args) + + def test_evacuate_without_share_storage(self): + self.app.client_manager.compute.api_version = \ + api_versions.APIVersion('2.13') + + args = [ + self.server.id, + '--shared-storage' + ] + verify_args = [ + ('server', self.server.id), + ('shared_storage', True), + ] + evac_args = { + 'host': None, 'on_shared_storage': True, 'password': None, + } + self._test_evacuate(args, verify_args, evac_args) + + def test_evacuate_without_share_storage_post_v213(self): + self.app.client_manager.compute.api_version = \ + api_versions.APIVersion('2.14') + + args = [ + self.server.id, + '--shared-storage' + ] + verify_args = [ + ('server', self.server.id), + ('shared_storage', True), + ] + parsed_args = self.check_parser(self.cmd, args, verify_args) + + self.assertRaises( + exceptions.CommandError, + self.cmd.take_action, + parsed_args) + + @mock.patch.object(common_utils, 'wait_for_status', return_value=True) + def test_evacuate_with_wait_ok(self, mock_wait_for_status): + args = [ + self.server.id, + '--wait', + ] + verify_args = [ + ('server', self.server.id), + ('wait', True), + ] + evac_args = { + 'host': None, 'on_shared_storage': False, 'password': None, + } + self._test_evacuate(args, verify_args, evac_args) + mock_wait_for_status.assert_called_once_with( + self.servers_mock.get, + self.server.id, + callback=mock.ANY, + ) class TestServerRemoveFixedIP(TestServer): @@ -5556,6 +6920,82 @@ class TestServerResizeConfirm(TestServer): self.server.confirm_resize.assert_called_with() +# TODO(stephenfin): Remove in OSC 7.0 +class TestServerMigrateConfirm(TestServer): + + def setUp(self): + super().setUp() + + methods = { + 'confirm_resize': None, + } + self.server = compute_fakes.FakeServer.create_one_server( + methods=methods) + + # This is the return value for utils.find_resource() + self.servers_mock.get.return_value = self.server + + self.servers_mock.confirm_resize.return_value = None + + # Get the command object to test + self.cmd = server.MigrateConfirm(self.app, None) + + def test_migrate_confirm(self): + arglist = [ + self.server.id, + ] + verifylist = [ + ('server', self.server.id), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + with mock.patch.object(self.cmd.log, 'warning') as mock_warning: + self.cmd.take_action(parsed_args) + + self.servers_mock.get.assert_called_with(self.server.id) + self.server.confirm_resize.assert_called_with() + + mock_warning.assert_called_once() + self.assertIn( + "The 'server migrate confirm' command has been deprecated", + str(mock_warning.call_args[0][0]) + ) + + +class TestServerConfirmMigration(TestServerResizeConfirm): + + def setUp(self): + super().setUp() + + methods = { + 'confirm_resize': None, + } + self.server = compute_fakes.FakeServer.create_one_server( + methods=methods) + + # This is the return value for utils.find_resource() + self.servers_mock.get.return_value = self.server + + self.servers_mock.confirm_resize.return_value = None + + # Get the command object to test + self.cmd = server.ConfirmMigration(self.app, None) + + def test_migration_confirm(self): + arglist = [ + self.server.id, + ] + verifylist = [ + ('server', self.server.id), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + self.cmd.take_action(parsed_args) + + self.servers_mock.get.assert_called_with(self.server.id) + self.server.confirm_resize.assert_called_with() + + class TestServerResizeRevert(TestServer): def setUp(self): @@ -5590,6 +7030,82 @@ class TestServerResizeRevert(TestServer): self.server.revert_resize.assert_called_with() +# TODO(stephenfin): Remove in OSC 7.0 +class TestServerMigrateRevert(TestServer): + + def setUp(self): + super().setUp() + + methods = { + 'revert_resize': None, + } + self.server = compute_fakes.FakeServer.create_one_server( + methods=methods) + + # This is the return value for utils.find_resource() + self.servers_mock.get.return_value = self.server + + self.servers_mock.revert_resize.return_value = None + + # Get the command object to test + self.cmd = server.MigrateRevert(self.app, None) + + def test_migrate_revert(self): + arglist = [ + self.server.id, + ] + verifylist = [ + ('server', self.server.id), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + with mock.patch.object(self.cmd.log, 'warning') as mock_warning: + self.cmd.take_action(parsed_args) + + self.servers_mock.get.assert_called_with(self.server.id) + self.server.revert_resize.assert_called_with() + + mock_warning.assert_called_once() + self.assertIn( + "The 'server migrate revert' command has been deprecated", + str(mock_warning.call_args[0][0]) + ) + + +class TestServerRevertMigration(TestServer): + + def setUp(self): + super().setUp() + + methods = { + 'revert_resize': None, + } + self.server = compute_fakes.FakeServer.create_one_server( + methods=methods) + + # This is the return value for utils.find_resource() + self.servers_mock.get.return_value = self.server + + self.servers_mock.revert_resize.return_value = None + + # Get the command object to test + self.cmd = server.RevertMigration(self.app, None) + + def test_migration_revert(self): + arglist = [ + self.server.id, + ] + verifylist = [ + ('server', self.server.id), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + self.cmd.take_action(parsed_args) + + self.servers_mock.get.assert_called_with(self.server.id) + self.server.revert_resize.assert_called_with() + + class TestServerRestore(TestServer): def setUp(self): @@ -5643,6 +7159,7 @@ class TestServerSet(TestServer): 'update': None, 'reset_state': None, 'change_password': None, + 'clear_password': None, 'add_tag': None, 'set_tags': None, } @@ -5717,15 +7234,46 @@ class TestServerSet(TestServer): 'foo_vm', ] verifylist = [ - ('property', {'key1': 'value1', 'key2': 'value2'}), + ('properties', {'key1': 'value1', 'key2': 'value2'}), ('server', 'foo_vm'), ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) result = self.cmd.take_action(parsed_args) self.servers_mock.set_meta.assert_called_once_with( - self.fake_servers[0], parsed_args.property) + self.fake_servers[0], parsed_args.properties) self.assertIsNone(result) + def test_server_set_with_password(self): + arglist = [ + '--password', 'foo', + 'foo_vm', + ] + verifylist = [ + ('password', 'foo'), + ('server', 'foo_vm'), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + self.cmd.take_action(parsed_args) + + self.fake_servers[0].change_password.assert_called_once_with('foo') + + def test_server_set_with_no_password(self): + arglist = [ + '--no-password', + 'foo_vm', + ] + verifylist = [ + ('no_password', True), + ('server', 'foo_vm'), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + self.cmd.take_action(parsed_args) + + self.fake_servers[0].clear_password.assert_called_once_with() + + # TODO(stephenfin): Remove this in a future major version @mock.patch.object(getpass, 'getpass', return_value=mock.sentinel.fake_pass) def test_server_set_with_root_password(self, mock_getpass): @@ -5838,16 +7386,126 @@ class TestServerShelve(TestServer): # Get the command object to test self.cmd = server.ShelveServer(self.app, None) - # Set shelve method to be tested. - self.methods = { + def test_shelve(self): + server_info = {'status': 'ACTIVE'} + server_methods = { + 'shelve': None, + 'shelve_offload': None, + } + + server = compute_fakes.FakeServer.create_one_server( + attrs=server_info, methods=server_methods) + self.servers_mock.get.return_value = server + + arglist = [server.name] + verifylist = [ + ('servers', [server.name]), + ('wait', False), + ('offload', False), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + result = self.cmd.take_action(parsed_args) + self.assertIsNone(result) + + self.servers_mock.get.assert_called_once_with(server.name) + server.shelve.assert_called_once_with() + server.shelve_offload.assert_not_called() + + def test_shelve_already_shelved(self): + server_info = {'status': 'SHELVED'} + server_methods = { 'shelve': None, + 'shelve_offload': None, } - def test_shelve_one_server(self): - self.run_method_with_servers('shelve', 1) + server = compute_fakes.FakeServer.create_one_server( + attrs=server_info, methods=server_methods) + self.servers_mock.get.return_value = server - def test_shelve_multi_servers(self): - self.run_method_with_servers('shelve', 3) + arglist = [server.name] + verifylist = [ + ('servers', [server.name]), + ('wait', False), + ('offload', False), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + result = self.cmd.take_action(parsed_args) + self.assertIsNone(result) + + self.servers_mock.get.assert_called_once_with(server.name) + server.shelve.assert_not_called() + server.shelve_offload.assert_not_called() + + @mock.patch.object(common_utils, 'wait_for_status', return_value=True) + def test_shelve_with_wait(self, mock_wait_for_status): + server_info = {'status': 'ACTIVE'} + server_methods = { + 'shelve': None, + 'shelve_offload': None, + } + + server = compute_fakes.FakeServer.create_one_server( + attrs=server_info, methods=server_methods) + self.servers_mock.get.return_value = server + + arglist = ['--wait', server.name] + verifylist = [ + ('servers', [server.name]), + ('wait', True), + ('offload', False), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + result = self.cmd.take_action(parsed_args) + self.assertIsNone(result) + + self.servers_mock.get.assert_called_once_with(server.name) + server.shelve.assert_called_once_with() + server.shelve_offload.assert_not_called() + mock_wait_for_status.assert_called_once_with( + self.servers_mock.get, + server.id, + callback=mock.ANY, + success_status=('shelved', 'shelved_offloaded'), + ) + + @mock.patch.object(common_utils, 'wait_for_status', return_value=True) + def test_shelve_offload(self, mock_wait_for_status): + server_info = {'status': 'ACTIVE'} + server_methods = { + 'shelve': None, + 'shelve_offload': None, + } + + server = compute_fakes.FakeServer.create_one_server( + attrs=server_info, methods=server_methods) + self.servers_mock.get.return_value = server + + arglist = ['--offload', server.name] + verifylist = [ + ('servers', [server.name]), + ('wait', False), + ('offload', True), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + result = self.cmd.take_action(parsed_args) + self.assertIsNone(result) + + self.servers_mock.get.assert_has_calls([ + mock.call(server.name), + mock.call(server.name), + ]) + server.shelve.assert_called_once_with() + server.shelve_offload.assert_called_once_with() + mock_wait_for_status.assert_called_once_with( + self.servers_mock.get, + server.id, + callback=mock.ANY, + success_status=('shelved', 'shelved_offloaded'), + ) class TestServerShow(TestServer): @@ -5857,6 +7515,10 @@ class TestServerShow(TestServer): self.image = image_fakes.FakeImage.create_one_image() self.flavor = compute_fakes.FakeFlavor.create_one_flavor() + self.topology = { + 'nodes': [{'vcpu_set': [0, 1]}, {'vcpu_set': [2, 3]}], + 'pagesize_kb': None, + } server_info = { 'image': {'id': self.image.id}, 'flavor': {'id': self.flavor.id}, @@ -5870,6 +7532,7 @@ class TestServerShow(TestServer): resp.status_code = 200 server_method = { 'diagnostics': (resp, {'test': 'test'}), + 'topology': self.topology, } self.server = compute_fakes.FakeServer.create_one_server( attrs=server_info, methods=server_method) @@ -5895,15 +7558,16 @@ class TestServerShow(TestServer): ) self.data = ( - 'Running', - 'public=10.20.30.40, 2001:db8::f', + server.PowerStateColumn( + getattr(self.server, 'OS-EXT-STS:power_state')), + format_columns.DictListColumn(self.server.networks), self.flavor.name + " (" + self.flavor.id + ")", self.server.id, self.image.name + " (" + self.image.id + ")", self.server.name, {'public': ['10.20.30.40', '2001:db8::f']}, 'tenant-id-xxx', - '', + format_columns.DictColumn({}), ) def test_show_no_options(self): @@ -5919,6 +7583,7 @@ class TestServerShow(TestServer): ] verifylist = [ ('diagnostics', False), + ('topology', False), ('server', self.server.name), ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) @@ -5926,7 +7591,7 @@ class TestServerShow(TestServer): columns, data = self.cmd.take_action(parsed_args) self.assertEqual(self.columns, columns) - self.assertEqual(self.data, data) + self.assertCountEqual(self.data, data) def test_show_embedded_flavor(self): # Tests using --os-compute-api-version >= 2.47 where the flavor @@ -5936,6 +7601,7 @@ class TestServerShow(TestServer): ] verifylist = [ ('diagnostics', False), + ('topology', False), ('server', self.server.name), ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) @@ -5953,7 +7619,7 @@ class TestServerShow(TestServer): self.assertEqual(self.columns, columns) # Since the flavor details are in a dict we can't be sure of the # ordering so just assert that one of the keys is in the output. - self.assertIn('original_name', data[2]) + self.assertIn('original_name', data[2]._value) def test_show_diagnostics(self): arglist = [ @@ -5962,6 +7628,7 @@ class TestServerShow(TestServer): ] verifylist = [ ('diagnostics', True), + ('topology', False), ('server', self.server.name), ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) @@ -5971,6 +7638,47 @@ class TestServerShow(TestServer): self.assertEqual(('test',), columns) self.assertEqual(('test',), data) + def test_show_topology(self): + self.app.client_manager.compute.api_version = \ + api_versions.APIVersion('2.78') + + arglist = [ + '--topology', + self.server.name, + ] + verifylist = [ + ('diagnostics', False), + ('topology', True), + ('server', self.server.name), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + self.columns += ('topology',) + self.data += (format_columns.DictColumn(self.topology),) + + columns, data = self.cmd.take_action(parsed_args) + + self.assertCountEqual(self.columns, columns) + self.assertCountEqual(self.data, data) + + def test_show_topology_pre_v278(self): + self.app.client_manager.compute.api_version = \ + api_versions.APIVersion('2.77') + + arglist = [ + '--topology', + self.server.name, + ] + verifylist = [ + ('diagnostics', False), + ('topology', True), + ('server', self.server.name), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + self.assertRaises( + exceptions.CommandError, self.cmd.take_action, parsed_args) + class TestServerStart(TestServer): @@ -5991,6 +7699,28 @@ class TestServerStart(TestServer): def test_server_start_multi_servers(self): self.run_method_with_servers('start', 3) + @mock.patch.object(common_utils, 'find_resource') + def test_server_start_with_all_projects(self, mock_find_resource): + servers = self.setup_servers_mock(count=1) + mock_find_resource.side_effect = compute_fakes.FakeServer.get_servers( + servers, 0, + ) + + arglist = [ + servers[0].id, + '--all-projects', + ] + verifylist = [ + ('server', [servers[0].id]), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + self.cmd.take_action(parsed_args) + + mock_find_resource.assert_called_once_with( + mock.ANY, servers[0].id, all_tenants=True, + ) + class TestServerStop(TestServer): @@ -6011,6 +7741,28 @@ class TestServerStop(TestServer): def test_server_stop_multi_servers(self): self.run_method_with_servers('stop', 3) + @mock.patch.object(common_utils, 'find_resource') + def test_server_start_with_all_projects(self, mock_find_resource): + servers = self.setup_servers_mock(count=1) + mock_find_resource.side_effect = compute_fakes.FakeServer.get_servers( + servers, 0, + ) + + arglist = [ + servers[0].id, + '--all-projects', + ] + verifylist = [ + ('server', [servers[0].id]), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + self.cmd.take_action(parsed_args) + + mock_find_resource.assert_called_once_with( + mock.ANY, servers[0].id, all_tenants=True, + ) + class TestServerSuspend(TestServer): @@ -6101,7 +7853,7 @@ class TestServerUnset(TestServer): 'foo_vm', ] verifylist = [ - ('property', ['key1', 'key2']), + ('properties', ['key1', 'key2']), ('server', 'foo_vm'), ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) @@ -6213,6 +7965,9 @@ class TestServerUnshelve(TestServer): self.methods = { 'unshelve': None, } + self.attrs = { + 'status': 'SHELVED', + } def test_unshelve_one_server(self): self.run_method_with_servers('unshelve', 1) @@ -6220,55 +7975,74 @@ class TestServerUnshelve(TestServer): def test_unshelve_multi_servers(self): self.run_method_with_servers('unshelve', 3) - def test_unshelve_server_with_specified_az(self): - server = compute_fakes.FakeServer.create_one_server() + def test_unshelve_with_specified_az(self): + self.app.client_manager.compute.api_version = \ + api_versions.APIVersion('2.77') + + server = compute_fakes.FakeServer.create_one_server( + attrs=self.attrs, methods=self.methods) + self.servers_mock.get.return_value = server arglist = [ - server.id, '--availability-zone', "foo-az", + server.id, ] verifylist = [ ('availability_zone', "foo-az"), ('server', [server.id]) ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) - ex = self.assertRaises(exceptions.CommandError, - self.cmd.take_action, - parsed_args) - self.assertIn( - '--os-compute-api-version 2.77 or greater is required', str(ex)) + self.cmd.take_action(parsed_args) -class TestServerUnshelveV277(TestServerUnshelve): - - def setUp(self): - super(TestServerUnshelveV277, self).setUp() - - self.server = compute_fakes.FakeServer.create_one_server( - methods=self.methods) - - # This is the return value for utils.find_resource() - self.servers_mock.get.return_value = self.server - - # Get the command object to test - self.cmd = server.UnshelveServer(self.app, None) + self.servers_mock.get.assert_called_with(server.id) + server.unshelve.assert_called_with(availability_zone="foo-az") - def test_specified_az_to_unshelve_with_v277(self): - self.app.client_manager.compute.api_version = api_versions.APIVersion( - '2.77') + def test_unshelve_with_specified_az_pre_v277(self): + self.app.client_manager.compute.api_version = \ + api_versions.APIVersion('2.76') + server = compute_fakes.FakeServer.create_one_server( + attrs=self.attrs, methods=self.methods) arglist = [ + server.id, '--availability-zone', "foo-az", - self.server.id, ] verifylist = [ ('availability_zone', "foo-az"), - ('server', [self.server.id]) + ('server', [server.id]) ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) + ex = self.assertRaises( + exceptions.CommandError, + self.cmd.take_action, + parsed_args) + self.assertIn( + '--os-compute-api-version 2.77 or greater is required', str(ex)) - self.cmd.take_action(parsed_args) - self.servers_mock.get.assert_called_with(self.server.id) - self.server.unshelve.assert_called_with(availability_zone="foo-az") + @mock.patch.object(common_utils, 'wait_for_status', return_value=True) + def test_unshelve_with_wait(self, mock_wait_for_status): + server = compute_fakes.FakeServer.create_one_server( + attrs=self.attrs, methods=self.methods) + self.servers_mock.get.return_value = server + + arglist = ['--wait', server.name] + verifylist = [ + ('server', [server.name]), + ('wait', True), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + result = self.cmd.take_action(parsed_args) + self.assertIsNone(result) + + self.servers_mock.get.assert_called_once_with(server.name) + server.unshelve.assert_called_once_with() + mock_wait_for_status.assert_called_once_with( + self.servers_mock.get, + server.id, + callback=mock.ANY, + success_status=('active', 'shutoff'), + ) class TestServerGeneral(TestServer): @@ -6322,50 +8096,6 @@ class TestServerGeneral(TestServer): self.assertRaises(exceptions.CommandError, server._get_ip_address, self.OLD, 'private', [6]) - def test_format_servers_list_power_state(self): - self.assertEqual("NOSTATE", - server._format_servers_list_power_state(0x00)) - self.assertEqual("Running", - server._format_servers_list_power_state(0x01)) - self.assertEqual("", - server._format_servers_list_power_state(0x02)) - self.assertEqual("Paused", - server._format_servers_list_power_state(0x03)) - self.assertEqual("Shutdown", - server._format_servers_list_power_state(0x04)) - self.assertEqual("", - server._format_servers_list_power_state(0x05)) - self.assertEqual("Crashed", - server._format_servers_list_power_state(0x06)) - self.assertEqual("Suspended", - server._format_servers_list_power_state(0x07)) - self.assertEqual("N/A", - server._format_servers_list_power_state(0x08)) - - def test_format_servers_list_networks(self): - # Setup network info to test. - networks = { - u'public': [u'10.20.30.40', u'2001:db8::f'], - u'private': [u'2001:db8::f', u'10.20.30.40'], - } - - # Prepare expected data. - # Since networks is a dict, whose items are in random order, there - # could be two results after formatted. - data_1 = (u'private=2001:db8::f, 10.20.30.40; ' - u'public=10.20.30.40, 2001:db8::f') - data_2 = (u'public=10.20.30.40, 2001:db8::f; ' - u'private=2001:db8::f, 10.20.30.40') - - # Call _format_servers_list_networks(). - networks_format = server._format_servers_list_networks(networks) - - msg = ('Network string is not formatted correctly.\n' - 'reference = %s or %s\n' - 'actual = %s\n' % - (data_1, data_2, networks_format)) - self.assertIn(networks_format, (data_1, data_2), msg) - @mock.patch('osc_lib.utils.find_resource') def test_prep_server_detail(self, find_resource): # Setup mock method return value. utils.find_resource() will be called @@ -6392,14 +8122,14 @@ class TestServerGeneral(TestServer): info = { 'id': _server.id, 'name': _server.name, - 'addresses': u'public=10.20.30.40, 2001:db8::f', - 'flavor': u'%s (%s)' % (_flavor.name, _flavor.id), - 'image': u'%s (%s)' % (_image.name, _image.id), - 'project_id': u'tenant-id-xxx', - 'properties': '', - 'OS-EXT-STS:power_state': server._format_servers_list_power_state( + 'image': '%s (%s)' % (_image.name, _image.id), + 'flavor': '%s (%s)' % (_flavor.name, _flavor.id), + 'OS-EXT-STS:power_state': server.PowerStateColumn( getattr(_server, 'OS-EXT-STS:power_state')), + 'properties': '', 'volumes_attached': [{"id": "6344fe9d-ef20-45b2-91a6"}], + 'addresses': format_columns.DictListColumn(_server.networks), + 'project_id': 'tenant-id-xxx', } # Call _prep_server_detail(). @@ -6412,4 +8142,4 @@ class TestServerGeneral(TestServer): server_detail.pop('networks') # Check the results. - self.assertEqual(info, server_detail) + self.assertCountEqual(info, server_detail) diff --git a/openstackclient/tests/unit/compute/v2/test_server_backup.py b/openstackclient/tests/unit/compute/v2/test_server_backup.py index 5cdc2080..753db9cd 100644 --- a/openstackclient/tests/unit/compute/v2/test_server_backup.py +++ b/openstackclient/tests/unit/compute/v2/test_server_backup.py @@ -139,7 +139,7 @@ class TestServerBackupCreate(TestServerBackup): ) self.assertEqual(self.image_columns(images[0]), columns) - self.assertItemEqual(self.image_data(images[0]), data) + self.assertItemsEqual(self.image_data(images[0]), data) def test_server_backup_create_options(self): servers = self.setup_servers_mock(count=1) @@ -173,7 +173,7 @@ class TestServerBackupCreate(TestServerBackup): ) self.assertEqual(self.image_columns(images[0]), columns) - self.assertItemEqual(self.image_data(images[0]), data) + self.assertItemsEqual(self.image_data(images[0]), data) @mock.patch.object(common_utils, 'wait_for_status', return_value=False) def test_server_backup_wait_fail(self, mock_wait_for_status): @@ -269,4 +269,4 @@ class TestServerBackupCreate(TestServerBackup): ) self.assertEqual(self.image_columns(images[0]), columns) - self.assertItemEqual(self.image_data(images[0]), data) + self.assertItemsEqual(self.image_data(images[0]), data) diff --git a/openstackclient/tests/unit/compute/v2/test_server_event.py b/openstackclient/tests/unit/compute/v2/test_server_event.py index 5c94891a..058a44d8 100644 --- a/openstackclient/tests/unit/compute/v2/test_server_event.py +++ b/openstackclient/tests/unit/compute/v2/test_server_event.py @@ -11,7 +11,12 @@ # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations # under the License. -# + +from unittest import mock + +import iso8601 +from novaclient import api_versions +from osc_lib import exceptions from openstackclient.compute.v2 import server_event from openstackclient.tests.unit.compute.v2 import fakes as compute_fakes @@ -113,6 +118,234 @@ class TestListServerEvent(TestServerEvent): self.assertEqual(self.long_columns, columns) self.assertEqual(self.long_data, tuple(data)) + def test_server_event_list_with_changes_since(self): + self.app.client_manager.compute.api_version = \ + api_versions.APIVersion('2.58') + + arglist = [ + '--changes-since', '2016-03-04T06:27:59Z', + self.fake_server.name, + ] + verifylist = [ + ('server', self.fake_server.name), + ('changes_since', '2016-03-04T06:27:59Z'), + ] + + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + columns, data = self.cmd.take_action(parsed_args) + + self.servers_mock.get.assert_called_once_with(self.fake_server.name) + self.events_mock.list.assert_called_once_with( + self.fake_server.id, changes_since='2016-03-04T06:27:59Z') + + self.assertEqual(self.columns, columns) + self.assertEqual(tuple(self.data), tuple(data)) + + @mock.patch.object(iso8601, 'parse_date', side_effect=iso8601.ParseError) + def test_server_event_list_with_changes_since_invalid( + self, mock_parse_isotime, + ): + self.app.client_manager.compute.api_version = \ + api_versions.APIVersion('2.58') + + arglist = [ + '--changes-since', 'Invalid time value', + self.fake_server.name, + ] + verifylist = [ + ('server', self.fake_server.name), + ('changes_since', 'Invalid time value'), + ] + + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + ex = self.assertRaises( + exceptions.CommandError, + self.cmd.take_action, + parsed_args) + + self.assertIn( + 'Invalid changes-since value:', str(ex)) + mock_parse_isotime.assert_called_once_with( + 'Invalid time value' + ) + + def test_server_event_list_with_changes_since_pre_v258(self): + self.app.client_manager.compute.api_version = \ + api_versions.APIVersion('2.57') + + arglist = [ + '--changes-since', '2016-03-04T06:27:59Z', + self.fake_server.name, + ] + verifylist = [ + ('server', self.fake_server.name), + ('changes_since', '2016-03-04T06:27:59Z'), + ] + + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + ex = self.assertRaises( + exceptions.CommandError, + self.cmd.take_action, + parsed_args) + + self.assertIn( + '--os-compute-api-version 2.58 or greater is required', str(ex)) + + def test_server_event_list_with_changes_before(self): + self.app.client_manager.compute.api_version = \ + api_versions.APIVersion('2.66') + + arglist = [ + '--changes-before', '2016-03-04T06:27:59Z', + self.fake_server.name, + ] + verifylist = [ + ('server', self.fake_server.name), + ('changes_before', '2016-03-04T06:27:59Z'), + ] + + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + columns, data = self.cmd.take_action(parsed_args) + + self.servers_mock.get.assert_called_once_with(self.fake_server.name) + self.events_mock.list.assert_called_once_with( + self.fake_server.id, changes_before='2016-03-04T06:27:59Z') + + self.assertEqual(self.columns, columns) + self.assertEqual(tuple(self.data), tuple(data)) + + @mock.patch.object(iso8601, 'parse_date', side_effect=iso8601.ParseError) + def test_server_event_list_with_changes_before_invalid( + self, mock_parse_isotime, + ): + self.app.client_manager.compute.api_version = \ + api_versions.APIVersion('2.66') + + arglist = [ + '--changes-before', 'Invalid time value', + self.fake_server.name, + ] + verifylist = [ + ('server', self.fake_server.name), + ('changes_before', 'Invalid time value'), + ] + + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + ex = self.assertRaises( + exceptions.CommandError, + self.cmd.take_action, + parsed_args) + + self.assertIn( + 'Invalid changes-before value:', str(ex)) + mock_parse_isotime.assert_called_once_with( + 'Invalid time value' + ) + + def test_server_event_list_with_changes_before_pre_v266(self): + self.app.client_manager.compute.api_version = \ + api_versions.APIVersion('2.65') + + arglist = [ + '--changes-before', '2016-03-04T06:27:59Z', + self.fake_server.name, + ] + verifylist = [ + ('server', self.fake_server.name), + ('changes_before', '2016-03-04T06:27:59Z'), + ] + + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + ex = self.assertRaises( + exceptions.CommandError, + self.cmd.take_action, + parsed_args) + + self.assertIn( + '--os-compute-api-version 2.66 or greater is required', str(ex)) + + def test_server_event_list_with_limit(self): + self.app.client_manager.compute.api_version = \ + api_versions.APIVersion('2.58') + + arglist = [ + '--limit', '1', + self.fake_server.name, + ] + verifylist = [ + ('limit', 1), + ('server', self.fake_server.name), + ] + + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + self.cmd.take_action(parsed_args) + + self.events_mock.list.assert_called_once_with( + self.fake_server.id, limit=1) + + def test_server_event_list_with_limit_pre_v258(self): + self.app.client_manager.compute.api_version = \ + api_versions.APIVersion('2.57') + + arglist = [ + '--limit', '1', + self.fake_server.name, + ] + verifylist = [ + ('limit', 1), + ('server', self.fake_server.name), + ] + + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + ex = self.assertRaises( + exceptions.CommandError, + self.cmd.take_action, + parsed_args) + + self.assertIn( + '--os-compute-api-version 2.58 or greater is required', str(ex)) + + def test_server_event_list_with_marker(self): + self.app.client_manager.compute.api_version = \ + api_versions.APIVersion('2.58') + + arglist = [ + '--marker', 'test_event', + self.fake_server.name, + ] + verifylist = [ + ('marker', 'test_event'), + ('server', self.fake_server.name), + ] + + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + self.cmd.take_action(parsed_args) + + self.events_mock.list.assert_called_once_with( + self.fake_server.id, marker='test_event') + + def test_server_event_list_with_marker_pre_v258(self): + self.app.client_manager.compute.api_version = \ + api_versions.APIVersion('2.57') + + arglist = [ + '--marker', 'test_event', + self.fake_server.name, + ] + verifylist = [ + ('marker', 'test_event'), + ('server', self.fake_server.name), + ] + + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + ex = self.assertRaises( + exceptions.CommandError, + self.cmd.take_action, + parsed_args) + + self.assertIn( + '--os-compute-api-version 2.58 or greater is required', str(ex)) + class TestShowServerEvent(TestServerEvent): diff --git a/openstackclient/tests/unit/compute/v2/test_server_group.py b/openstackclient/tests/unit/compute/v2/test_server_group.py index bf0ea0ba..3ed19e27 100644 --- a/openstackclient/tests/unit/compute/v2/test_server_group.py +++ b/openstackclient/tests/unit/compute/v2/test_server_group.py @@ -16,6 +16,7 @@ from unittest import mock from novaclient import api_versions +from osc_lib.cli import format_columns from osc_lib import exceptions from osc_lib import utils @@ -39,9 +40,9 @@ class TestServerGroup(compute_fakes.TestComputev2): data = ( fake_server_group.id, - utils.format_list(fake_server_group.members), + format_columns.ListColumn(fake_server_group.members), fake_server_group.name, - utils.format_list(fake_server_group.policies), + format_columns.ListColumn(fake_server_group.policies), fake_server_group.project_id, fake_server_group.user_id, ) @@ -70,7 +71,7 @@ class TestServerGroupV264(TestServerGroup): data = ( fake_server_group.id, - utils.format_list(fake_server_group.members), + format_columns.ListColumn(fake_server_group.members), fake_server_group.name, fake_server_group.policy, fake_server_group.project_id, @@ -105,8 +106,8 @@ class TestServerGroupCreate(TestServerGroup): policies=[parsed_args.policy], ) - self.assertEqual(self.columns, columns) - self.assertEqual(self.data, data) + self.assertCountEqual(self.columns, columns) + self.assertCountEqual(self.data, data) def test_server_group_create_with_soft_policies(self): self.app.client_manager.compute.api_version = api_versions.APIVersion( @@ -127,8 +128,8 @@ class TestServerGroupCreate(TestServerGroup): policies=[parsed_args.policy], ) - self.assertEqual(self.columns, columns) - self.assertEqual(self.data, data) + self.assertCountEqual(self.columns, columns) + self.assertCountEqual(self.data, data) def test_server_group_create_with_soft_policies_pre_v215(self): self.app.client_manager.compute.api_version = api_versions.APIVersion( @@ -151,27 +152,54 @@ class TestServerGroupCreate(TestServerGroup): '--os-compute-api-version 2.15 or greater is required', str(ex)) - def test_server_group_create_v264(self): + def test_server_group_create_with_rules(self): self.app.client_manager.compute.api_version = api_versions.APIVersion( '2.64') arglist = [ '--policy', 'soft-anti-affinity', + '--rule', 'max_server_per_host=2', 'affinity_group', ] verifylist = [ ('policy', 'soft-anti-affinity'), + ('rules', {'max_server_per_host': '2'}), ('name', 'affinity_group'), ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) columns, data = self.cmd.take_action(parsed_args) self.server_groups_mock.create.assert_called_once_with( name=parsed_args.name, - policy=parsed_args.policy, + policy=parsed_args.policy, # should be 'policy', not 'policies' + rules=parsed_args.rules, ) - self.assertEqual(self.columns, columns) - self.assertEqual(self.data, data) + self.assertCountEqual(self.columns, columns) + self.assertCountEqual(self.data, data) + + def test_server_group_create_with_rules_pre_v264(self): + self.app.client_manager.compute.api_version = api_versions.APIVersion( + '2.63') + + arglist = [ + '--policy', 'soft-anti-affinity', + '--rule', 'max_server_per_host=2', + 'affinity_group', + ] + verifylist = [ + ('policy', 'soft-anti-affinity'), + ('rules', {'max_server_per_host': '2'}), + ('name', 'affinity_group'), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + ex = self.assertRaises( + exceptions.CommandError, + self.cmd.take_action, + parsed_args) + self.assertIn( + '--os-compute-api-version 2.64 or greater is required', + str(ex)) class TestServerGroupDelete(TestServerGroup): @@ -275,14 +303,14 @@ class TestServerGroupList(TestServerGroup): list_data = (( TestServerGroup.fake_server_group.id, TestServerGroup.fake_server_group.name, - utils.format_list(TestServerGroup.fake_server_group.policies), + format_columns.ListColumn(TestServerGroup.fake_server_group.policies), ),) list_data_long = (( TestServerGroup.fake_server_group.id, TestServerGroup.fake_server_group.name, - utils.format_list(TestServerGroup.fake_server_group.policies), - utils.format_list(TestServerGroup.fake_server_group.members), + format_columns.ListColumn(TestServerGroup.fake_server_group.policies), + format_columns.ListColumn(TestServerGroup.fake_server_group.members), TestServerGroup.fake_server_group.project_id, TestServerGroup.fake_server_group.user_id, ),) @@ -298,13 +326,16 @@ class TestServerGroupList(TestServerGroup): verifylist = [ ('all_projects', False), ('long', False), + ('limit', None), + ('offset', None), ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) columns, data = self.cmd.take_action(parsed_args) - self.server_groups_mock.list.assert_called_once_with(False) - self.assertEqual(self.list_columns, columns) - self.assertEqual(self.list_data, tuple(data)) + self.server_groups_mock.list.assert_called_once_with() + + self.assertCountEqual(self.list_columns, columns) + self.assertCountEqual(self.list_data, tuple(data)) def test_server_group_list_with_all_projects_and_long(self): arglist = [ @@ -314,13 +345,48 @@ class TestServerGroupList(TestServerGroup): verifylist = [ ('all_projects', True), ('long', True), + ('limit', None), + ('offset', None), ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) columns, data = self.cmd.take_action(parsed_args) - self.server_groups_mock.list.assert_called_once_with(True) + self.server_groups_mock.list.assert_called_once_with( + all_projects=True) + + self.assertCountEqual(self.list_columns_long, columns) + self.assertCountEqual(self.list_data_long, tuple(data)) + + def test_server_group_list_with_limit(self): + arglist = [ + '--limit', '1', + ] + verifylist = [ + ('all_projects', False), + ('long', False), + ('limit', 1), + ('offset', None), + ] + + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + self.cmd.take_action(parsed_args) + + self.server_groups_mock.list.assert_called_once_with(limit=1) + + def test_server_group_list_with_offset(self): + arglist = [ + '--offset', '5', + ] + verifylist = [ + ('all_projects', False), + ('long', False), + ('limit', None), + ('offset', 5), + ] + + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + self.cmd.take_action(parsed_args) - self.assertEqual(self.list_columns_long, columns) - self.assertEqual(self.list_data_long, tuple(data)) + self.server_groups_mock.list.assert_called_once_with(offset=5) class TestServerGroupListV264(TestServerGroupV264): @@ -350,7 +416,8 @@ class TestServerGroupListV264(TestServerGroupV264): TestServerGroupV264.fake_server_group.id, TestServerGroupV264.fake_server_group.name, TestServerGroupV264.fake_server_group.policy, - utils.format_list(TestServerGroupV264.fake_server_group.members), + format_columns.ListColumn( + TestServerGroupV264.fake_server_group.members), TestServerGroupV264.fake_server_group.project_id, TestServerGroupV264.fake_server_group.user_id, ),) @@ -371,10 +438,10 @@ class TestServerGroupListV264(TestServerGroupV264): ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) columns, data = self.cmd.take_action(parsed_args) - self.server_groups_mock.list.assert_called_once_with(False) + self.server_groups_mock.list.assert_called_once_with() - self.assertEqual(self.list_columns, columns) - self.assertEqual(self.list_data, tuple(data)) + self.assertCountEqual(self.list_columns, columns) + self.assertCountEqual(self.list_data, tuple(data)) def test_server_group_list_with_all_projects_and_long(self): arglist = [ @@ -387,10 +454,11 @@ class TestServerGroupListV264(TestServerGroupV264): ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) columns, data = self.cmd.take_action(parsed_args) - self.server_groups_mock.list.assert_called_once_with(True) + self.server_groups_mock.list.assert_called_once_with( + all_projects=True) - self.assertEqual(self.list_columns_long, columns) - self.assertEqual(self.list_data_long, tuple(data)) + self.assertCountEqual(self.list_columns_long, columns) + self.assertCountEqual(self.list_data_long, tuple(data)) class TestServerGroupShow(TestServerGroup): @@ -412,5 +480,5 @@ class TestServerGroupShow(TestServerGroup): parsed_args = self.check_parser(self.cmd, arglist, verifylist) columns, data = self.cmd.take_action(parsed_args) - self.assertEqual(self.columns, columns) - self.assertEqual(self.data, data) + self.assertCountEqual(self.columns, columns) + self.assertCountEqual(self.data, data) diff --git a/openstackclient/tests/unit/compute/v2/test_server_image.py b/openstackclient/tests/unit/compute/v2/test_server_image.py index 1cec5b68..66452a8b 100644 --- a/openstackclient/tests/unit/compute/v2/test_server_image.py +++ b/openstackclient/tests/unit/compute/v2/test_server_image.py @@ -130,10 +130,11 @@ class TestServerImageCreate(TestServerImage): self.servers_mock.create_image.assert_called_with( servers[0].id, servers[0].name, + None, ) self.assertEqual(self.image_columns(images[0]), columns) - self.assertItemEqual(self.image_data(images[0]), data) + self.assertItemsEqual(self.image_data(images[0]), data) def test_server_image_create_options(self): servers = self.setup_servers_mock(count=1) @@ -141,11 +142,13 @@ class TestServerImageCreate(TestServerImage): arglist = [ '--name', 'img-nam', + '--property', 'key=value', servers[0].id, ] verifylist = [ ('name', 'img-nam'), ('server', servers[0].id), + ('properties', {'key': 'value'}), ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) @@ -158,10 +161,11 @@ class TestServerImageCreate(TestServerImage): self.servers_mock.create_image.assert_called_with( servers[0].id, 'img-nam', + {'key': 'value'}, ) self.assertEqual(self.image_columns(images[0]), columns) - self.assertItemEqual(self.image_data(images[0]), data) + self.assertItemsEqual(self.image_data(images[0]), data) @mock.patch.object(common_utils, 'wait_for_status', return_value=False) def test_server_create_image_wait_fail(self, mock_wait_for_status): @@ -188,6 +192,7 @@ class TestServerImageCreate(TestServerImage): self.servers_mock.create_image.assert_called_with( servers[0].id, servers[0].name, + None, ) mock_wait_for_status.assert_called_once_with( @@ -220,6 +225,7 @@ class TestServerImageCreate(TestServerImage): self.servers_mock.create_image.assert_called_with( servers[0].id, servers[0].name, + None, ) mock_wait_for_status.assert_called_once_with( @@ -229,4 +235,4 @@ class TestServerImageCreate(TestServerImage): ) self.assertEqual(self.image_columns(images[0]), columns) - self.assertItemEqual(self.image_data(images[0]), data) + self.assertItemsEqual(self.image_data(images[0]), data) diff --git a/openstackclient/tests/unit/compute/v2/test_server_volume.py b/openstackclient/tests/unit/compute/v2/test_server_volume.py new file mode 100644 index 00000000..4d4916b7 --- /dev/null +++ b/openstackclient/tests/unit/compute/v2/test_server_volume.py @@ -0,0 +1,287 @@ +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. +# + +from novaclient import api_versions +from osc_lib import exceptions + +from openstackclient.compute.v2 import server_volume +from openstackclient.tests.unit.compute.v2 import fakes as compute_fakes + + +class TestServerVolume(compute_fakes.TestComputev2): + + def setUp(self): + super().setUp() + + # Get a shortcut to the compute client ServerManager Mock + self.servers_mock = self.app.client_manager.compute.servers + self.servers_mock.reset_mock() + + # Get a shortcut to the compute client VolumeManager mock + self.servers_volumes_mock = self.app.client_manager.compute.volumes + self.servers_volumes_mock.reset_mock() + + +class TestServerVolumeList(TestServerVolume): + + def setUp(self): + super().setUp() + + self.server = compute_fakes.FakeServer.create_one_server() + self.volume_attachments = ( + compute_fakes.FakeVolumeAttachment.create_volume_attachments()) + + self.servers_mock.get.return_value = self.server + self.servers_volumes_mock.get_server_volumes.return_value = ( + self.volume_attachments) + + # Get the command object to test + self.cmd = server_volume.ListServerVolume(self.app, None) + + def test_server_volume_list(self): + self.app.client_manager.compute.api_version = \ + api_versions.APIVersion('2.1') + + arglist = [ + self.server.id, + ] + verifylist = [ + ('server', self.server.id), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + columns, data = self.cmd.take_action(parsed_args) + + self.assertEqual(('ID', 'Device', 'Server ID', 'Volume ID'), columns) + self.assertEqual( + ( + ( + self.volume_attachments[0].id, + self.volume_attachments[0].device, + self.volume_attachments[0].serverId, + self.volume_attachments[0].volumeId, + ), + ( + self.volume_attachments[1].id, + self.volume_attachments[1].device, + self.volume_attachments[1].serverId, + self.volume_attachments[1].volumeId, + ), + ), + tuple(data), + ) + self.servers_volumes_mock.get_server_volumes.assert_called_once_with( + self.server.id) + + def test_server_volume_list_with_tags(self): + self.app.client_manager.compute.api_version = \ + api_versions.APIVersion('2.70') + + arglist = [ + self.server.id, + ] + verifylist = [ + ('server', self.server.id), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + columns, data = self.cmd.take_action(parsed_args) + + self.assertEqual( + ('ID', 'Device', 'Server ID', 'Volume ID', 'Tag',), columns, + ) + self.assertEqual( + ( + ( + self.volume_attachments[0].id, + self.volume_attachments[0].device, + self.volume_attachments[0].serverId, + self.volume_attachments[0].volumeId, + self.volume_attachments[0].tag, + ), + ( + self.volume_attachments[1].id, + self.volume_attachments[1].device, + self.volume_attachments[1].serverId, + self.volume_attachments[1].volumeId, + self.volume_attachments[1].tag, + ), + ), + tuple(data), + ) + self.servers_volumes_mock.get_server_volumes.assert_called_once_with( + self.server.id) + + def test_server_volume_list_with_delete_on_attachment(self): + self.app.client_manager.compute.api_version = \ + api_versions.APIVersion('2.79') + + arglist = [ + self.server.id, + ] + verifylist = [ + ('server', self.server.id), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + columns, data = self.cmd.take_action(parsed_args) + + self.assertEqual( + ( + 'ID', 'Device', 'Server ID', 'Volume ID', 'Tag', + 'Delete On Termination?', + ), + columns, + ) + self.assertEqual( + ( + ( + self.volume_attachments[0].id, + self.volume_attachments[0].device, + self.volume_attachments[0].serverId, + self.volume_attachments[0].volumeId, + self.volume_attachments[0].tag, + self.volume_attachments[0].delete_on_termination, + ), + ( + self.volume_attachments[1].id, + self.volume_attachments[1].device, + self.volume_attachments[1].serverId, + self.volume_attachments[1].volumeId, + self.volume_attachments[1].tag, + self.volume_attachments[1].delete_on_termination, + ), + ), + tuple(data), + ) + self.servers_volumes_mock.get_server_volumes.assert_called_once_with( + self.server.id) + + +class TestServerVolumeUpdate(TestServerVolume): + + def setUp(self): + super().setUp() + + self.server = compute_fakes.FakeServer.create_one_server() + self.servers_mock.get.return_value = self.server + + # Get the command object to test + self.cmd = server_volume.UpdateServerVolume(self.app, None) + + def test_server_volume_update(self): + + arglist = [ + self.server.id, + 'foo', + ] + verifylist = [ + ('server', self.server.id), + ('volume', 'foo'), + ('delete_on_termination', None), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + result = self.cmd.take_action(parsed_args) + + # This is a no-op + self.servers_volumes_mock.update_server_volume.assert_not_called() + self.assertIsNone(result) + + def test_server_volume_update_with_delete_on_termination(self): + self.app.client_manager.compute.api_version = \ + api_versions.APIVersion('2.85') + + arglist = [ + self.server.id, + 'foo', + '--delete-on-termination', + ] + verifylist = [ + ('server', self.server.id), + ('volume', 'foo'), + ('delete_on_termination', True), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + result = self.cmd.take_action(parsed_args) + + self.servers_volumes_mock.update_server_volume.assert_called_once_with( + self.server.id, 'foo', 'foo', + delete_on_termination=True) + self.assertIsNone(result) + + def test_server_volume_update_with_preserve_on_termination(self): + self.app.client_manager.compute.api_version = \ + api_versions.APIVersion('2.85') + + arglist = [ + self.server.id, + 'foo', + '--preserve-on-termination', + ] + verifylist = [ + ('server', self.server.id), + ('volume', 'foo'), + ('delete_on_termination', False), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + result = self.cmd.take_action(parsed_args) + + self.servers_volumes_mock.update_server_volume.assert_called_once_with( + self.server.id, 'foo', 'foo', + delete_on_termination=False) + self.assertIsNone(result) + + def test_server_volume_update_with_delete_on_termination_pre_v285(self): + self.app.client_manager.compute.api_version = \ + api_versions.APIVersion('2.84') + + arglist = [ + self.server.id, + 'foo', + '--delete-on-termination', + ] + verifylist = [ + ('server', self.server.id), + ('volume', 'foo'), + ('delete_on_termination', True), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + self.assertRaises( + exceptions.CommandError, + self.cmd.take_action, + parsed_args) + + def test_server_volume_update_with_preserve_on_termination_pre_v285(self): + self.app.client_manager.compute.api_version = \ + api_versions.APIVersion('2.84') + + arglist = [ + self.server.id, + 'foo', + '--preserve-on-termination', + ] + verifylist = [ + ('server', self.server.id), + ('volume', 'foo'), + ('delete_on_termination', False), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + self.assertRaises( + exceptions.CommandError, + self.cmd.take_action, + parsed_args) diff --git a/openstackclient/tests/unit/compute/v2/test_usage.py b/openstackclient/tests/unit/compute/v2/test_usage.py index c0871025..bbccb9bd 100644 --- a/openstackclient/tests/unit/compute/v2/test_usage.py +++ b/openstackclient/tests/unit/compute/v2/test_usage.py @@ -16,7 +16,7 @@ from unittest import mock from novaclient import api_versions -from openstackclient.compute.v2 import usage +from openstackclient.compute.v2 import usage as usage_cmds from openstackclient.tests.unit.compute.v2 import fakes as compute_fakes from openstackclient.tests.unit.identity.v3 import fakes as identity_fakes @@ -49,11 +49,11 @@ class TestUsageList(TestUsage): ) data = [( - usages[0].tenant_id, - len(usages[0].server_usages), - float("%.2f" % usages[0].total_memory_mb_usage), - float("%.2f" % usages[0].total_vcpus_usage), - float("%.2f" % usages[0].total_local_gb_usage), + usage_cmds.ProjectColumn(usages[0].tenant_id), + usage_cmds.CountColumn(usages[0].server_usages), + usage_cmds.FloatColumn(usages[0].total_memory_mb_usage), + usage_cmds.FloatColumn(usages[0].total_vcpus_usage), + usage_cmds.FloatColumn(usages[0].total_local_gb_usage), )] def setUp(self): @@ -63,7 +63,7 @@ class TestUsageList(TestUsage): self.projects_mock.list.return_value = [self.project] # Get the command object to test - self.cmd = usage.ListUsage(self.app, None) + self.cmd = usage_cmds.ListUsage(self.app, None) def test_usage_list_no_options(self): @@ -79,8 +79,8 @@ class TestUsageList(TestUsage): self.projects_mock.list.assert_called_with() - self.assertEqual(self.columns, columns) - self.assertEqual(tuple(self.data), tuple(data)) + self.assertCountEqual(self.columns, columns) + self.assertCountEqual(tuple(self.data), tuple(data)) def test_usage_list_with_options(self): arglist = [ @@ -102,8 +102,8 @@ class TestUsageList(TestUsage): datetime.datetime(2016, 12, 20, 0, 0), detailed=True) - self.assertEqual(self.columns, columns) - self.assertEqual(tuple(self.data), tuple(data)) + self.assertCountEqual(self.columns, columns) + self.assertCountEqual(tuple(self.data), tuple(data)) def test_usage_list_with_pagination(self): arglist = [] @@ -127,8 +127,8 @@ class TestUsageList(TestUsage): mock.call(mock.ANY, mock.ANY, detailed=True, marker=self.usages[0]['server_usages'][0]['instance_id']) ]) - self.assertEqual(self.columns, columns) - self.assertEqual(tuple(self.data), tuple(data)) + self.assertCountEqual(self.columns, columns) + self.assertCountEqual(tuple(self.data), tuple(data)) class TestUsageShow(TestUsage): @@ -139,17 +139,19 @@ class TestUsageShow(TestUsage): attrs={'tenant_id': project.name}) columns = ( + 'Project', + 'Servers', + 'RAM MB-Hours', 'CPU Hours', 'Disk GB-Hours', - 'RAM MB-Hours', - 'Servers', ) data = ( - float("%.2f" % usage.total_vcpus_usage), - float("%.2f" % usage.total_local_gb_usage), - float("%.2f" % usage.total_memory_mb_usage), - len(usage.server_usages), + usage_cmds.ProjectColumn(usage.tenant_id), + usage_cmds.CountColumn(usage.server_usages), + usage_cmds.FloatColumn(usage.total_memory_mb_usage), + usage_cmds.FloatColumn(usage.total_vcpus_usage), + usage_cmds.FloatColumn(usage.total_local_gb_usage), ) def setUp(self): @@ -159,7 +161,7 @@ class TestUsageShow(TestUsage): self.projects_mock.get.return_value = self.project # Get the command object to test - self.cmd = usage.ShowUsage(self.app, None) + self.cmd = usage_cmds.ShowUsage(self.app, None) def test_usage_show_no_options(self): diff --git a/openstackclient/tests/unit/identity/v2_0/test_catalog.py b/openstackclient/tests/unit/identity/v2_0/test_catalog.py index 17355074..e2c56ba1 100644 --- a/openstackclient/tests/unit/identity/v2_0/test_catalog.py +++ b/openstackclient/tests/unit/identity/v2_0/test_catalog.py @@ -71,9 +71,10 @@ class TestCatalogList(TestCatalog): datalist = (( 'supernova', 'compute', - catalog.EndpointsColumn(self.service_catalog['endpoints']), + catalog.EndpointsColumn( + auth_ref.service_catalog.catalog[0]['endpoints']), ), ) - self.assertListItemEqual(datalist, tuple(data)) + self.assertItemsEqual(datalist, tuple(data)) def test_catalog_list_with_endpoint_url(self): attr = { @@ -113,9 +114,10 @@ class TestCatalogList(TestCatalog): datalist = (( 'supernova', 'compute', - catalog.EndpointsColumn(service_catalog['endpoints']), + catalog.EndpointsColumn( + auth_ref.service_catalog.catalog[0]['endpoints']), ), ) - self.assertListItemEqual(datalist, tuple(data)) + self.assertItemsEqual(datalist, tuple(data)) class TestCatalogShow(TestCatalog): @@ -150,16 +152,17 @@ class TestCatalogShow(TestCatalog): collist = ('endpoints', 'id', 'name', 'type') self.assertEqual(collist, columns) datalist = ( - catalog.EndpointsColumn(self.service_catalog['endpoints']), + catalog.EndpointsColumn( + auth_ref.service_catalog.catalog[0]['endpoints']), self.service_catalog.id, 'supernova', 'compute', ) - self.assertItemEqual(datalist, data) + self.assertItemsEqual(datalist, data) class TestFormatColumns(TestCatalog): - def test_endpoints_column_human_readabale(self): + def test_endpoints_column_human_readable(self): col = catalog.EndpointsColumn(self.service_catalog['endpoints']) self.assertEqual( 'one\n publicURL: https://public.one.example.com\n ' diff --git a/openstackclient/tests/unit/identity/v2_0/test_project.py b/openstackclient/tests/unit/identity/v2_0/test_project.py index cd8c825d..766d5dab 100644 --- a/openstackclient/tests/unit/identity/v2_0/test_project.py +++ b/openstackclient/tests/unit/identity/v2_0/test_project.py @@ -643,7 +643,7 @@ class TestProjectShow(TestProject): self.fake_proj_show.name, format_columns.DictColumn({}), ) - self.assertItemEqual(datalist, data) + self.assertItemsEqual(datalist, data) class TestProjectUnset(TestProject): diff --git a/openstackclient/tests/unit/identity/v2_0/test_user.py b/openstackclient/tests/unit/identity/v2_0/test_user.py index 4308b05d..dd300478 100644 --- a/openstackclient/tests/unit/identity/v2_0/test_user.py +++ b/openstackclient/tests/unit/identity/v2_0/test_user.py @@ -482,7 +482,7 @@ class TestUserList(TestUser): self.users_mock.list.assert_called_with(tenant_id=None) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.datalist, tuple(data)) + self.assertItemsEqual(self.datalist, tuple(data)) def test_user_list_project(self): arglist = [ @@ -502,7 +502,7 @@ class TestUserList(TestUser): self.users_mock.list.assert_called_with(tenant_id=project_id) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.datalist, tuple(data)) + self.assertItemsEqual(self.datalist, tuple(data)) def test_user_list_long(self): arglist = [ @@ -531,7 +531,7 @@ class TestUserList(TestUser): self.fake_user_l.email, True, ), ) - self.assertListItemEqual(datalist, tuple(data)) + self.assertItemsEqual(datalist, tuple(data)) class TestUserSet(TestUser): @@ -819,4 +819,4 @@ class TestUserShow(TestUser): self.fake_user.name, self.fake_project.id, ) - self.assertItemEqual(datalist, data) + self.assertItemsEqual(datalist, data) diff --git a/openstackclient/tests/unit/identity/v3/test_catalog.py b/openstackclient/tests/unit/identity/v3/test_catalog.py index 3630ccb6..97ce48f6 100644 --- a/openstackclient/tests/unit/identity/v3/test_catalog.py +++ b/openstackclient/tests/unit/identity/v3/test_catalog.py @@ -91,9 +91,10 @@ class TestCatalogList(TestCatalog): datalist = (( 'supernova', 'compute', - catalog.EndpointsColumn(self.fake_service['endpoints']), + catalog.EndpointsColumn( + auth_ref.service_catalog.catalog[0]['endpoints']), ), ) - self.assertListItemEqual(datalist, tuple(data)) + self.assertItemsEqual(datalist, tuple(data)) class TestCatalogShow(TestCatalog): @@ -128,12 +129,13 @@ class TestCatalogShow(TestCatalog): collist = ('endpoints', 'id', 'name', 'type') self.assertEqual(collist, columns) datalist = ( - catalog.EndpointsColumn(self.fake_service['endpoints']), + catalog.EndpointsColumn( + auth_ref.service_catalog.catalog[0]['endpoints']), 'qwertyuiop', 'supernova', 'compute', ) - self.assertItemEqual(datalist, data) + self.assertItemsEqual(datalist, data) class TestFormatColumns(TestCatalog): diff --git a/openstackclient/tests/unit/identity/v3/test_domain.py b/openstackclient/tests/unit/identity/v3/test_domain.py index 46f389e8..c39f1bd3 100644 --- a/openstackclient/tests/unit/identity/v3/test_domain.py +++ b/openstackclient/tests/unit/identity/v3/test_domain.py @@ -293,6 +293,61 @@ class TestDomainList(TestDomain): ), ) self.assertEqual(datalist, tuple(data)) + def test_domain_list_with_option_name(self): + arglist = ['--name', + self.domain.name] + verifylist = [ + ('name', self.domain.name) + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + # In base command class Lister in cliff, abstract method take_action() + # returns a tuple containing the column names and an iterable + # containing the data to be listed. + columns, data = self.cmd.take_action(parsed_args) + + kwargs = { + 'name': self.domain.name + } + self.domains_mock.list.assert_called_with(**kwargs) + + collist = ('ID', 'Name', 'Enabled', 'Description') + self.assertEqual(collist, columns) + datalist = (( + self.domain.id, + self.domain.name, + True, + self.domain.description, + ), ) + self.assertEqual(datalist, tuple(data)) + + def test_domain_list_with_option_enabled(self): + arglist = ['--enabled'] + verifylist = [ + ('enabled', True) + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + # In base command class Lister in cliff, abstract method take_action() + # returns a tuple containing the column names and an iterable + # containing the data to be listed. + columns, data = self.cmd.take_action(parsed_args) + + kwargs = { + 'enabled': True + } + self.domains_mock.list.assert_called_with(**kwargs) + + collist = ('ID', 'Name', 'Enabled', 'Description') + self.assertEqual(collist, columns) + datalist = (( + self.domain.id, + self.domain.name, + True, + self.domain.description, + ), ) + self.assertEqual(datalist, tuple(data)) + class TestDomainSet(TestDomain): diff --git a/openstackclient/tests/unit/identity/v3/test_identity_provider.py b/openstackclient/tests/unit/identity/v3/test_identity_provider.py index a419a9bc..5aff2b1b 100644 --- a/openstackclient/tests/unit/identity/v3/test_identity_provider.py +++ b/openstackclient/tests/unit/identity/v3/test_identity_provider.py @@ -89,7 +89,7 @@ class TestIdentityProviderCreate(TestIdentityProvider): ) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.datalist, data) + self.assertItemsEqual(self.datalist, data) def test_create_identity_provider_description(self): arglist = [ @@ -117,7 +117,7 @@ class TestIdentityProviderCreate(TestIdentityProvider): ) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.datalist, data) + self.assertItemsEqual(self.datalist, data) def test_create_identity_provider_remote_id(self): arglist = [ @@ -145,7 +145,7 @@ class TestIdentityProviderCreate(TestIdentityProvider): ) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.datalist, data) + self.assertItemsEqual(self.datalist, data) def test_create_identity_provider_remote_ids_multiple(self): arglist = [ @@ -174,7 +174,7 @@ class TestIdentityProviderCreate(TestIdentityProvider): ) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.datalist, data) + self.assertItemsEqual(self.datalist, data) def test_create_identity_provider_remote_ids_file(self): arglist = [ @@ -207,7 +207,7 @@ class TestIdentityProviderCreate(TestIdentityProvider): ) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.datalist, data) + self.assertItemsEqual(self.datalist, data) def test_create_identity_provider_disabled(self): @@ -250,7 +250,7 @@ class TestIdentityProviderCreate(TestIdentityProvider): identity_fakes.idp_id, identity_fakes.formatted_idp_remote_ids ) - self.assertItemEqual(datalist, data) + self.assertItemsEqual(datalist, data) def test_create_identity_provider_domain_name(self): arglist = [ @@ -278,7 +278,7 @@ class TestIdentityProviderCreate(TestIdentityProvider): ) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.datalist, data) + self.assertItemsEqual(self.datalist, data) def test_create_identity_provider_domain_id(self): arglist = [ @@ -306,7 +306,7 @@ class TestIdentityProviderCreate(TestIdentityProvider): ) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.datalist, data) + self.assertItemsEqual(self.datalist, data) class TestIdentityProviderDelete(TestIdentityProvider): @@ -382,7 +382,62 @@ class TestIdentityProviderList(TestIdentityProvider): identity_fakes.domain_id, identity_fakes.idp_description, ), ) - self.assertListItemEqual(datalist, tuple(data)) + self.assertItemsEqual(datalist, tuple(data)) + + def test_identity_provider_list_ID_option(self): + arglist = ['--id', + identity_fakes.idp_id] + verifylist = [ + ('id', identity_fakes.idp_id) + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + # In base command class Lister in cliff, abstract method take_action() + # returns a tuple containing the column names and an iterable + # containing the data to be listed. + columns, data = self.cmd.take_action(parsed_args) + + kwargs = { + 'id': identity_fakes.idp_id + } + self.identity_providers_mock.list.assert_called_with(**kwargs) + + collist = ('ID', 'Enabled', 'Domain ID', 'Description') + self.assertEqual(collist, columns) + datalist = (( + identity_fakes.idp_id, + True, + identity_fakes.domain_id, + identity_fakes.idp_description, + ), ) + self.assertItemsEqual(datalist, tuple(data)) + + def test_identity_provider_list_enabled_option(self): + arglist = ['--enabled'] + verifylist = [ + ('enabled', True) + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + # In base command class Lister in cliff, abstract method take_action() + # returns a tuple containing the column names and an iterable + # containing the data to be listed. + columns, data = self.cmd.take_action(parsed_args) + + kwargs = { + 'enabled': True + } + self.identity_providers_mock.list.assert_called_with(**kwargs) + + collist = ('ID', 'Enabled', 'Domain ID', 'Description') + self.assertEqual(collist, columns) + datalist = (( + identity_fakes.idp_id, + True, + identity_fakes.domain_id, + identity_fakes.idp_description, + ), ) + self.assertItemsEqual(datalist, tuple(data)) class TestIdentityProviderSet(TestIdentityProvider): @@ -667,4 +722,4 @@ class TestIdentityProviderShow(TestIdentityProvider): identity_fakes.idp_id, identity_fakes.formatted_idp_remote_ids ) - self.assertItemEqual(datalist, data) + self.assertItemsEqual(datalist, data) diff --git a/openstackclient/tests/unit/image/v1/test_image.py b/openstackclient/tests/unit/image/v1/test_image.py index 2f190a7a..db64983c 100644 --- a/openstackclient/tests/unit/image/v1/test_image.py +++ b/openstackclient/tests/unit/image/v1/test_image.py @@ -100,7 +100,7 @@ class TestImageCreate(TestImage): self.assertEqual(self.client.update_image.call_args_list, []) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, data) + self.assertItemsEqual(self.data, data) @mock.patch('sys.stdin', side_effect=[None]) def test_image_reserve_options(self, raw_input): @@ -149,7 +149,7 @@ class TestImageCreate(TestImage): self.assertEqual(self.client.update_image.call_args_list, []) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, data) + self.assertItemsEqual(self.data, data) @mock.patch('openstackclient.image.v1.image.io.open', name='Open') def test_image_create_file(self, mock_open): @@ -205,7 +205,7 @@ class TestImageCreate(TestImage): self.assertEqual(self.client.update_image.call_args_list, []) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, data) + self.assertItemsEqual(self.data, data) class TestImageDelete(TestImage): @@ -386,7 +386,7 @@ class TestImageList(TestImage): format_columns.DictColumn( {'Alpha': 'a', 'Beta': 'b', 'Gamma': 'g'}), ), ) - self.assertListItemEqual(datalist, tuple(data)) + self.assertItemsEqual(datalist, tuple(data)) @mock.patch('osc_lib.api.utils.simple_filter') def test_image_list_property_option(self, sf_mock): @@ -737,7 +737,7 @@ class TestImageShow(TestImage): ) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, data) + self.assertItemsEqual(self.data, data) def test_image_show_human_readable(self): arglist = [ diff --git a/openstackclient/tests/unit/image/v2/test_image.py b/openstackclient/tests/unit/image/v2/test_image.py index b094817e..87dfdbea 100644 --- a/openstackclient/tests/unit/image/v2/test_image.py +++ b/openstackclient/tests/unit/image/v2/test_image.py @@ -111,7 +111,7 @@ class TestImageCreate(TestImage): self.assertEqual( self.expected_columns, columns) - self.assertItemEqual( + self.assertItemsEqual( self.expected_data, data) @@ -166,7 +166,7 @@ class TestImageCreate(TestImage): self.assertEqual( self.expected_columns, columns) - self.assertItemEqual( + self.assertItemsEqual( self.expected_data, data) @@ -255,7 +255,7 @@ class TestImageCreate(TestImage): self.assertEqual( self.expected_columns, columns) - self.assertItemEqual( + self.assertItemsEqual( self.expected_data, data) @@ -513,7 +513,7 @@ class TestImageList(TestImage): ) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.datalist, tuple(data)) + self.assertItemsEqual(self.datalist, tuple(data)) def test_image_list_public_option(self): arglist = [ @@ -537,7 +537,7 @@ class TestImageList(TestImage): ) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.datalist, tuple(data)) + self.assertItemsEqual(self.datalist, tuple(data)) def test_image_list_private_option(self): arglist = [ @@ -561,7 +561,7 @@ class TestImageList(TestImage): ) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.datalist, tuple(data)) + self.assertItemsEqual(self.datalist, tuple(data)) def test_image_list_community_option(self): arglist = [ @@ -609,7 +609,7 @@ class TestImageList(TestImage): ) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.datalist, tuple(data)) + self.assertItemsEqual(self.datalist, tuple(data)) def test_image_list_shared_member_status_option(self): arglist = [ @@ -697,7 +697,7 @@ class TestImageList(TestImage): self._image.owner_id, format_columns.ListColumn(self._image.tags), ), ) - self.assertListItemEqual(datalist, tuple(data)) + self.assertItemsEqual(datalist, tuple(data)) @mock.patch('osc_lib.api.utils.simple_filter') def test_image_list_property_option(self, sf_mock): @@ -725,7 +725,7 @@ class TestImageList(TestImage): ) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.datalist, tuple(data)) + self.assertItemsEqual(self.datalist, tuple(data)) @mock.patch('osc_lib.utils.sort_items') def test_image_list_sort_option(self, si_mock): @@ -747,7 +747,7 @@ class TestImageList(TestImage): str, ) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.datalist, tuple(data)) + self.assertItemsEqual(self.datalist, tuple(data)) def test_image_list_limit_option(self): ret_limit = 1 @@ -769,6 +769,21 @@ class TestImageList(TestImage): self.assertEqual(self.columns, columns) self.assertEqual(ret_limit, len(tuple(data))) + def test_image_list_project_option(self): + self.client.find_image = mock.Mock(return_value=self._image) + arglist = [ + '--project', 'nova', + ] + verifylist = [ + ('project', 'nova'), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + columns, data = self.cmd.take_action(parsed_args) + + self.assertEqual(self.columns, columns) + self.assertItemsEqual(self.datalist, tuple(data)) + @mock.patch('osc_lib.utils.find_resource') def test_image_list_marker_option(self, fr_mock): # tangchen: Since image_fakes.IMAGE is a dict, it cannot offer a .id @@ -1472,7 +1487,7 @@ class TestImageShow(TestImage): ) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, data) + self.assertItemsEqual(self.data, data) def test_image_show_human_readable(self): self.client.find_image.return_value = self.new_image @@ -1501,15 +1516,16 @@ class TestImageShow(TestImage): class TestImageUnset(TestImage): - attrs = {} - attrs['tags'] = ['test'] - attrs['prop'] = 'test' - attrs['prop2'] = 'fake' - image = image_fakes.FakeImage.create_one_image(attrs) - def setUp(self): super(TestImageUnset, self).setUp() + attrs = {} + attrs['tags'] = ['test'] + attrs['hw_rng_model'] = 'virtio' + attrs['prop'] = 'test' + attrs['prop2'] = 'fake' + self.image = image_fakes.FakeImage.create_one_image(attrs) + self.client.find_image.return_value = self.image self.client.remove_tag.return_value = self.image self.client.update_image.return_value = self.image @@ -1552,22 +1568,20 @@ class TestImageUnset(TestImage): def test_image_unset_property_option(self): arglist = [ + '--property', 'hw_rng_model', '--property', 'prop', self.image.id, ] verifylist = [ - ('properties', ['prop']), + ('properties', ['hw_rng_model', 'prop']), ('image', self.image.id) ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) result = self.cmd.take_action(parsed_args) - kwargs = {} self.client.update_image.assert_called_with( - self.image, - properties={'prop2': 'fake'}, - **kwargs) + self.image, properties={'prop2': 'fake'}) self.assertIsNone(result) @@ -1575,23 +1589,21 @@ class TestImageUnset(TestImage): arglist = [ '--tag', 'test', + '--property', 'hw_rng_model', '--property', 'prop', self.image.id, ] verifylist = [ ('tags', ['test']), - ('properties', ['prop']), + ('properties', ['hw_rng_model', 'prop']), ('image', self.image.id) ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) result = self.cmd.take_action(parsed_args) - kwargs = {} self.client.update_image.assert_called_with( - self.image, - properties={'prop2': 'fake'}, - **kwargs) + self.image, properties={'prop2': 'fake'}) self.client.remove_tag.assert_called_with( self.image.id, 'test' @@ -1618,7 +1630,7 @@ class TestImageSave(TestImage): verifylist = [ ('file', '/path/to/file'), - ('image', self.image.id) + ('image', self.image.id), ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) @@ -1626,6 +1638,7 @@ class TestImageSave(TestImage): self.client.download_image.assert_called_once_with( self.image.id, + stream=True, output='/path/to/file') diff --git a/openstackclient/tests/unit/network/v2/fakes.py b/openstackclient/tests/unit/network/v2/fakes.py index 2db83d3b..e5023d43 100644 --- a/openstackclient/tests/unit/network/v2/fakes.py +++ b/openstackclient/tests/unit/network/v2/fakes.py @@ -83,6 +83,79 @@ class TestNetworkV2(utils.TestCommand): ) +class FakeAddressGroup(object): + """Fake one or more address groups.""" + + @staticmethod + def create_one_address_group(attrs=None): + """Create a fake address group. + + :param Dictionary attrs: + A dictionary with all attributes + :return: + A FakeResource object with name, id, etc. + """ + attrs = attrs or {} + + # Set default attributes. + address_group_attrs = { + 'name': 'address-group-name-' + uuid.uuid4().hex, + 'description': 'address-group-description-' + uuid.uuid4().hex, + 'id': 'address-group-id-' + uuid.uuid4().hex, + 'tenant_id': 'project-id-' + uuid.uuid4().hex, + 'addresses': ['10.0.0.1/32'], + } + + # Overwrite default attributes. + address_group_attrs.update(attrs) + + address_group = fakes.FakeResource( + info=copy.deepcopy(address_group_attrs), + loaded=True) + + # Set attributes with special mapping in OpenStack SDK. + address_group.project_id = address_group_attrs['tenant_id'] + + return address_group + + @staticmethod + def create_address_groups(attrs=None, count=2): + """Create multiple fake address groups. + + :param Dictionary attrs: + A dictionary with all attributes + :param int count: + The number of address groups to fake + :return: + A list of FakeResource objects faking the address groups + """ + address_groups = [] + for i in range(0, count): + address_groups.append( + FakeAddressGroup.create_one_address_group(attrs)) + + return address_groups + + @staticmethod + def get_address_groups(address_groups=None, count=2): + """Get an iterable Mock object with a list of faked address groups. + + If address groups list is provided, then initialize the Mock object + with the list. Otherwise create one. + + :param List address_groups: + A list of FakeResource objects faking address groups + :param int count: + The number of address groups to fake + :return: + An iterable Mock object with side_effect set to a list of faked + address groups + """ + if address_groups is None: + address_groups = FakeAddressGroup.create_address_groups(count) + return mock.Mock(side_effect=address_groups) + + class FakeAddressScope(object): """Fake one or more address scopes.""" @@ -624,6 +697,7 @@ class FakePort(object): 'description': 'description-' + uuid.uuid4().hex, 'device_id': 'device-id-' + uuid.uuid4().hex, 'device_owner': 'compute:nova', + 'device_profile': 'cyborg_device_profile_1', 'dns_assignment': [{}], 'dns_domain': 'dns-domain-' + uuid.uuid4().hex, 'dns_name': 'dns-name-' + uuid.uuid4().hex, @@ -1309,6 +1383,7 @@ class FakeSecurityGroupRule(object): 'port_range_min': None, 'protocol': None, 'remote_group_id': None, + 'remote_address_group_id': None, 'remote_ip_prefix': '0.0.0.0/0', 'security_group_id': 'security-group-id-' + uuid.uuid4().hex, 'tenant_id': 'project-id-' + uuid.uuid4().hex, diff --git a/openstackclient/tests/unit/network/v2/test_address_group.py b/openstackclient/tests/unit/network/v2/test_address_group.py new file mode 100644 index 00000000..e4fa8ab3 --- /dev/null +++ b/openstackclient/tests/unit/network/v2/test_address_group.py @@ -0,0 +1,502 @@ +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. +# + +from unittest import mock +from unittest.mock import call + +from osc_lib import exceptions + +from openstackclient.network.v2 import address_group +from openstackclient.tests.unit.identity.v3 import fakes as identity_fakes_v3 +from openstackclient.tests.unit.network.v2 import fakes as network_fakes +from openstackclient.tests.unit import utils as tests_utils + + +class TestAddressGroup(network_fakes.TestNetworkV2): + + def setUp(self): + super(TestAddressGroup, self).setUp() + + # Get a shortcut to the network client + self.network = self.app.client_manager.network + # Get a shortcut to the ProjectManager Mock + self.projects_mock = self.app.client_manager.identity.projects + # Get a shortcut to the DomainManager Mock + self.domains_mock = self.app.client_manager.identity.domains + + +class TestCreateAddressGroup(TestAddressGroup): + + project = identity_fakes_v3.FakeProject.create_one_project() + domain = identity_fakes_v3.FakeDomain.create_one_domain() + # The new address group created. + new_address_group = ( + network_fakes.FakeAddressGroup.create_one_address_group( + attrs={ + 'tenant_id': project.id, + } + )) + columns = ( + 'addresses', + 'description', + 'id', + 'name', + 'project_id', + ) + data = ( + new_address_group.addresses, + new_address_group.description, + new_address_group.id, + new_address_group.name, + new_address_group.project_id, + ) + + def setUp(self): + super(TestCreateAddressGroup, self).setUp() + self.network.create_address_group = mock.Mock( + return_value=self.new_address_group) + + # Get the command object to test + self.cmd = address_group.CreateAddressGroup(self.app, self.namespace) + + self.projects_mock.get.return_value = self.project + self.domains_mock.get.return_value = self.domain + + def test_create_no_options(self): + arglist = [] + verifylist = [] + + # Missing required args should bail here + self.assertRaises(tests_utils.ParserException, self.check_parser, + self.cmd, arglist, verifylist) + + def test_create_default_options(self): + arglist = [ + self.new_address_group.name, + ] + verifylist = [ + ('project', None), + ('name', self.new_address_group.name), + ('description', None), + ('address', []), + ] + + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + columns, data = (self.cmd.take_action(parsed_args)) + + self.network.create_address_group.assert_called_once_with(**{ + 'name': self.new_address_group.name, + 'addresses': [], + }) + self.assertEqual(self.columns, columns) + self.assertItemsEqual(self.data, data) + + def test_create_all_options(self): + arglist = [ + '--project', self.project.name, + '--project-domain', self.domain.name, + '--address', '10.0.0.1', + '--description', self.new_address_group.description, + self.new_address_group.name, + ] + verifylist = [ + ('project', self.project.name), + ('project_domain', self.domain.name), + ('address', ['10.0.0.1']), + ('description', self.new_address_group.description), + ('name', self.new_address_group.name), + ] + + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + columns, data = (self.cmd.take_action(parsed_args)) + + self.network.create_address_group.assert_called_once_with(**{ + 'addresses': ['10.0.0.1/32'], + 'tenant_id': self.project.id, + 'name': self.new_address_group.name, + 'description': self.new_address_group.description, + }) + self.assertEqual(self.columns, columns) + self.assertItemsEqual(self.data, data) + + +class TestDeleteAddressGroup(TestAddressGroup): + + # The address group to delete. + _address_groups = ( + network_fakes.FakeAddressGroup.create_address_groups(count=2)) + + def setUp(self): + super(TestDeleteAddressGroup, self).setUp() + self.network.delete_address_group = mock.Mock(return_value=None) + self.network.find_address_group = ( + network_fakes.FakeAddressGroup.get_address_groups( + address_groups=self._address_groups) + ) + + # Get the command object to test + self.cmd = address_group.DeleteAddressGroup(self.app, self.namespace) + + def test_address_group_delete(self): + arglist = [ + self._address_groups[0].name, + ] + verifylist = [ + ('address_group', [self._address_groups[0].name]), + ] + + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + result = self.cmd.take_action(parsed_args) + self.network.find_address_group.assert_called_once_with( + self._address_groups[0].name, ignore_missing=False) + self.network.delete_address_group.assert_called_once_with( + self._address_groups[0]) + self.assertIsNone(result) + + def test_multi_address_groups_delete(self): + arglist = [] + + for a in self._address_groups: + arglist.append(a.name) + verifylist = [ + ('address_group', arglist), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + result = self.cmd.take_action(parsed_args) + + calls = [] + for a in self._address_groups: + calls.append(call(a)) + self.network.delete_address_group.assert_has_calls(calls) + self.assertIsNone(result) + + def test_multi_address_groups_delete_with_exception(self): + arglist = [ + self._address_groups[0].name, + 'unexist_address_group', + ] + verifylist = [ + ('address_group', + [self._address_groups[0].name, 'unexist_address_group']), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + find_mock_result = [self._address_groups[0], exceptions.CommandError] + self.network.find_address_group = ( + mock.Mock(side_effect=find_mock_result) + ) + + try: + self.cmd.take_action(parsed_args) + self.fail('CommandError should be raised.') + except exceptions.CommandError as e: + self.assertEqual('1 of 2 address groups failed to delete.', str(e)) + + self.network.find_address_group.assert_any_call( + self._address_groups[0].name, ignore_missing=False) + self.network.find_address_group.assert_any_call( + 'unexist_address_group', ignore_missing=False) + self.network.delete_address_group.assert_called_once_with( + self._address_groups[0] + ) + + +class TestListAddressGroup(TestAddressGroup): + + # The address groups to list up. + address_groups = ( + network_fakes.FakeAddressGroup.create_address_groups(count=3)) + columns = ( + 'ID', + 'Name', + 'Description', + 'Project', + 'Addresses', + ) + data = [] + for group in address_groups: + data.append(( + group.id, + group.name, + group.description, + group.project_id, + group.addresses, + )) + + def setUp(self): + super(TestListAddressGroup, self).setUp() + self.network.address_groups = mock.Mock( + return_value=self.address_groups) + + # Get the command object to test + self.cmd = address_group.ListAddressGroup(self.app, self.namespace) + + def test_address_group_list(self): + arglist = [] + verifylist = [] + + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + columns, data = self.cmd.take_action(parsed_args) + + self.network.address_groups.assert_called_once_with(**{}) + self.assertEqual(self.columns, columns) + self.assertItemsEqual(self.data, list(data)) + + def test_address_group_list_name(self): + arglist = [ + '--name', self.address_groups[0].name, + ] + verifylist = [ + ('name', self.address_groups[0].name), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + columns, data = self.cmd.take_action(parsed_args) + + self.network.address_groups.assert_called_once_with( + **{'name': self.address_groups[0].name}) + self.assertEqual(self.columns, columns) + self.assertItemsEqual(self.data, list(data)) + + def test_address_group_list_project(self): + project = identity_fakes_v3.FakeProject.create_one_project() + self.projects_mock.get.return_value = project + arglist = [ + '--project', project.id, + ] + verifylist = [ + ('project', project.id), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + columns, data = self.cmd.take_action(parsed_args) + + self.network.address_groups.assert_called_once_with( + project_id=project.id) + self.assertEqual(self.columns, columns) + self.assertItemsEqual(self.data, list(data)) + + def test_address_group_project_domain(self): + project = identity_fakes_v3.FakeProject.create_one_project() + self.projects_mock.get.return_value = project + arglist = [ + '--project', project.id, + '--project-domain', project.domain_id, + ] + verifylist = [ + ('project', project.id), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + columns, data = self.cmd.take_action(parsed_args) + + self.network.address_groups.assert_called_once_with( + project_id=project.id) + self.assertEqual(self.columns, columns) + self.assertItemsEqual(self.data, list(data)) + + +class TestSetAddressGroup(TestAddressGroup): + + # The address group to set. + _address_group = network_fakes.FakeAddressGroup.create_one_address_group() + + def setUp(self): + super(TestSetAddressGroup, self).setUp() + self.network.update_address_group = mock.Mock(return_value=None) + self.network.find_address_group = mock.Mock( + return_value=self._address_group) + self.network.add_addresses_to_address_group = mock.Mock( + return_value=self._address_group) + # Get the command object to test + self.cmd = address_group.SetAddressGroup(self.app, self.namespace) + + def test_set_nothing(self): + arglist = [self._address_group.name, ] + verifylist = [ + ('address_group', self._address_group.name), + ] + + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + result = self.cmd.take_action(parsed_args) + + self.network.update_address_group.assert_not_called() + self.network.add_addresses_to_address_group.assert_not_called() + self.assertIsNone(result) + + def test_set_name_and_description(self): + arglist = [ + '--name', 'new_address_group_name', + '--description', 'new_address_group_description', + self._address_group.name, + ] + verifylist = [ + ('name', 'new_address_group_name'), + ('description', 'new_address_group_description'), + ('address_group', self._address_group.name), + ] + + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + result = self.cmd.take_action(parsed_args) + attrs = { + 'name': "new_address_group_name", + 'description': 'new_address_group_description', + } + self.network.update_address_group.assert_called_with( + self._address_group, **attrs) + self.assertIsNone(result) + + def test_set_one_address(self): + arglist = [ + self._address_group.name, + '--address', '10.0.0.2', + ] + verifylist = [ + ('address_group', self._address_group.name), + ('address', ['10.0.0.2']), + ] + + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + result = self.cmd.take_action(parsed_args) + self.network.add_addresses_to_address_group.assert_called_once_with( + self._address_group, ['10.0.0.2/32']) + self.assertIsNone(result) + + def test_set_multiple_addresses(self): + arglist = [ + self._address_group.name, + '--address', '10.0.0.2', + '--address', '2001::/16', + ] + verifylist = [ + ('address_group', self._address_group.name), + ('address', ['10.0.0.2', '2001::/16']), + ] + + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + result = self.cmd.take_action(parsed_args) + self.network.add_addresses_to_address_group.assert_called_once_with( + self._address_group, ['10.0.0.2/32', '2001::/16']) + self.assertIsNone(result) + + +class TestShowAddressGroup(TestAddressGroup): + + # The address group to show. + _address_group = network_fakes.FakeAddressGroup.create_one_address_group() + columns = ( + 'addresses', + 'description', + 'id', + 'name', + 'project_id', + ) + data = ( + _address_group.addresses, + _address_group.description, + _address_group.id, + _address_group.name, + _address_group.project_id, + ) + + def setUp(self): + super(TestShowAddressGroup, self).setUp() + self.network.find_address_group = mock.Mock( + return_value=self._address_group) + + # Get the command object to test + self.cmd = address_group.ShowAddressGroup(self.app, self.namespace) + + def test_show_no_options(self): + arglist = [] + verifylist = [] + + # Missing required args should bail here + self.assertRaises(tests_utils.ParserException, self.check_parser, + self.cmd, arglist, verifylist) + + def test_show_all_options(self): + arglist = [ + self._address_group.name, + ] + verifylist = [ + ('address_group', self._address_group.name), + ] + + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + columns, data = self.cmd.take_action(parsed_args) + + self.network.find_address_group.assert_called_once_with( + self._address_group.name, ignore_missing=False) + self.assertEqual(self.columns, columns) + self.assertItemsEqual(self.data, list(data)) + + +class TestUnsetAddressGroup(TestAddressGroup): + + # The address group to unset. + _address_group = network_fakes.FakeAddressGroup.create_one_address_group() + + def setUp(self): + super(TestUnsetAddressGroup, self).setUp() + self.network.find_address_group = mock.Mock( + return_value=self._address_group) + self.network.remove_addresses_from_address_group = mock.Mock( + return_value=self._address_group) + # Get the command object to test + self.cmd = address_group.UnsetAddressGroup(self.app, self.namespace) + + def test_unset_nothing(self): + arglist = [self._address_group.name, ] + verifylist = [ + ('address_group', self._address_group.name), + ] + + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + result = self.cmd.take_action(parsed_args) + + self.network.remove_addresses_from_address_group.assert_not_called() + self.assertIsNone(result) + + def test_unset_one_address(self): + arglist = [ + self._address_group.name, + '--address', '10.0.0.2', + ] + verifylist = [ + ('address_group', self._address_group.name), + ('address', ['10.0.0.2']), + ] + + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + result = self.cmd.take_action(parsed_args) + self.network.remove_addresses_from_address_group.\ + assert_called_once_with(self._address_group, ['10.0.0.2/32']) + self.assertIsNone(result) + + def test_unset_multiple_addresses(self): + arglist = [ + self._address_group.name, + '--address', '10.0.0.2', + '--address', '2001::/16', + ] + verifylist = [ + ('address_group', self._address_group.name), + ('address', ['10.0.0.2', '2001::/16']), + ] + + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + result = self.cmd.take_action(parsed_args) + self.network.remove_addresses_from_address_group.\ + assert_called_once_with(self._address_group, + ['10.0.0.2/32', '2001::/16']) + self.assertIsNone(result) diff --git a/openstackclient/tests/unit/network/v2/test_ip_availability.py b/openstackclient/tests/unit/network/v2/test_ip_availability.py index 9a712704..ade57837 100644 --- a/openstackclient/tests/unit/network/v2/test_ip_availability.py +++ b/openstackclient/tests/unit/network/v2/test_ip_availability.py @@ -75,7 +75,7 @@ class TestListIPAvailability(TestIPAvailability): self.network.network_ip_availabilities.assert_called_once_with( **filters) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) def test_list_ip_version(self): arglist = [ @@ -93,7 +93,7 @@ class TestListIPAvailability(TestIPAvailability): self.network.network_ip_availabilities.assert_called_once_with( **filters) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) def test_list_project(self): arglist = [ @@ -113,7 +113,7 @@ class TestListIPAvailability(TestIPAvailability): self.network.network_ip_availabilities.assert_called_once_with( **filters) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) class TestShowIPAvailability(TestIPAvailability): @@ -176,4 +176,4 @@ class TestShowIPAvailability(TestIPAvailability): self._ip_availability.network_name, ignore_missing=False) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, data) + self.assertItemsEqual(self.data, data) diff --git a/openstackclient/tests/unit/network/v2/test_network.py b/openstackclient/tests/unit/network/v2/test_network.py index 5f8eed67..e29b72c7 100644 --- a/openstackclient/tests/unit/network/v2/test_network.py +++ b/openstackclient/tests/unit/network/v2/test_network.py @@ -146,7 +146,7 @@ class TestCreateNetworkIdentityV3(TestNetwork): }) self.assertFalse(self.network.set_tags.called) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, data) + self.assertItemsEqual(self.data, data) def test_create_all_options(self): arglist = [ @@ -211,7 +211,7 @@ class TestCreateNetworkIdentityV3(TestNetwork): 'dns_domain': 'example.org.', }) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, data) + self.assertItemsEqual(self.data, data) def test_create_other_options(self): arglist = [ @@ -238,7 +238,7 @@ class TestCreateNetworkIdentityV3(TestNetwork): 'port_security_enabled': False, }) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, data) + self.assertItemsEqual(self.data, data) def _test_create_with_tag(self, add_tags=True): arglist = [self._network.name] @@ -270,7 +270,7 @@ class TestCreateNetworkIdentityV3(TestNetwork): else: self.assertFalse(self.network.set_tags.called) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, data) + self.assertItemsEqual(self.data, data) def test_create_with_tags(self): self._test_create_with_tag(add_tags=True) @@ -385,7 +385,7 @@ class TestCreateNetworkIdentityV2(TestNetwork): }) self.assertFalse(self.network.set_tags.called) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, data) + self.assertItemsEqual(self.data, data) def test_create_with_domain_identityv2(self): arglist = [ @@ -577,7 +577,7 @@ class TestListNetwork(TestNetwork): self.network.networks.assert_called_once_with() self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) def test_list_external(self): arglist = [ @@ -598,7 +598,7 @@ class TestListNetwork(TestNetwork): **{'router:external': True, 'is_router_external': True} ) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) def test_list_internal(self): arglist = [ @@ -615,7 +615,7 @@ class TestListNetwork(TestNetwork): **{'router:external': False, 'is_router_external': False} ) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) def test_network_list_long(self): arglist = [ @@ -634,7 +634,7 @@ class TestListNetwork(TestNetwork): self.network.networks.assert_called_once_with() self.assertEqual(self.columns_long, columns) - self.assertListItemEqual(self.data_long, list(data)) + self.assertItemsEqual(self.data_long, list(data)) def test_list_name(self): test_name = "fakename" @@ -653,7 +653,7 @@ class TestListNetwork(TestNetwork): **{'name': test_name} ) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) def test_network_list_enable(self): arglist = [ @@ -671,7 +671,7 @@ class TestListNetwork(TestNetwork): **{'admin_state_up': True, 'is_admin_state_up': True} ) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) def test_network_list_disable(self): arglist = [ @@ -689,7 +689,7 @@ class TestListNetwork(TestNetwork): **{'admin_state_up': False, 'is_admin_state_up': False} ) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) def test_network_list_project(self): project = identity_fakes_v3.FakeProject.create_one_project() @@ -708,7 +708,7 @@ class TestListNetwork(TestNetwork): ) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) def test_network_list_project_domain(self): project = identity_fakes_v3.FakeProject.create_one_project() @@ -727,7 +727,7 @@ class TestListNetwork(TestNetwork): self.network.networks.assert_called_once_with(**filters) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) def test_network_list_share(self): arglist = [ @@ -744,7 +744,7 @@ class TestListNetwork(TestNetwork): **{'shared': True, 'is_shared': True} ) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) def test_network_list_no_share(self): arglist = [ @@ -761,7 +761,7 @@ class TestListNetwork(TestNetwork): **{'shared': False, 'is_shared': False} ) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) def test_network_list_status(self): choices = ['ACTIVE', 'BUILD', 'DOWN', 'ERROR'] @@ -780,7 +780,7 @@ class TestListNetwork(TestNetwork): **{'status': test_status} ) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) def test_network_list_provider_network_type(self): network_type = self._network[0].provider_network_type @@ -798,7 +798,7 @@ class TestListNetwork(TestNetwork): 'provider_network_type': network_type} ) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) def test_network_list_provider_physical_network(self): physical_network = self._network[0].provider_physical_network @@ -816,7 +816,7 @@ class TestListNetwork(TestNetwork): 'provider_physical_network': physical_network} ) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) def test_network_list_provider_segment(self): segmentation_id = self._network[0].provider_segmentation_id @@ -834,7 +834,7 @@ class TestListNetwork(TestNetwork): 'provider_segmentation_id': segmentation_id} ) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) def test_network_list_dhcp_agent(self): arglist = [ @@ -853,7 +853,7 @@ class TestListNetwork(TestNetwork): *attrs) self.assertEqual(self.columns, columns) - self.assertListItemEqual(list(data), list(self.data)) + self.assertItemsEqual(list(data), list(self.data)) def test_list_with_tag_options(self): arglist = [ @@ -878,7 +878,7 @@ class TestListNetwork(TestNetwork): 'not_any_tags': 'black,white'} ) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) class TestSetNetwork(TestNetwork): @@ -1111,7 +1111,7 @@ class TestShowNetwork(TestNetwork): self._network.name, ignore_missing=False) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, data) + self.assertItemsEqual(self.data, data) class TestUnsetNetwork(TestNetwork): diff --git a/openstackclient/tests/unit/network/v2/test_network_agent.py b/openstackclient/tests/unit/network/v2/test_network_agent.py index 3181ee78..fceac68e 100644 --- a/openstackclient/tests/unit/network/v2/test_network_agent.py +++ b/openstackclient/tests/unit/network/v2/test_network_agent.py @@ -246,7 +246,7 @@ class TestListNetworkAgent(TestNetworkAgent): self.network.agents.assert_called_once_with(**{}) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) def test_network_agents_list_agent_type(self): arglist = [ @@ -263,7 +263,7 @@ class TestListNetworkAgent(TestNetworkAgent): 'agent_type': 'DHCP agent', }) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) def test_network_agents_list_host(self): arglist = [ @@ -280,7 +280,7 @@ class TestListNetworkAgent(TestNetworkAgent): 'host': self.network_agents[0].host, }) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) def test_network_agents_list_networks(self): arglist = [ @@ -298,7 +298,7 @@ class TestListNetworkAgent(TestNetworkAgent): self.network.network_hosting_dhcp_agents.assert_called_once_with( *attrs) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) def test_network_agents_list_routers(self): arglist = [ @@ -318,7 +318,7 @@ class TestListNetworkAgent(TestNetworkAgent): *attrs) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) def test_network_agents_list_routers_with_long_option(self): arglist = [ @@ -343,7 +343,7 @@ class TestListNetworkAgent(TestNetworkAgent): router_agent_data = [d + ('',) for d in self.data] self.assertEqual(router_agent_columns, columns) - self.assertListItemEqual(router_agent_data, list(data)) + self.assertItemsEqual(router_agent_data, list(data)) class TestRemoveNetworkFromAgent(TestNetworkAgent): @@ -571,4 +571,4 @@ class TestShowNetworkAgent(TestNetworkAgent): self.network.get_agent.assert_called_once_with( self._network_agent.id) self.assertEqual(self.columns, columns) - self.assertItemEqual(list(self.data), list(data)) + self.assertItemsEqual(list(self.data), list(data)) diff --git a/openstackclient/tests/unit/network/v2/test_network_rbac.py b/openstackclient/tests/unit/network/v2/test_network_rbac.py index d7c71ea7..08be64c5 100644 --- a/openstackclient/tests/unit/network/v2/test_network_rbac.py +++ b/openstackclient/tests/unit/network/v2/test_network_rbac.py @@ -42,6 +42,7 @@ class TestCreateNetworkRBAC(TestNetworkRBAC): sg_object = network_fakes.FakeNetworkSecGroup.create_one_security_group() as_object = network_fakes.FakeAddressScope.create_one_address_scope() snp_object = network_fakes.FakeSubnetPool.create_one_subnet_pool() + ag_object = network_fakes.FakeAddressGroup.create_one_address_group() project = identity_fakes_v3.FakeProject.create_one_project() rbac_policy = network_fakes.FakeNetworkRBAC.create_one_network_rbac( attrs={'tenant_id': project.id, @@ -85,6 +86,8 @@ class TestCreateNetworkRBAC(TestNetworkRBAC): return_value=self.as_object) self.network.find_subnet_pool = mock.Mock( return_value=self.snp_object) + self.network.find_address_group = mock.Mock( + return_value=self.ag_object) self.projects_mock.get.return_value = self.project def test_network_rbac_create_no_type(self): @@ -236,7 +239,8 @@ class TestCreateNetworkRBAC(TestNetworkRBAC): ('qos_policy', "qos_object"), ('security_group', "sg_object"), ('subnetpool', "snp_object"), - ('address_scope', "as_object") + ('address_scope', "as_object"), + ('address_group', "ag_object") ) @ddt.unpack def test_network_rbac_create_object(self, obj_type, obj_fake_attr): diff --git a/openstackclient/tests/unit/network/v2/test_port.py b/openstackclient/tests/unit/network/v2/test_port.py index d8889ae5..8c5158d7 100644 --- a/openstackclient/tests/unit/network/v2/test_port.py +++ b/openstackclient/tests/unit/network/v2/test_port.py @@ -26,6 +26,10 @@ from openstackclient.tests.unit.network.v2 import fakes as network_fakes from openstackclient.tests.unit import utils as tests_utils +LIST_FIELDS_TO_RETRIEVE = ('id', 'name', 'mac_address', 'fixed_ips', 'status') +LIST_FIELDS_TO_RETRIEVE_LONG = ('security_group_ids', 'device_owner', 'tags') + + class TestPort(network_fakes.TestNetworkV2): def setUp(self): @@ -50,6 +54,7 @@ class TestPort(network_fakes.TestNetworkV2): 'description', 'device_id', 'device_owner', + 'device_profile', 'dns_assignment', 'dns_domain', 'dns_name', @@ -82,6 +87,7 @@ class TestPort(network_fakes.TestNetworkV2): fake_port.description, fake_port.device_id, fake_port.device_owner, + fake_port.device_profile, format_columns.ListDictColumn(fake_port.dns_assignment), fake_port.dns_domain, fake_port.dns_name, @@ -147,7 +153,7 @@ class TestCreatePort(TestPort): self.assertFalse(self.network.set_tags.called) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, data) + self.assertItemsEqual(self.data, data) def test_create_full_options(self): arglist = [ @@ -205,7 +211,7 @@ class TestCreatePort(TestPort): }) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, data) + self.assertItemsEqual(self.data, data) def test_create_invalid_json_binding_profile(self): arglist = [ @@ -256,7 +262,7 @@ class TestCreatePort(TestPort): }) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, data) + self.assertItemsEqual(self.data, data) def test_create_with_security_group(self): secgroup = network_fakes.FakeSecurityGroup.create_one_security_group() @@ -285,7 +291,7 @@ class TestCreatePort(TestPort): }) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, data) + self.assertItemsEqual(self.data, data) def test_create_port_with_dns_name(self): arglist = [ @@ -311,7 +317,7 @@ class TestCreatePort(TestPort): }) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, data) + self.assertItemsEqual(self.data, data) def test_create_with_security_groups(self): sg_1 = network_fakes.FakeSecurityGroup.create_one_security_group() @@ -341,7 +347,7 @@ class TestCreatePort(TestPort): }) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, data) + self.assertItemsEqual(self.data, data) def test_create_with_no_security_groups(self): arglist = [ @@ -367,7 +373,7 @@ class TestCreatePort(TestPort): }) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, data) + self.assertItemsEqual(self.data, data) def test_create_with_no_fixed_ips(self): arglist = [ @@ -393,7 +399,7 @@ class TestCreatePort(TestPort): }) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, data) + self.assertItemsEqual(self.data, data) def test_create_port_with_allowed_address_pair_ipaddr(self): pairs = [{'ip_address': '192.168.1.123'}, @@ -423,7 +429,7 @@ class TestCreatePort(TestPort): }) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, data) + self.assertItemsEqual(self.data, data) def test_create_port_with_allowed_address_pair(self): pairs = [{'ip_address': '192.168.1.123', @@ -459,7 +465,7 @@ class TestCreatePort(TestPort): }) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, data) + self.assertItemsEqual(self.data, data) def test_create_port_with_qos(self): qos_policy = network_fakes.FakeNetworkQosPolicy.create_one_qos_policy() @@ -487,7 +493,7 @@ class TestCreatePort(TestPort): }) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, data) + self.assertItemsEqual(self.data, data) def test_create_port_security_enabled(self): arglist = [ @@ -596,7 +602,7 @@ class TestCreatePort(TestPort): self.assertFalse(self.network.set_tags.called) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, data) + self.assertItemsEqual(self.data, data) def test_create_with_tags(self): self._test_create_with_tag(add_tags=True, add_tags_in_post=True) @@ -639,7 +645,7 @@ class TestCreatePort(TestPort): }) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, data) + self.assertItemsEqual(self.data, data) def test_create_with_uplink_status_propagation_enabled(self): self._test_create_with_uplink_status_propagation(enable=True) @@ -719,7 +725,7 @@ class TestCreatePort(TestPort): self.network.create_port.assert_called_once_with(**create_args) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, data) + self.assertItemsEqual(self.data, data) def test_create_with_numa_affinity_policy_required(self): self._test_create_with_numa_affinity_policy(policy='required') @@ -733,6 +739,33 @@ class TestCreatePort(TestPort): def test_create_with_numa_affinity_policy_null(self): self._test_create_with_numa_affinity_policy() + def test_create_with_device_profile(self): + arglist = [ + '--network', self._port.network_id, + '--device-profile', 'cyborg_device_profile_1', + 'test-port', + ] + + verifylist = [ + ('network', self._port.network_id,), + ('device_profile', self._port.device_profile,), + ('name', 'test-port'), + ] + + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + columns, data = (self.cmd.take_action(parsed_args)) + + create_args = { + 'admin_state_up': True, + 'network_id': self._port.network_id, + 'name': 'test-port', + 'device_profile': 'cyborg_device_profile_1', + } + self.network.create_port.assert_called_once_with(**create_args) + self.assertEqual(self.columns, columns) + self.assertItemsEqual(self.data, data) + class TestDeletePort(TestPort): @@ -883,9 +916,10 @@ class TestListPort(TestPort): columns, data = self.cmd.take_action(parsed_args) - self.network.ports.assert_called_once_with() + self.network.ports.assert_called_once_with( + fields=LIST_FIELDS_TO_RETRIEVE) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) def test_port_list_router_opt(self): arglist = [ @@ -901,10 +935,11 @@ class TestListPort(TestPort): columns, data = self.cmd.take_action(parsed_args) self.network.ports.assert_called_once_with(**{ - 'device_id': 'fake-router-id' + 'device_id': 'fake-router-id', + 'fields': LIST_FIELDS_TO_RETRIEVE, }) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) @mock.patch.object(utils, 'find_resource') def test_port_list_with_server_option(self, mock_find): @@ -921,10 +956,11 @@ class TestListPort(TestPort): parsed_args = self.check_parser(self.cmd, arglist, verifylist) columns, data = self.cmd.take_action(parsed_args) self.network.ports.assert_called_once_with( - device_id=fake_server.id) + device_id=fake_server.id, + fields=LIST_FIELDS_TO_RETRIEVE) mock_find.assert_called_once_with(mock.ANY, 'fake-server-name') self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) def test_port_list_device_id_opt(self): arglist = [ @@ -940,10 +976,11 @@ class TestListPort(TestPort): columns, data = self.cmd.take_action(parsed_args) self.network.ports.assert_called_once_with(**{ - 'device_id': self._ports[0].device_id + 'device_id': self._ports[0].device_id, + 'fields': LIST_FIELDS_TO_RETRIEVE, }) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) def test_port_list_device_owner_opt(self): arglist = [ @@ -959,10 +996,11 @@ class TestListPort(TestPort): columns, data = self.cmd.take_action(parsed_args) self.network.ports.assert_called_once_with(**{ - 'device_owner': self._ports[0].device_owner + 'device_owner': self._ports[0].device_owner, + 'fields': LIST_FIELDS_TO_RETRIEVE, }) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) def test_port_list_all_opt(self): arglist = [ @@ -987,10 +1025,11 @@ class TestListPort(TestPort): 'device_owner': self._ports[0].device_owner, 'device_id': 'fake-router-id', 'network_id': 'fake-network-id', - 'mac_address': self._ports[0].mac_address + 'mac_address': self._ports[0].mac_address, + 'fields': LIST_FIELDS_TO_RETRIEVE, }) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) def test_port_list_mac_address_opt(self): arglist = [ @@ -1006,10 +1045,11 @@ class TestListPort(TestPort): columns, data = self.cmd.take_action(parsed_args) self.network.ports.assert_called_once_with(**{ - 'mac_address': self._ports[0].mac_address + 'mac_address': self._ports[0].mac_address, + 'fields': LIST_FIELDS_TO_RETRIEVE, }) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) def test_port_list_fixed_ip_opt_ip_address(self): ip_address = self._ports[0].fixed_ips[0]['ip_address'] @@ -1025,9 +1065,11 @@ class TestListPort(TestPort): columns, data = self.cmd.take_action(parsed_args) self.network.ports.assert_called_once_with(**{ - 'fixed_ips': ['ip_address=%s' % ip_address]}) + 'fixed_ips': ['ip_address=%s' % ip_address], + 'fields': LIST_FIELDS_TO_RETRIEVE, + }) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) def test_port_list_fixed_ip_opt_ip_address_substr(self): ip_address_ss = self._ports[0].fixed_ips[0]['ip_address'][:-1] @@ -1043,9 +1085,11 @@ class TestListPort(TestPort): columns, data = self.cmd.take_action(parsed_args) self.network.ports.assert_called_once_with(**{ - 'fixed_ips': ['ip_address_substr=%s' % ip_address_ss]}) + 'fixed_ips': ['ip_address_substr=%s' % ip_address_ss], + 'fields': LIST_FIELDS_TO_RETRIEVE, + }) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) def test_port_list_fixed_ip_opt_subnet_id(self): subnet_id = self._ports[0].fixed_ips[0]['subnet_id'] @@ -1063,9 +1107,11 @@ class TestListPort(TestPort): columns, data = self.cmd.take_action(parsed_args) self.network.ports.assert_called_once_with(**{ - 'fixed_ips': ['subnet_id=%s' % subnet_id]}) + 'fixed_ips': ['subnet_id=%s' % subnet_id], + 'fields': LIST_FIELDS_TO_RETRIEVE, + }) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) def test_port_list_fixed_ip_opts(self): subnet_id = self._ports[0].fixed_ips[0]['subnet_id'] @@ -1087,9 +1133,11 @@ class TestListPort(TestPort): self.network.ports.assert_called_once_with(**{ 'fixed_ips': ['subnet_id=%s' % subnet_id, - 'ip_address=%s' % ip_address]}) + 'ip_address=%s' % ip_address], + 'fields': LIST_FIELDS_TO_RETRIEVE, + }) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) def test_port_list_fixed_ips(self): subnet_id = self._ports[0].fixed_ips[0]['subnet_id'] @@ -1103,17 +1151,21 @@ class TestListPort(TestPort): {'ip-address': ip_address}]) ] - self.fake_subnet = network_fakes.FakeSubnet.create_one_subnet( - {'id': subnet_id}) + self.fake_subnet = network_fakes.FakeSubnet.create_one_subnet({ + 'id': subnet_id, + 'fields': LIST_FIELDS_TO_RETRIEVE, + }) self.network.find_subnet = mock.Mock(return_value=self.fake_subnet) parsed_args = self.check_parser(self.cmd, arglist, verifylist) columns, data = self.cmd.take_action(parsed_args) self.network.ports.assert_called_once_with(**{ 'fixed_ips': ['subnet_id=%s' % subnet_id, - 'ip_address=%s' % ip_address]}) + 'ip_address=%s' % ip_address], + 'fields': LIST_FIELDS_TO_RETRIEVE, + }) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) def test_list_port_with_long(self): arglist = [ @@ -1128,9 +1180,10 @@ class TestListPort(TestPort): columns, data = self.cmd.take_action(parsed_args) - self.network.ports.assert_called_once_with() + self.network.ports.assert_called_once_with( + fields=LIST_FIELDS_TO_RETRIEVE + LIST_FIELDS_TO_RETRIEVE_LONG) self.assertEqual(self.columns_long, columns) - self.assertListItemEqual(self.data_long, list(data)) + self.assertItemsEqual(self.data_long, list(data)) def test_port_list_host(self): arglist = [ @@ -1142,11 +1195,14 @@ class TestListPort(TestPort): parsed_args = self.check_parser(self.cmd, arglist, verifylist) columns, data = self.cmd.take_action(parsed_args) - filters = {'binding:host_id': 'foobar'} + filters = { + 'binding:host_id': 'foobar', + 'fields': LIST_FIELDS_TO_RETRIEVE, + } self.network.ports.assert_called_once_with(**filters) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) def test_port_list_project(self): project = identity_fakes.FakeProject.create_one_project() @@ -1160,11 +1216,15 @@ class TestListPort(TestPort): parsed_args = self.check_parser(self.cmd, arglist, verifylist) columns, data = self.cmd.take_action(parsed_args) - filters = {'tenant_id': project.id, 'project_id': project.id} + filters = { + 'tenant_id': project.id, + 'project_id': project.id, + 'fields': LIST_FIELDS_TO_RETRIEVE, + } self.network.ports.assert_called_once_with(**filters) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) def test_port_list_project_domain(self): project = identity_fakes.FakeProject.create_one_project() @@ -1180,11 +1240,35 @@ class TestListPort(TestPort): parsed_args = self.check_parser(self.cmd, arglist, verifylist) columns, data = self.cmd.take_action(parsed_args) - filters = {'tenant_id': project.id, 'project_id': project.id} + filters = { + 'tenant_id': project.id, + 'project_id': project.id, + 'fields': LIST_FIELDS_TO_RETRIEVE, + } + + self.network.ports.assert_called_once_with(**filters) + self.assertEqual(self.columns, columns) + self.assertItemsEqual(self.data, list(data)) + + def test_port_list_name(self): + test_name = "fakename" + arglist = [ + '--name', test_name, + ] + verifylist = [ + ('name', test_name), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + columns, data = self.cmd.take_action(parsed_args) + filters = { + 'name': test_name, + 'fields': LIST_FIELDS_TO_RETRIEVE, + } self.network.ports.assert_called_once_with(**filters) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) def test_list_with_tag_options(self): arglist = [ @@ -1206,10 +1290,11 @@ class TestListPort(TestPort): **{'tags': 'red,blue', 'any_tags': 'red,green', 'not_tags': 'orange,yellow', - 'not_any_tags': 'black,white'} + 'not_any_tags': 'black,white', + 'fields': LIST_FIELDS_TO_RETRIEVE} ) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) class TestSetPort(TestPort): @@ -1809,7 +1894,7 @@ class TestShowPort(TestPort): self._port.name, ignore_missing=False) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, data) + self.assertItemsEqual(self.data, data) class TestUnsetPort(TestPort): diff --git a/openstackclient/tests/unit/network/v2/test_router.py b/openstackclient/tests/unit/network/v2/test_router.py index 09b4957c..323c9198 100644 --- a/openstackclient/tests/unit/network/v2/test_router.py +++ b/openstackclient/tests/unit/network/v2/test_router.py @@ -184,7 +184,7 @@ class TestCreateRouter(TestRouter): }) self.assertFalse(self.network.set_tags.called) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, data) + self.assertItemsEqual(self.data, data) def _test_create_with_ha_options(self, option, ha): arglist = [ @@ -208,7 +208,7 @@ class TestCreateRouter(TestRouter): 'ha': ha, }) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, data) + self.assertItemsEqual(self.data, data) def test_create_with_ha_option(self): self._test_create_with_ha_options('--ha', True) @@ -237,7 +237,7 @@ class TestCreateRouter(TestRouter): 'distributed': distributed, }) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, data) + self.assertItemsEqual(self.data, data) def test_create_with_distributed_option(self): self._test_create_with_distributed_options('--distributed', True) @@ -268,7 +268,7 @@ class TestCreateRouter(TestRouter): }) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, data) + self.assertItemsEqual(self.data, data) def _test_create_with_tag(self, add_tags=True): arglist = [self.new_router.name] @@ -301,7 +301,7 @@ class TestCreateRouter(TestRouter): else: self.assertFalse(self.network.set_tags.called) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, data) + self.assertItemsEqual(self.data, data) def test_create_with_tags(self): self._test_create_with_tag(add_tags=True) @@ -494,7 +494,7 @@ class TestListRouter(TestRouter): self.network.routers.assert_called_once_with() self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) def test_router_list_no_ha_no_distributed(self): _routers = network_fakes.FakeRouter.create_routers({ @@ -531,7 +531,7 @@ class TestListRouter(TestRouter): self.network.routers.assert_called_once_with() self.assertEqual(self.columns_long, columns) - self.assertListItemEqual(self.data_long, list(data)) + self.assertItemsEqual(self.data_long, list(data)) def test_router_list_long_no_az(self): arglist = [ @@ -552,7 +552,7 @@ class TestListRouter(TestRouter): self.network.routers.assert_called_once_with() self.assertEqual(self.columns_long_no_az, columns) - self.assertListItemEqual(self.data_long_no_az, list(data)) + self.assertItemsEqual(self.data_long_no_az, list(data)) def test_list_name(self): test_name = "fakename" @@ -570,7 +570,7 @@ class TestListRouter(TestRouter): **{'name': test_name} ) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) def test_router_list_enable(self): arglist = [ @@ -587,7 +587,7 @@ class TestListRouter(TestRouter): **{'admin_state_up': True, 'is_admin_state_up': True} ) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) def test_router_list_disable(self): arglist = [ @@ -605,7 +605,7 @@ class TestListRouter(TestRouter): ) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) def test_router_list_project(self): project = identity_fakes_v3.FakeProject.create_one_project() @@ -623,7 +623,7 @@ class TestListRouter(TestRouter): self.network.routers.assert_called_once_with(**filters) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) def test_router_list_project_domain(self): project = identity_fakes_v3.FakeProject.create_one_project() @@ -643,7 +643,7 @@ class TestListRouter(TestRouter): self.network.routers.assert_called_once_with(**filters) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) def test_router_list_agents_no_args(self): arglist = [ @@ -671,7 +671,7 @@ class TestListRouter(TestRouter): self.network.agent_hosted_routers( *attrs) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) def test_list_with_tag_options(self): arglist = [ @@ -696,7 +696,7 @@ class TestListRouter(TestRouter): 'not_any_tags': 'black,white'} ) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) class TestRemovePortFromRouter(TestRouter): @@ -1403,7 +1403,7 @@ class TestShowRouter(TestRouter): 'device_id': self._router.id }) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, data) + self.assertItemsEqual(self.data, data) def test_show_no_ha_no_distributed(self): _router = network_fakes.FakeRouter.create_one_router({ diff --git a/openstackclient/tests/unit/network/v2/test_security_group_compute.py b/openstackclient/tests/unit/network/v2/test_security_group_compute.py index b4ddcf80..837c9b21 100644 --- a/openstackclient/tests/unit/network/v2/test_security_group_compute.py +++ b/openstackclient/tests/unit/network/v2/test_security_group_compute.py @@ -88,7 +88,7 @@ class TestCreateSecurityGroupCompute(TestSecurityGroupCompute): self._security_group['name'], ) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, data) + self.assertItemsEqual(self.data, data) def test_security_group_create_all_options(self, sg_mock): sg_mock.return_value = self._security_group @@ -109,7 +109,7 @@ class TestCreateSecurityGroupCompute(TestSecurityGroupCompute): self._security_group['description'], ) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, data) + self.assertItemsEqual(self.data, data) @mock.patch( @@ -255,7 +255,7 @@ class TestListSecurityGroupCompute(TestSecurityGroupCompute): kwargs = {'search_opts': {'all_tenants': False}} sg_mock.assert_called_once_with(**kwargs) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) def test_security_group_list_all_projects(self, sg_mock): sg_mock.return_value = self._security_groups @@ -272,7 +272,7 @@ class TestListSecurityGroupCompute(TestSecurityGroupCompute): kwargs = {'search_opts': {'all_tenants': True}} sg_mock.assert_called_once_with(**kwargs) self.assertEqual(self.columns_all_projects, columns) - self.assertListItemEqual(self.data_all_projects, list(data)) + self.assertItemsEqual(self.data_all_projects, list(data)) @mock.patch( @@ -401,4 +401,4 @@ class TestShowSecurityGroupCompute(TestSecurityGroupCompute): sg_mock.assert_called_once_with(self._security_group['id']) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, data) + self.assertItemsEqual(self.data, data) diff --git a/openstackclient/tests/unit/network/v2/test_security_group_network.py b/openstackclient/tests/unit/network/v2/test_security_group_network.py index 7c1d7fb6..fe377785 100644 --- a/openstackclient/tests/unit/network/v2/test_security_group_network.py +++ b/openstackclient/tests/unit/network/v2/test_security_group_network.py @@ -96,7 +96,7 @@ class TestCreateSecurityGroupNetwork(TestSecurityGroupNetwork): 'name': self._security_group.name, }) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, data) + self.assertItemsEqual(self.data, data) def test_create_all_options(self): arglist = [ @@ -124,7 +124,7 @@ class TestCreateSecurityGroupNetwork(TestSecurityGroupNetwork): 'tenant_id': self.project.id, }) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, data) + self.assertItemsEqual(self.data, data) def _test_create_with_tag(self, add_tags=True): arglist = [self._security_group.name] @@ -155,7 +155,7 @@ class TestCreateSecurityGroupNetwork(TestSecurityGroupNetwork): else: self.assertFalse(self.network.set_tags.called) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, data) + self.assertItemsEqual(self.data, data) def test_create_with_tags(self): self._test_create_with_tag(add_tags=True) @@ -293,7 +293,7 @@ class TestListSecurityGroupNetwork(TestSecurityGroupNetwork): self.network.security_groups.assert_called_once_with( fields=security_group.ListSecurityGroup.FIELDS_TO_RETRIEVE) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) def test_security_group_list_all_projects(self): arglist = [ @@ -309,7 +309,7 @@ class TestListSecurityGroupNetwork(TestSecurityGroupNetwork): self.network.security_groups.assert_called_once_with( fields=security_group.ListSecurityGroup.FIELDS_TO_RETRIEVE) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) def test_security_group_list_project(self): project = identity_fakes.FakeProject.create_one_project() @@ -329,7 +329,7 @@ class TestListSecurityGroupNetwork(TestSecurityGroupNetwork): self.network.security_groups.assert_called_once_with(**filters) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) def test_security_group_list_project_domain(self): project = identity_fakes.FakeProject.create_one_project() @@ -351,7 +351,7 @@ class TestListSecurityGroupNetwork(TestSecurityGroupNetwork): self.network.security_groups.assert_called_once_with(**filters) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) def test_list_with_tag_options(self): arglist = [ @@ -539,7 +539,7 @@ class TestShowSecurityGroupNetwork(TestSecurityGroupNetwork): self.network.find_security_group.assert_called_once_with( self._security_group.id, ignore_missing=False) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, data) + self.assertItemsEqual(self.data, data) class TestUnsetSecurityGroupNetwork(TestSecurityGroupNetwork): diff --git a/openstackclient/tests/unit/network/v2/test_security_group_rule_network.py b/openstackclient/tests/unit/network/v2/test_security_group_rule_network.py index 01411611..bcdb0c26 100644 --- a/openstackclient/tests/unit/network/v2/test_security_group_rule_network.py +++ b/openstackclient/tests/unit/network/v2/test_security_group_rule_network.py @@ -46,6 +46,9 @@ class TestCreateSecurityGroupRuleNetwork(TestSecurityGroupRuleNetwork): _security_group = \ network_fakes.FakeSecurityGroup.create_one_security_group() + # The address group to be used in security group rules + _address_group = network_fakes.FakeAddressGroup.create_one_address_group() + expected_columns = ( 'description', 'direction', @@ -55,6 +58,7 @@ class TestCreateSecurityGroupRuleNetwork(TestSecurityGroupRuleNetwork): 'port_range_min', 'project_id', 'protocol', + 'remote_address_group_id', 'remote_group_id', 'remote_ip_prefix', 'security_group_id', @@ -77,6 +81,7 @@ class TestCreateSecurityGroupRuleNetwork(TestSecurityGroupRuleNetwork): self._security_group_rule.port_range_min, self._security_group_rule.project_id, self._security_group_rule.protocol, + self._security_group_rule.remote_address_group_id, self._security_group_rule.remote_group_id, self._security_group_rule.remote_ip_prefix, self._security_group_rule.security_group_id, @@ -88,6 +93,9 @@ class TestCreateSecurityGroupRuleNetwork(TestSecurityGroupRuleNetwork): self.network.find_security_group = mock.Mock( return_value=self._security_group) + self.network.find_address_group = mock.Mock( + return_value=self._address_group) + self.projects_mock.get.return_value = self.project self.domains_mock.get.return_value = self.domain @@ -103,6 +111,7 @@ class TestCreateSecurityGroupRuleNetwork(TestSecurityGroupRuleNetwork): arglist = [ '--remote-ip', '10.10.0.0/24', '--remote-group', self._security_group.id, + '--remote-address-group', self._address_group.id, self._security_group.id, ] self.assertRaises(tests_utils.ParserException, @@ -258,6 +267,34 @@ class TestCreateSecurityGroupRuleNetwork(TestSecurityGroupRuleNetwork): self.assertEqual(self.expected_columns, columns) self.assertEqual(self.expected_data, data) + def test_create_remote_address_group(self): + self._setup_security_group_rule({ + 'protocol': 'icmp', + 'remote_address_group_id': self._address_group.id, + }) + arglist = [ + '--protocol', 'icmp', + '--remote-address-group', self._address_group.name, + self._security_group.id, + ] + verifylist = [ + ('remote_address_group', self._address_group.name), + ('group', self._security_group.id), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + columns, data = self.cmd.take_action(parsed_args) + + self.network.create_security_group_rule.assert_called_once_with(**{ + 'direction': self._security_group_rule.direction, + 'ethertype': self._security_group_rule.ether_type, + 'protocol': self._security_group_rule.protocol, + 'remote_address_group_id': self._address_group.id, + 'security_group_id': self._security_group.id, + }) + self.assertEqual(self.expected_columns, columns) + self.assertEqual(self.expected_data, data) + def test_create_remote_group(self): self._setup_security_group_rule({ 'protocol': 'tcp', @@ -878,6 +915,7 @@ class TestListSecurityGroupRuleNetwork(TestSecurityGroupRuleNetwork): 'Port Range', 'Direction', 'Remote Security Group', + 'Remote Address Group', ) expected_columns_no_group = ( 'ID', @@ -887,6 +925,7 @@ class TestListSecurityGroupRuleNetwork(TestSecurityGroupRuleNetwork): 'Port Range', 'Direction', 'Remote Security Group', + 'Remote Address Group', 'Security Group', ) @@ -902,6 +941,7 @@ class TestListSecurityGroupRuleNetwork(TestSecurityGroupRuleNetwork): _security_group_rule), _security_group_rule.direction, _security_group_rule.remote_group_id, + _security_group_rule.remote_address_group_id, )) expected_data_no_group.append(( _security_group_rule.id, @@ -912,6 +952,7 @@ class TestListSecurityGroupRuleNetwork(TestSecurityGroupRuleNetwork): _security_group_rule), _security_group_rule.direction, _security_group_rule.remote_group_id, + _security_group_rule.remote_address_group_id, _security_group_rule.security_group_id, )) @@ -1041,6 +1082,7 @@ class TestShowSecurityGroupRuleNetwork(TestSecurityGroupRuleNetwork): 'port_range_min', 'project_id', 'protocol', + 'remote_address_group_id', 'remote_group_id', 'remote_ip_prefix', 'security_group_id', @@ -1055,6 +1097,7 @@ class TestShowSecurityGroupRuleNetwork(TestSecurityGroupRuleNetwork): _security_group_rule.port_range_min, _security_group_rule.project_id, _security_group_rule.protocol, + _security_group_rule.remote_address_group_id, _security_group_rule.remote_group_id, _security_group_rule.remote_ip_prefix, _security_group_rule.security_group_id, diff --git a/openstackclient/tests/unit/network/v2/test_subnet.py b/openstackclient/tests/unit/network/v2/test_subnet.py index 47d0c6b4..6085cda8 100644 --- a/openstackclient/tests/unit/network/v2/test_subnet.py +++ b/openstackclient/tests/unit/network/v2/test_subnet.py @@ -255,7 +255,7 @@ class TestCreateSubnet(TestSubnet): }) self.assertFalse(self.network.set_tags.called) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, data) + self.assertItemsEqual(self.data, data) def test_create_from_subnet_pool_options(self): # Mock SDK calls for this test. @@ -317,7 +317,7 @@ class TestCreateSubnet(TestSubnet): 'service_types': self._subnet_from_pool.service_types, }) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data_subnet_pool, data) + self.assertItemsEqual(self.data_subnet_pool, data) def test_create_options_subnet_range_ipv6(self): # Mock SDK calls for this test. @@ -390,7 +390,7 @@ class TestCreateSubnet(TestSubnet): }) self.assertFalse(self.network.set_tags.called) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data_ipv6, data) + self.assertItemsEqual(self.data_ipv6, data) def test_create_with_network_segment(self): # Mock SDK calls for this test. @@ -424,7 +424,7 @@ class TestCreateSubnet(TestSubnet): }) self.assertFalse(self.network.set_tags.called) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, data) + self.assertItemsEqual(self.data, data) def test_create_with_description(self): # Mock SDK calls for this test. @@ -458,7 +458,7 @@ class TestCreateSubnet(TestSubnet): }) self.assertFalse(self.network.set_tags.called) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, data) + self.assertItemsEqual(self.data, data) def _test_create_with_dns(self, publish_dns=True): arglist = [ @@ -490,7 +490,7 @@ class TestCreateSubnet(TestSubnet): dns_publish_fixed_ip=publish_dns, ) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, data) + self.assertItemsEqual(self.data, data) def test_create_with_dns(self): self._test_create_with_dns(publish_dns=True) @@ -535,7 +535,7 @@ class TestCreateSubnet(TestSubnet): else: self.assertFalse(self.network.set_tags.called) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, data) + self.assertItemsEqual(self.data, data) def test_create_with_tags(self): self._test_create_with_tag(add_tags=True) @@ -691,7 +691,7 @@ class TestListSubnet(TestSubnet): self.network.subnets.assert_called_once_with() self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) def test_subnet_list_long(self): arglist = [ @@ -706,7 +706,7 @@ class TestListSubnet(TestSubnet): self.network.subnets.assert_called_once_with() self.assertEqual(self.columns_long, columns) - self.assertListItemEqual(self.data_long, list(data)) + self.assertItemsEqual(self.data_long, list(data)) def test_subnet_list_ip_version(self): arglist = [ @@ -722,7 +722,7 @@ class TestListSubnet(TestSubnet): self.network.subnets.assert_called_once_with(**filters) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) def test_subnet_list_dhcp(self): arglist = [ @@ -738,7 +738,7 @@ class TestListSubnet(TestSubnet): self.network.subnets.assert_called_once_with(**filters) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) def test_subnet_list_no_dhcp(self): arglist = [ @@ -754,7 +754,7 @@ class TestListSubnet(TestSubnet): self.network.subnets.assert_called_once_with(**filters) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) def test_subnet_list_service_type(self): arglist = [ @@ -769,7 +769,7 @@ class TestListSubnet(TestSubnet): self.network.subnets.assert_called_once_with(**filters) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) def test_subnet_list_project(self): project = identity_fakes_v3.FakeProject.create_one_project() @@ -787,7 +787,7 @@ class TestListSubnet(TestSubnet): self.network.subnets.assert_called_once_with(**filters) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) def test_subnet_list_service_type_multiple(self): arglist = [ @@ -805,7 +805,7 @@ class TestListSubnet(TestSubnet): 'network:floatingip_agent_gateway']} self.network.subnets.assert_called_once_with(**filters) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) def test_subnet_list_project_domain(self): project = identity_fakes_v3.FakeProject.create_one_project() @@ -825,7 +825,7 @@ class TestListSubnet(TestSubnet): self.network.subnets.assert_called_once_with(**filters) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) def test_subnet_list_network(self): network = network_fakes.FakeNetwork.create_one_network() @@ -843,7 +843,7 @@ class TestListSubnet(TestSubnet): self.network.subnets.assert_called_once_with(**filters) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) def test_subnet_list_gateway(self): subnet = network_fakes.FakeSubnet.create_one_subnet() @@ -861,7 +861,7 @@ class TestListSubnet(TestSubnet): self.network.subnets.assert_called_once_with(**filters) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) def test_subnet_list_name(self): subnet = network_fakes.FakeSubnet.create_one_subnet() @@ -879,7 +879,7 @@ class TestListSubnet(TestSubnet): self.network.subnets.assert_called_once_with(**filters) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) def test_subnet_list_subnet_range(self): subnet = network_fakes.FakeSubnet.create_one_subnet() @@ -897,7 +897,7 @@ class TestListSubnet(TestSubnet): self.network.subnets.assert_called_once_with(**filters) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) def test_list_with_tag_options(self): arglist = [ @@ -1244,7 +1244,7 @@ class TestShowSubnet(TestSubnet): self._subnet.name, ignore_missing=False) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, data) + self.assertItemsEqual(self.data, data) class TestUnsetSubnet(TestSubnet): @@ -1264,6 +1264,7 @@ class TestUnsetSubnet(TestSubnet): 'end': '8.8.8.170'}], 'service_types': ['network:router_gateway', 'network:floatingip_agent_gateway'], + 'gateway_ip': 'fe80::a00a:0:c0de:0:1', 'tags': ['green', 'red'], }) self.network.find_subnet = mock.Mock(return_value=self._testsubnet) self.network.update_subnet = mock.Mock(return_value=None) @@ -1277,6 +1278,7 @@ class TestUnsetSubnet(TestSubnet): '--host-route', 'destination=10.30.30.30/24,gateway=10.30.30.1', '--allocation-pool', 'start=8.8.8.100,end=8.8.8.150', '--service-type', 'network:router_gateway', + '--gateway', self._testsubnet.name, ] verifylist = [ @@ -1286,6 +1288,7 @@ class TestUnsetSubnet(TestSubnet): ('allocation_pools', [{ 'start': '8.8.8.100', 'end': '8.8.8.150'}]), ('service_types', ['network:router_gateway']), + ('gateway', True), ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) @@ -1297,6 +1300,7 @@ class TestUnsetSubnet(TestSubnet): "destination": "10.20.20.0/24", "nexthop": "10.20.20.1"}], 'allocation_pools': [{'start': '8.8.8.160', 'end': '8.8.8.170'}], 'service_types': ['network:floatingip_agent_gateway'], + 'gateway_ip': None, } self.network.update_subnet.assert_called_once_with( self._testsubnet, **attrs) diff --git a/openstackclient/tests/unit/network/v2/test_subnet_pool.py b/openstackclient/tests/unit/network/v2/test_subnet_pool.py index eb454646..243fc76d 100644 --- a/openstackclient/tests/unit/network/v2/test_subnet_pool.py +++ b/openstackclient/tests/unit/network/v2/test_subnet_pool.py @@ -133,7 +133,7 @@ class TestCreateSubnetPool(TestSubnetPool): }) self.assertFalse(self.network.set_tags.called) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, data) + self.assertItemsEqual(self.data, data) def test_create_prefixlen_options(self): arglist = [ @@ -163,7 +163,7 @@ class TestCreateSubnetPool(TestSubnetPool): 'name': self._subnet_pool.name, }) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, data) + self.assertItemsEqual(self.data, data) def test_create_len_negative(self): arglist = [ @@ -201,7 +201,7 @@ class TestCreateSubnetPool(TestSubnetPool): 'name': self._subnet_pool.name, }) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, data) + self.assertItemsEqual(self.data, data) def test_create_address_scope_option(self): arglist = [ @@ -224,7 +224,7 @@ class TestCreateSubnetPool(TestSubnetPool): 'name': self._subnet_pool.name, }) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, data) + self.assertItemsEqual(self.data, data) def test_create_default_and_shared_options(self): arglist = [ @@ -250,7 +250,7 @@ class TestCreateSubnetPool(TestSubnetPool): 'shared': True, }) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, data) + self.assertItemsEqual(self.data, data) def test_create_with_description(self): arglist = [ @@ -273,7 +273,7 @@ class TestCreateSubnetPool(TestSubnetPool): 'description': self._subnet_pool.description, }) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, data) + self.assertItemsEqual(self.data, data) def test_create_with_default_quota(self): arglist = [ @@ -294,7 +294,7 @@ class TestCreateSubnetPool(TestSubnetPool): 'default_quota': 10, }) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, data) + self.assertItemsEqual(self.data, data) def _test_create_with_tag(self, add_tags=True): arglist = [ @@ -328,7 +328,7 @@ class TestCreateSubnetPool(TestSubnetPool): else: self.assertFalse(self.network.set_tags.called) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, data) + self.assertItemsEqual(self.data, data) def test_create_with_tags(self): self._test_create_with_tag(add_tags=True) @@ -476,7 +476,7 @@ class TestListSubnetPool(TestSubnetPool): self.network.subnet_pools.assert_called_once_with() self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) def test_subnet_pool_list_long(self): arglist = [ @@ -491,7 +491,7 @@ class TestListSubnetPool(TestSubnetPool): self.network.subnet_pools.assert_called_once_with() self.assertEqual(self.columns_long, columns) - self.assertListItemEqual(self.data_long, list(data)) + self.assertItemsEqual(self.data_long, list(data)) def test_subnet_pool_list_no_share(self): arglist = [ @@ -507,7 +507,7 @@ class TestListSubnetPool(TestSubnetPool): self.network.subnet_pools.assert_called_once_with(**filters) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) def test_subnet_pool_list_share(self): arglist = [ @@ -523,7 +523,7 @@ class TestListSubnetPool(TestSubnetPool): self.network.subnet_pools.assert_called_once_with(**filters) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) def test_subnet_pool_list_no_default(self): arglist = [ @@ -539,7 +539,7 @@ class TestListSubnetPool(TestSubnetPool): self.network.subnet_pools.assert_called_once_with(**filters) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) def test_subnet_pool_list_default(self): arglist = [ @@ -555,7 +555,7 @@ class TestListSubnetPool(TestSubnetPool): self.network.subnet_pools.assert_called_once_with(**filters) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) def test_subnet_pool_list_project(self): project = identity_fakes_v3.FakeProject.create_one_project() @@ -573,7 +573,7 @@ class TestListSubnetPool(TestSubnetPool): self.network.subnet_pools.assert_called_once_with(**filters) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) def test_subnet_pool_list_project_domain(self): project = identity_fakes_v3.FakeProject.create_one_project() @@ -593,7 +593,7 @@ class TestListSubnetPool(TestSubnetPool): self.network.subnet_pools.assert_called_once_with(**filters) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) def test_subnet_pool_list_name(self): subnet_pool = network_fakes.FakeSubnetPool.create_one_subnet_pool() @@ -611,7 +611,7 @@ class TestListSubnetPool(TestSubnetPool): self.network.subnet_pools.assert_called_once_with(**filters) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) def test_subnet_pool_list_address_scope(self): addr_scope = network_fakes.FakeAddressScope.create_one_address_scope() @@ -629,7 +629,7 @@ class TestListSubnetPool(TestSubnetPool): self.network.subnet_pools.assert_called_once_with(**filters) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) def test_list_with_tag_options(self): arglist = [ @@ -654,7 +654,7 @@ class TestListSubnetPool(TestSubnetPool): 'not_any_tags': 'black,white'} ) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) class TestSetSubnetPool(TestSubnetPool): @@ -1008,7 +1008,7 @@ class TestShowSubnetPool(TestSubnetPool): ignore_missing=False ) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, data) + self.assertItemsEqual(self.data, data) class TestUnsetSubnetPool(TestSubnetPool): diff --git a/openstackclient/tests/unit/utils.py b/openstackclient/tests/unit/utils.py index 4130f18e..39cb5614 100644 --- a/openstackclient/tests/unit/utils.py +++ b/openstackclient/tests/unit/utils.py @@ -17,7 +17,6 @@ from io import StringIO import os -from cliff import columns as cliff_columns import fixtures import testtools @@ -85,18 +84,3 @@ class TestCommand(TestCase): self.assertIn(attr, parsed_args) self.assertEqual(value, getattr(parsed_args, attr)) return parsed_args - - def assertListItemEqual(self, expected, actual): - self.assertEqual(len(expected), len(actual)) - for item_expected, item_actual in zip(expected, actual): - self.assertItemEqual(item_expected, item_actual) - - def assertItemEqual(self, expected, actual): - self.assertEqual(len(expected), len(actual)) - for col_expected, col_actual in zip(expected, actual): - if isinstance(col_expected, cliff_columns.FormattableColumn): - self.assertIsInstance(col_actual, col_expected.__class__) - self.assertEqual(col_expected.human_readable(), - col_actual.human_readable()) - else: - self.assertEqual(col_expected, col_actual) diff --git a/openstackclient/tests/unit/volume/v1/test_qos_specs.py b/openstackclient/tests/unit/volume/v1/test_qos_specs.py index 83c533b6..5500438b 100644 --- a/openstackclient/tests/unit/volume/v1/test_qos_specs.py +++ b/openstackclient/tests/unit/volume/v1/test_qos_specs.py @@ -109,7 +109,7 @@ class TestQosCreate(TestQos): ) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.datalist, data) + self.assertItemsEqual(self.datalist, data) def test_qos_create_with_consumer(self): arglist = [ @@ -129,7 +129,7 @@ class TestQosCreate(TestQos): {'consumer': self.new_qos_spec.consumer} ) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.datalist, data) + self.assertItemsEqual(self.datalist, data) def test_qos_create_with_properties(self): arglist = [ @@ -155,7 +155,7 @@ class TestQosCreate(TestQos): ) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.datalist, data) + self.assertItemsEqual(self.datalist, data) class TestQosDelete(TestQos): @@ -350,7 +350,7 @@ class TestQosList(TestQos): self.qos_mock.list.assert_called_with() self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) def test_qos_list_no_association(self): self.qos_mock.reset_mock() @@ -377,7 +377,7 @@ class TestQosList(TestQos): format_columns.ListColumn(None), format_columns.DictColumn(self.qos_specs[1].specs), ) - self.assertListItemEqual(ex_data, list(data)) + self.assertItemsEqual(ex_data, list(data)) class TestQosSet(TestQos): @@ -454,7 +454,7 @@ class TestQosShow(TestQos): self.qos_spec.name, format_columns.DictColumn(self.qos_spec.specs), ) - self.assertItemEqual(datalist, tuple(data)) + self.assertItemsEqual(datalist, tuple(data)) class TestQosUnset(TestQos): diff --git a/openstackclient/tests/unit/volume/v1/test_type.py b/openstackclient/tests/unit/volume/v1/test_type.py index 8bee5747..f1d46914 100644 --- a/openstackclient/tests/unit/volume/v1/test_type.py +++ b/openstackclient/tests/unit/volume/v1/test_type.py @@ -78,7 +78,7 @@ class TestTypeCreate(TestType): ) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, data) + self.assertItemsEqual(self.data, data) def test_type_create_with_encryption(self): encryption_info = { @@ -139,7 +139,7 @@ class TestTypeCreate(TestType): body, ) self.assertEqual(encryption_columns, columns) - self.assertItemEqual(encryption_data, data) + self.assertItemsEqual(encryption_data, data) class TestTypeDelete(TestType): @@ -270,7 +270,7 @@ class TestTypeList(TestType): columns, data = self.cmd.take_action(parsed_args) self.types_mock.list.assert_called_once_with() self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) def test_type_list_with_options(self): arglist = [ @@ -284,7 +284,7 @@ class TestTypeList(TestType): columns, data = self.cmd.take_action(parsed_args) self.types_mock.list.assert_called_once_with() self.assertEqual(self.columns_long, columns) - self.assertListItemEqual(self.data_long, list(data)) + self.assertItemsEqual(self.data_long, list(data)) def test_type_list_with_encryption(self): encryption_type = volume_fakes.FakeType.create_one_encryption_type( @@ -328,7 +328,7 @@ class TestTypeList(TestType): self.encryption_types_mock.list.assert_called_once_with() self.types_mock.list.assert_called_once_with() self.assertEqual(encryption_columns, columns) - self.assertListItemEqual(encryption_data, list(data)) + self.assertItemsEqual(encryption_data, list(data)) class TestTypeSet(TestType): @@ -469,7 +469,7 @@ class TestTypeShow(TestType): self.types_mock.get.assert_called_with(self.volume_type.id) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, data) + self.assertItemsEqual(self.data, data) def test_type_show_with_encryption(self): encryption_type = volume_fakes.FakeType.create_one_encryption_type() @@ -513,7 +513,7 @@ class TestTypeShow(TestType): self.types_mock.get.assert_called_with(self.volume_type.id) self.encryption_types_mock.get.assert_called_with(self.volume_type.id) self.assertEqual(encryption_columns, columns) - self.assertItemEqual(encryption_data, data) + self.assertItemsEqual(encryption_data, data) class TestTypeUnset(TestType): diff --git a/openstackclient/tests/unit/volume/v1/test_volume.py b/openstackclient/tests/unit/volume/v1/test_volume.py index 25cdf92a..704a66da 100644 --- a/openstackclient/tests/unit/volume/v1/test_volume.py +++ b/openstackclient/tests/unit/volume/v1/test_volume.py @@ -135,7 +135,7 @@ class TestVolumeCreate(TestVolume): None, ) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.datalist, data) + self.assertItemsEqual(self.datalist, data) def test_volume_create_options(self): arglist = [ @@ -179,7 +179,7 @@ class TestVolumeCreate(TestVolume): ) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.datalist, data) + self.assertItemsEqual(self.datalist, data) def test_volume_create_user_project_id(self): # Return a project @@ -226,7 +226,7 @@ class TestVolumeCreate(TestVolume): ) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.datalist, data) + self.assertItemsEqual(self.datalist, data) def test_volume_create_user_project_name(self): # Return a project @@ -273,7 +273,7 @@ class TestVolumeCreate(TestVolume): ) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.datalist, data) + self.assertItemsEqual(self.datalist, data) def test_volume_create_properties(self): arglist = [ @@ -314,7 +314,7 @@ class TestVolumeCreate(TestVolume): ) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.datalist, data) + self.assertItemsEqual(self.datalist, data) def test_volume_create_image_id(self): image = image_fakes.FakeImage.create_one_image() @@ -357,7 +357,7 @@ class TestVolumeCreate(TestVolume): ) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.datalist, data) + self.assertItemsEqual(self.datalist, data) def test_volume_create_image_name(self): image = image_fakes.FakeImage.create_one_image() @@ -400,7 +400,7 @@ class TestVolumeCreate(TestVolume): ) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.datalist, data) + self.assertItemsEqual(self.datalist, data) def test_volume_create_with_source(self): self.volumes_mock.get.return_value = self.new_volume @@ -430,7 +430,7 @@ class TestVolumeCreate(TestVolume): None, ) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.datalist, data) + self.assertItemsEqual(self.datalist, data) def test_volume_create_with_bootable_and_readonly(self): arglist = [ @@ -468,7 +468,7 @@ class TestVolumeCreate(TestVolume): ) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.datalist, data) + self.assertItemsEqual(self.datalist, data) self.volumes_mock.set_bootable.assert_called_with( self.new_volume.id, True) self.volumes_mock.update_readonly_flag.assert_called_with( @@ -510,7 +510,7 @@ class TestVolumeCreate(TestVolume): ) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.datalist, data) + self.assertItemsEqual(self.datalist, data) self.volumes_mock.set_bootable.assert_called_with( self.new_volume.id, False) self.volumes_mock.update_readonly_flag.assert_called_with( @@ -562,7 +562,7 @@ class TestVolumeCreate(TestVolume): self.assertEqual(2, mock_error.call_count) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.datalist, data) + self.assertItemsEqual(self.datalist, data) self.volumes_mock.set_bootable.assert_called_with( self.new_volume.id, True) self.volumes_mock.update_readonly_flag.assert_called_with( @@ -765,7 +765,7 @@ class TestVolumeList(TestVolume): columns, data = self.cmd.take_action(parsed_args) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.datalist, tuple(data)) + self.assertItemsEqual(self.datalist, tuple(data)) def test_volume_list_name(self): arglist = [ @@ -782,7 +782,7 @@ class TestVolumeList(TestVolume): columns, data = self.cmd.take_action(parsed_args) self.assertEqual(self.columns, tuple(columns)) - self.assertListItemEqual(self.datalist, tuple(data)) + self.assertItemsEqual(self.datalist, tuple(data)) def test_volume_list_status(self): arglist = [ @@ -799,7 +799,7 @@ class TestVolumeList(TestVolume): columns, data = self.cmd.take_action(parsed_args) self.assertEqual(self.columns, tuple(columns)) - self.assertListItemEqual(self.datalist, tuple(data)) + self.assertItemsEqual(self.datalist, tuple(data)) def test_volume_list_all_projects(self): arglist = [ @@ -816,7 +816,7 @@ class TestVolumeList(TestVolume): columns, data = self.cmd.take_action(parsed_args) self.assertEqual(self.columns, tuple(columns)) - self.assertListItemEqual(self.datalist, tuple(data)) + self.assertItemsEqual(self.datalist, tuple(data)) def test_volume_list_long(self): arglist = [ @@ -856,7 +856,7 @@ class TestVolumeList(TestVolume): volume.AttachmentsColumn(self._volume.attachments), format_columns.DictColumn(self._volume.metadata), ), ) - self.assertListItemEqual(datalist, tuple(data)) + self.assertItemsEqual(datalist, tuple(data)) def test_volume_list_with_limit(self): arglist = [ @@ -881,7 +881,7 @@ class TestVolumeList(TestVolume): 'all_tenants': False, } ) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.datalist, tuple(data)) + self.assertItemsEqual(self.datalist, tuple(data)) def test_volume_list_negative_limit(self): arglist = [ @@ -1272,7 +1272,7 @@ class TestVolumeShow(TestVolume): self.volumes_mock.get.assert_called_with(self._volume.id) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.datalist, data) + self.assertItemsEqual(self.datalist, data) def test_volume_show_backward_compatibility(self): arglist = [ diff --git a/openstackclient/tests/unit/volume/v1/test_volume_backup.py b/openstackclient/tests/unit/volume/v1/test_volume_backup.py index 20aadcd3..a7131550 100644 --- a/openstackclient/tests/unit/volume/v1/test_volume_backup.py +++ b/openstackclient/tests/unit/volume/v1/test_volume_backup.py @@ -100,7 +100,7 @@ class TestBackupCreate(TestBackup): self.new_backup.description, ) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, data) + self.assertItemsEqual(self.data, data) def test_backup_create_without_name(self): arglist = [ @@ -124,7 +124,7 @@ class TestBackupCreate(TestBackup): self.new_backup.description, ) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, data) + self.assertItemsEqual(self.data, data) class TestBackupDelete(TestBackup): @@ -277,7 +277,7 @@ class TestBackupList(TestBackup): search_opts=search_opts, ) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) def test_backup_list_with_options(self): arglist = [ @@ -309,7 +309,7 @@ class TestBackupList(TestBackup): search_opts=search_opts, ) self.assertEqual(self.columns_long, columns) - self.assertListItemEqual(self.data_long, list(data)) + self.assertItemsEqual(self.data_long, list(data)) class TestBackupRestore(TestBackup): @@ -391,4 +391,4 @@ class TestBackupShow(TestBackup): self.backups_mock.get.assert_called_with(self.backup.id) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, data) + self.assertItemsEqual(self.data, data) diff --git a/openstackclient/tests/unit/volume/v2/test_consistency_group.py b/openstackclient/tests/unit/volume/v2/test_consistency_group.py index c3bd71e3..6bb6c029 100644 --- a/openstackclient/tests/unit/volume/v2/test_consistency_group.py +++ b/openstackclient/tests/unit/volume/v2/test_consistency_group.py @@ -251,7 +251,7 @@ class TestConsistencyGroupCreate(TestConsistencyGroup): ) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, data) + self.assertItemsEqual(self.data, data) def test_consistency_group_create_from_source(self): arglist = [ @@ -279,7 +279,7 @@ class TestConsistencyGroupCreate(TestConsistencyGroup): ) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, data) + self.assertItemsEqual(self.data, data) def test_consistency_group_create_from_snapshot(self): arglist = [ @@ -307,7 +307,7 @@ class TestConsistencyGroupCreate(TestConsistencyGroup): ) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, data) + self.assertItemsEqual(self.data, data) class TestConsistencyGroupDelete(TestConsistencyGroup): @@ -463,7 +463,7 @@ class TestConsistencyGroupList(TestConsistencyGroup): self.consistencygroups_mock.list.assert_called_once_with( detailed=True, search_opts={'all_tenants': False}) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) def test_consistency_group_list_with_all_project(self): arglist = [ @@ -480,7 +480,7 @@ class TestConsistencyGroupList(TestConsistencyGroup): self.consistencygroups_mock.list.assert_called_once_with( detailed=True, search_opts={'all_tenants': True}) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) def test_consistency_group_list_with_long(self): arglist = [ @@ -497,7 +497,7 @@ class TestConsistencyGroupList(TestConsistencyGroup): self.consistencygroups_mock.list.assert_called_once_with( detailed=True, search_opts={'all_tenants': False}) self.assertEqual(self.columns_long, columns) - self.assertListItemEqual(self.data_long, list(data)) + self.assertItemsEqual(self.data_long, list(data)) class TestConsistencyGroupRemoveVolume(TestConsistencyGroup): @@ -705,4 +705,4 @@ class TestConsistencyGroupShow(TestConsistencyGroup): self.consistencygroups_mock.get.assert_called_once_with( self.consistency_group.id) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, data) + self.assertItemsEqual(self.data, data) diff --git a/openstackclient/tests/unit/volume/v2/test_qos_specs.py b/openstackclient/tests/unit/volume/v2/test_qos_specs.py index 073ec570..bc4cee8b 100644 --- a/openstackclient/tests/unit/volume/v2/test_qos_specs.py +++ b/openstackclient/tests/unit/volume/v2/test_qos_specs.py @@ -112,7 +112,7 @@ class TestQosCreate(TestQos): ) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, data) + self.assertItemsEqual(self.data, data) def test_qos_create_with_consumer(self): arglist = [ @@ -133,7 +133,7 @@ class TestQosCreate(TestQos): ) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, data) + self.assertItemsEqual(self.data, data) def test_qos_create_with_properties(self): arglist = [ @@ -159,7 +159,7 @@ class TestQosCreate(TestQos): ) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, data) + self.assertItemsEqual(self.data, data) class TestQosDelete(TestQos): @@ -342,7 +342,7 @@ class TestQosList(TestQos): self.qos_mock.list.assert_called_with() self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) def test_qos_list_no_association(self): self.qos_mock.reset_mock() @@ -369,7 +369,7 @@ class TestQosList(TestQos): format_columns.ListColumn(None), format_columns.DictColumn(self.qos_specs[1].specs), ) - self.assertListItemEqual(ex_data, list(data)) + self.assertItemsEqual(ex_data, list(data)) class TestQosSet(TestQos): @@ -449,7 +449,7 @@ class TestQosShow(TestQos): ) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, tuple(data)) + self.assertItemsEqual(self.data, tuple(data)) class TestQosUnset(TestQos): diff --git a/openstackclient/tests/unit/volume/v2/test_type.py b/openstackclient/tests/unit/volume/v2/test_type.py index f13d0851..000464c5 100644 --- a/openstackclient/tests/unit/volume/v2/test_type.py +++ b/openstackclient/tests/unit/volume/v2/test_type.py @@ -93,7 +93,7 @@ class TestTypeCreate(TestType): ) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, data) + self.assertItemsEqual(self.data, data) def test_type_create_private(self): arglist = [ @@ -119,7 +119,7 @@ class TestTypeCreate(TestType): ) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, data) + self.assertItemsEqual(self.data, data) def test_public_type_create_with_project(self): arglist = [ @@ -196,7 +196,7 @@ class TestTypeCreate(TestType): body, ) self.assertEqual(encryption_columns, columns) - self.assertItemEqual(encryption_data, data) + self.assertItemsEqual(encryption_data, data) class TestTypeDelete(TestType): @@ -330,7 +330,7 @@ class TestTypeList(TestType): columns, data = self.cmd.take_action(parsed_args) self.types_mock.list.assert_called_once_with(is_public=None) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) def test_type_list_with_options(self): arglist = [ @@ -348,7 +348,7 @@ class TestTypeList(TestType): columns, data = self.cmd.take_action(parsed_args) self.types_mock.list.assert_called_once_with(is_public=True) self.assertEqual(self.columns_long, columns) - self.assertListItemEqual(self.data_long, list(data)) + self.assertItemsEqual(self.data_long, list(data)) def test_type_list_with_private_option(self): arglist = [ @@ -365,7 +365,7 @@ class TestTypeList(TestType): columns, data = self.cmd.take_action(parsed_args) self.types_mock.list.assert_called_once_with(is_public=False) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) def test_type_list_with_default_option(self): arglist = [ @@ -383,7 +383,7 @@ class TestTypeList(TestType): columns, data = self.cmd.take_action(parsed_args) self.types_mock.default.assert_called_once_with() self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data_with_default_type, list(data)) + self.assertItemsEqual(self.data_with_default_type, list(data)) def test_type_list_with_encryption(self): encryption_type = volume_fakes.FakeType.create_one_encryption_type( @@ -427,7 +427,7 @@ class TestTypeList(TestType): self.encryption_types_mock.list.assert_called_once_with() self.types_mock.list.assert_called_once_with(is_public=None) self.assertEqual(encryption_columns, columns) - self.assertListItemEqual(encryption_data, list(data)) + self.assertItemsEqual(encryption_data, list(data)) class TestTypeSet(TestType): @@ -713,7 +713,7 @@ class TestTypeShow(TestType): self.types_mock.get.assert_called_with(self.volume_type.id) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.data, data) + self.assertItemsEqual(self.data, data) def test_type_show_with_access(self): arglist = [ @@ -746,7 +746,7 @@ class TestTypeShow(TestType): private_type.name, format_columns.DictColumn(private_type.extra_specs) ) - self.assertItemEqual(private_type_data, data) + self.assertItemsEqual(private_type_data, data) def test_type_show_with_list_access_exec(self): arglist = [ @@ -778,7 +778,7 @@ class TestTypeShow(TestType): private_type.name, format_columns.DictColumn(private_type.extra_specs) ) - self.assertItemEqual(private_type_data, data) + self.assertItemsEqual(private_type_data, data) def test_type_show_with_encryption(self): encryption_type = volume_fakes.FakeType.create_one_encryption_type() @@ -824,7 +824,7 @@ class TestTypeShow(TestType): self.types_mock.get.assert_called_with(self.volume_type.id) self.encryption_types_mock.get.assert_called_with(self.volume_type.id) self.assertEqual(encryption_columns, columns) - self.assertItemEqual(encryption_data, data) + self.assertItemsEqual(encryption_data, data) class TestTypeUnset(TestType): diff --git a/openstackclient/tests/unit/volume/v2/test_volume.py b/openstackclient/tests/unit/volume/v2/test_volume.py index 4e204ad1..b9fe4e83 100644 --- a/openstackclient/tests/unit/volume/v2/test_volume.py +++ b/openstackclient/tests/unit/volume/v2/test_volume.py @@ -136,7 +136,7 @@ class TestVolumeCreate(TestVolume): ) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.datalist, data) + self.assertItemsEqual(self.datalist, data) def test_volume_create_options(self): consistency_group = ( @@ -182,7 +182,7 @@ class TestVolumeCreate(TestVolume): ) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.datalist, data) + self.assertItemsEqual(self.datalist, data) def test_volume_create_properties(self): arglist = [ @@ -218,7 +218,7 @@ class TestVolumeCreate(TestVolume): ) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.datalist, data) + self.assertItemsEqual(self.datalist, data) def test_volume_create_image_id(self): image = image_fakes.FakeImage.create_one_image() @@ -256,7 +256,7 @@ class TestVolumeCreate(TestVolume): ) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.datalist, data) + self.assertItemsEqual(self.datalist, data) def test_volume_create_image_name(self): image = image_fakes.FakeImage.create_one_image() @@ -294,7 +294,7 @@ class TestVolumeCreate(TestVolume): ) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.datalist, data) + self.assertItemsEqual(self.datalist, data) def test_volume_create_with_snapshot(self): snapshot = volume_fakes.FakeSnapshot.create_one_snapshot() @@ -331,7 +331,7 @@ class TestVolumeCreate(TestVolume): ) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.datalist, data) + self.assertItemsEqual(self.datalist, data) def test_volume_create_with_bootable_and_readonly(self): arglist = [ @@ -369,7 +369,7 @@ class TestVolumeCreate(TestVolume): ) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.datalist, data) + self.assertItemsEqual(self.datalist, data) self.volumes_mock.set_bootable.assert_called_with( self.new_volume.id, True) self.volumes_mock.update_readonly_flag.assert_called_with( @@ -411,7 +411,7 @@ class TestVolumeCreate(TestVolume): ) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.datalist, data) + self.assertItemsEqual(self.datalist, data) self.volumes_mock.set_bootable.assert_called_with( self.new_volume.id, False) self.volumes_mock.update_readonly_flag.assert_called_with( @@ -463,7 +463,7 @@ class TestVolumeCreate(TestVolume): self.assertEqual(2, mock_error.call_count) self.assertEqual(self.columns, columns) - self.assertItemEqual(self.datalist, data) + self.assertItemsEqual(self.datalist, data) self.volumes_mock.set_bootable.assert_called_with( self.new_volume.id, True) self.volumes_mock.update_readonly_flag.assert_called_with( @@ -680,7 +680,7 @@ class TestVolumeList(TestVolume): self.mock_volume.size, volume.AttachmentsColumn(self.mock_volume.attachments), ), ) - self.assertListItemEqual(datalist, tuple(data)) + self.assertItemsEqual(datalist, tuple(data)) def test_volume_list_project(self): arglist = [ @@ -720,7 +720,7 @@ class TestVolumeList(TestVolume): self.mock_volume.size, volume.AttachmentsColumn(self.mock_volume.attachments), ), ) - self.assertListItemEqual(datalist, tuple(data)) + self.assertItemsEqual(datalist, tuple(data)) def test_volume_list_project_domain(self): arglist = [ @@ -762,7 +762,7 @@ class TestVolumeList(TestVolume): self.mock_volume.size, volume.AttachmentsColumn(self.mock_volume.attachments), ), ) - self.assertListItemEqual(datalist, tuple(data)) + self.assertItemsEqual(datalist, tuple(data)) def test_volume_list_user(self): arglist = [ @@ -801,7 +801,7 @@ class TestVolumeList(TestVolume): self.mock_volume.size, volume.AttachmentsColumn(self.mock_volume.attachments), ), ) - self.assertListItemEqual(datalist, tuple(data)) + self.assertItemsEqual(datalist, tuple(data)) def test_volume_list_user_domain(self): arglist = [ @@ -843,7 +843,7 @@ class TestVolumeList(TestVolume): self.mock_volume.size, volume.AttachmentsColumn(self.mock_volume.attachments), ), ) - self.assertListItemEqual(datalist, tuple(data)) + self.assertItemsEqual(datalist, tuple(data)) def test_volume_list_name(self): arglist = [ @@ -883,7 +883,7 @@ class TestVolumeList(TestVolume): self.mock_volume.size, volume.AttachmentsColumn(self.mock_volume.attachments), ), ) - self.assertListItemEqual(datalist, tuple(data)) + self.assertItemsEqual(datalist, tuple(data)) def test_volume_list_status(self): arglist = [ @@ -923,7 +923,7 @@ class TestVolumeList(TestVolume): self.mock_volume.size, volume.AttachmentsColumn(self.mock_volume.attachments), ), ) - self.assertListItemEqual(datalist, tuple(data)) + self.assertItemsEqual(datalist, tuple(data)) def test_volume_list_all_projects(self): arglist = [ @@ -963,7 +963,7 @@ class TestVolumeList(TestVolume): self.mock_volume.size, volume.AttachmentsColumn(self.mock_volume.attachments), ), ) - self.assertListItemEqual(datalist, tuple(data)) + self.assertItemsEqual(datalist, tuple(data)) def test_volume_list_long(self): arglist = [ @@ -1017,7 +1017,7 @@ class TestVolumeList(TestVolume): volume.AttachmentsColumn(self.mock_volume.attachments), format_columns.DictColumn(self.mock_volume.metadata), ), ) - self.assertListItemEqual(datalist, tuple(data)) + self.assertItemsEqual(datalist, tuple(data)) def test_volume_list_with_marker_and_limit(self): arglist = [ @@ -1056,7 +1056,7 @@ class TestVolumeList(TestVolume): 'name': None, 'all_tenants': False, } ) - self.assertListItemEqual(datalist, tuple(data)) + self.assertItemsEqual(datalist, tuple(data)) def test_volume_list_negative_limit(self): arglist = [ @@ -1450,7 +1450,7 @@ class TestVolumeShow(TestVolume): volume_fakes.FakeVolume.get_volume_columns(self._volume), columns) - self.assertItemEqual( + self.assertItemsEqual( volume_fakes.FakeVolume.get_volume_data(self._volume), data) diff --git a/openstackclient/tests/unit/volume/v2/test_volume_backend.py b/openstackclient/tests/unit/volume/v2/test_volume_backend.py index db188660..d9ac2c96 100644 --- a/openstackclient/tests/unit/volume/v2/test_volume_backend.py +++ b/openstackclient/tests/unit/volume/v2/test_volume_backend.py @@ -65,7 +65,7 @@ class TestShowVolumeCapability(volume_fakes.TestVolume): # confirming if all expected values are present in the result. for cap in data: - self.assertTrue(cap[0] in capabilities) + self.assertIn(cap[0], capabilities) # checking if proper call was made to get capabilities self.capability_mock.get.assert_called_with( diff --git a/openstackclient/tests/unit/volume/v2/test_volume_backup.py b/openstackclient/tests/unit/volume/v2/test_volume_backup.py index 4e1f7ee1..13513ed8 100644 --- a/openstackclient/tests/unit/volume/v2/test_volume_backup.py +++ b/openstackclient/tests/unit/volume/v2/test_volume_backup.py @@ -314,7 +314,7 @@ class TestBackupList(TestBackup): limit=None, ) self.assertEqual(self.columns, columns) - self.assertListItemEqual(self.data, list(data)) + self.assertItemsEqual(self.data, list(data)) def test_backup_list_with_options(self): arglist = [ @@ -353,7 +353,7 @@ class TestBackupList(TestBackup): limit=3, ) self.assertEqual(self.columns_long, columns) - self.assertListItemEqual(self.data_long, list(data)) + self.assertItemsEqual(self.data_long, list(data)) class TestBackupRestore(TestBackup): |