openstack/python-openstackclient
Code Issues Proposed changes

tests: Convert network tests to use 'parse_output'

Browse Source 
Change-Id: I93e2a4e0a4c7ec07da0c78a171f3d787125af053
Signed-off-by: Stephen Finucane <sfinucan@redhat.com>
This commit is contained in:
Stephen Finucane 2022-11-08 11:23:25 +00:00
parent 874519e980
commit 50aed3fea2
27 changed files with 1130 additions and 892 deletions

28
openstackclient/tests/functional/network/v2/common.py

@ -10,7 +10,6 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
import json
import uuid import uuid
from openstackclient.tests.functional import base from openstackclient.tests.functional import base
@ -32,7 +31,10 @@ class NetworkTagTests(NetworkTests):
def test_tag_operation(self): def test_tag_operation(self):
# Get project IDs # Get project IDs
cmd_output = json.loads(self.openstack('token issue -f json ')) cmd_output = self.openstack(
'token issue ',
parse_output=True,
)
auth_project_id = cmd_output['project_id'] auth_project_id = cmd_output['project_id']
# Network create with no options # Network create with no options
@ -63,17 +65,20 @@ class NetworkTagTests(NetworkTests):
self._set_resource_and_tag_check('set', name2, '--no-tag', []) self._set_resource_and_tag_check('set', name2, '--no-tag', [])
def _list_tag_check(self, project_id, expected): def _list_tag_check(self, project_id, expected):
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'{} list --long --project {} -f json'.format(self.base_command, '{} list --long --project {}'.format(self.base_command,
project_id))) project_id),
parse_output=True,
)
for name, tags in expected: for name, tags in expected:
net = [n for n in cmd_output if n['Name'] == name][0] net = [n for n in cmd_output if n['Name'] == name][0]
self.assertEqual(set(tags), set(net['Tags'])) self.assertEqual(set(tags), set(net['Tags']))
def _create_resource_for_tag_test(self, name, args): def _create_resource_for_tag_test(self, name, args):
return json.loads(self.openstack( return self.openstack(
'{} create -f json {} {}'.format(self.base_command, args, name) '{} create {} {}'.format(self.base_command, args, name),
)) parse_output=True,
)
def _create_resource_and_tag_check(self, args, expected): def _create_resource_and_tag_check(self, args, expected):
name = uuid.uuid4().hex name = uuid.uuid4().hex
@ -89,7 +94,8 @@ class NetworkTagTests(NetworkTests):
'{} {} {} {}'.format(self.base_command, command, args, name) '{} {} {} {}'.format(self.base_command, command, args, name)
) )
self.assertFalse(cmd_output) self.assertFalse(cmd_output)
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'{} show -f json {}'.format(self.base_command, name) '{} show {}'.format(self.base_command, name),
)) parse_output=True,
)
self.assertEqual(set(expected), set(cmd_output['tags'])) self.assertEqual(set(expected), set(cmd_output['tags']))

89
openstackclient/tests/functional/network/v2/test_address_group.py

@ -10,7 +10,6 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
import json
import uuid import uuid
from openstackclient.tests.functional.network.v2 import common from openstackclient.tests.functional.network.v2 import common
@ -30,20 +29,22 @@ class AddressGroupTests(common.NetworkTests):
def test_address_group_create_and_delete(self): def test_address_group_create_and_delete(self):
"""Test create, delete multiple""" """Test create, delete multiple"""
name1 = uuid.uuid4().hex name1 = uuid.uuid4().hex
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'address group create -f json ' + 'address group create ' +
name1 name1,
)) parse_output=True,
)
self.assertEqual( self.assertEqual(
name1, name1,
cmd_output['name'], cmd_output['name'],
) )
name2 = uuid.uuid4().hex name2 = uuid.uuid4().hex
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'address group create -f json ' + 'address group create ' +
name2 name2,
)) parse_output=True,
)
self.assertEqual( self.assertEqual(
name2, name2,
cmd_output['name'], cmd_output['name'],
@ -57,10 +58,10 @@ class AddressGroupTests(common.NetworkTests):
def test_address_group_list(self): def test_address_group_list(self):
"""Test create, list filters, delete""" """Test create, list filters, delete"""
# Get project IDs # Get project IDs
cmd_output = json.loads(self.openstack('token issue -f json ')) cmd_output = self.openstack('token issue ', parse_output=True)
auth_project_id = cmd_output['project_id'] auth_project_id = cmd_output['project_id']
cmd_output = json.loads(self.openstack('project list -f json ')) cmd_output = self.openstack('project list ', parse_output=True)
admin_project_id = None admin_project_id = None
demo_project_id = None demo_project_id = None
for p in cmd_output: for p in cmd_output:
@ -79,10 +80,11 @@ class AddressGroupTests(common.NetworkTests):
self.assertEqual(admin_project_id, auth_project_id) self.assertEqual(admin_project_id, auth_project_id)
name1 = uuid.uuid4().hex name1 = uuid.uuid4().hex
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'address group create -f json ' + 'address group create ' +
name1 name1,
)) parse_output=True,
)
self.addCleanup(self.openstack, 'address group delete ' + name1) self.addCleanup(self.openstack, 'address group delete ' + name1)
self.assertEqual( self.assertEqual(
admin_project_id, admin_project_id,
@ -90,11 +92,12 @@ class AddressGroupTests(common.NetworkTests):
) )
name2 = uuid.uuid4().hex name2 = uuid.uuid4().hex
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'address group create -f json ' + 'address group create ' +
'--project ' + demo_project_id + '--project ' + demo_project_id +
' ' + name2 ' ' + name2,
)) parse_output=True,
)
self.addCleanup(self.openstack, 'address group delete ' + name2) self.addCleanup(self.openstack, 'address group delete ' + name2)
self.assertEqual( self.assertEqual(
demo_project_id, demo_project_id,
@ -102,27 +105,30 @@ class AddressGroupTests(common.NetworkTests):
) )
# Test list # Test list
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'address group list -f json ', 'address group list ',
)) parse_output=True,
)
names = [x["Name"] for x in cmd_output] names = [x["Name"] for x in cmd_output]
self.assertIn(name1, names) self.assertIn(name1, names)
self.assertIn(name2, names) self.assertIn(name2, names)
# Test list --project # Test list --project
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'address group list -f json ' + 'address group list ' +
'--project ' + demo_project_id '--project ' + demo_project_id,
)) parse_output=True,
)
names = [x["Name"] for x in cmd_output] names = [x["Name"] for x in cmd_output]
self.assertNotIn(name1, names) self.assertNotIn(name1, names)
self.assertIn(name2, names) self.assertIn(name2, names)
# Test list --name # Test list --name
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'address group list -f json ' + 'address group list ' +
'--name ' + name1 '--name ' + name1,
)) parse_output=True,
)
names = [x["Name"] for x in cmd_output] names = [x["Name"] for x in cmd_output]
self.assertIn(name1, names) self.assertIn(name1, names)
self.assertNotIn(name2, names) self.assertNotIn(name2, names)
@ -131,12 +137,13 @@ class AddressGroupTests(common.NetworkTests):
"""Tests create options, set, unset, and show""" """Tests create options, set, unset, and show"""
name = uuid.uuid4().hex name = uuid.uuid4().hex
newname = name + "_" newname = name + "_"
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'address group create -f json ' + 'address group create ' +
'--description aaaa ' + '--description aaaa ' +
'--address 10.0.0.1 --address 2001::/16 ' + '--address 10.0.0.1 --address 2001::/16 ' +
name name,
)) parse_output=True,
)
self.addCleanup(self.openstack, 'address group delete ' + newname) self.addCleanup(self.openstack, 'address group delete ' + newname)
self.assertEqual(name, cmd_output['name']) self.assertEqual(name, cmd_output['name'])
self.assertEqual('aaaa', cmd_output['description']) self.assertEqual('aaaa', cmd_output['description'])
@ -153,10 +160,11 @@ class AddressGroupTests(common.NetworkTests):
self.assertOutput('', raw_output) self.assertOutput('', raw_output)
# Show the updated address group # Show the updated address group
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'address group show -f json ' + 'address group show ' +
newname, newname,
)) parse_output=True,
)
self.assertEqual(newname, cmd_output['name']) self.assertEqual(newname, cmd_output['name'])
self.assertEqual('bbbb', cmd_output['description']) self.assertEqual('bbbb', cmd_output['description'])
self.assertEqual(4, len(cmd_output['addresses'])) self.assertEqual(4, len(cmd_output['addresses']))
@ -170,8 +178,9 @@ class AddressGroupTests(common.NetworkTests):
) )
self.assertEqual('', raw_output) self.assertEqual('', raw_output)
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'address group show -f json ' + 'address group show ' +
newname, newname,
)) parse_output=True,
)
self.assertEqual(0, len(cmd_output['addresses'])) self.assertEqual(0, len(cmd_output['addresses']))

74
openstackclient/tests/functional/network/v2/test_address_scope.py

@ -10,7 +10,6 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
import json
import uuid import uuid
from openstackclient.tests.functional.network.v2 import common from openstackclient.tests.functional.network.v2 import common
@ -33,10 +32,11 @@ class AddressScopeTests(common.NetworkTests):
def test_address_scope_delete(self): def test_address_scope_delete(self):
"""Test create, delete multiple""" """Test create, delete multiple"""
name1 = uuid.uuid4().hex name1 = uuid.uuid4().hex
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'address scope create -f json ' + 'address scope create ' +
name1 name1,
)) parse_output=True,
)
self.assertEqual( self.assertEqual(
name1, name1,
cmd_output['name'], cmd_output['name'],
@ -45,10 +45,11 @@ class AddressScopeTests(common.NetworkTests):
self.assertFalse(cmd_output['shared']) self.assertFalse(cmd_output['shared'])
name2 = uuid.uuid4().hex name2 = uuid.uuid4().hex
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'address scope create -f json ' + 'address scope create ' +
name2 name2,
)) parse_output=True,
)
self.assertEqual( self.assertEqual(
name2, name2,
cmd_output['name'], cmd_output['name'],
@ -62,12 +63,13 @@ class AddressScopeTests(common.NetworkTests):
def test_address_scope_list(self): def test_address_scope_list(self):
"""Test create defaults, list filters, delete""" """Test create defaults, list filters, delete"""
name1 = uuid.uuid4().hex name1 = uuid.uuid4().hex
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'address scope create -f json ' + 'address scope create ' +
'--ip-version 4 ' + '--ip-version 4 ' +
'--share ' + '--share ' +
name1 name1,
)) parse_output=True,
)
self.addCleanup(self.openstack, 'address scope delete ' + name1) self.addCleanup(self.openstack, 'address scope delete ' + name1)
self.assertEqual( self.assertEqual(
name1, name1,
@ -80,12 +82,13 @@ class AddressScopeTests(common.NetworkTests):
self.assertTrue(cmd_output['shared']) self.assertTrue(cmd_output['shared'])
name2 = uuid.uuid4().hex name2 = uuid.uuid4().hex
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'address scope create -f json ' + 'address scope create ' +
'--ip-version 6 ' + '--ip-version 6 ' +
'--no-share ' + '--no-share ' +
name2 name2,
)) parse_output=True,
)
self.addCleanup(self.openstack, 'address scope delete ' + name2) self.addCleanup(self.openstack, 'address scope delete ' + name2)
self.assertEqual( self.assertEqual(
name2, name2,
@ -98,25 +101,28 @@ class AddressScopeTests(common.NetworkTests):
self.assertFalse(cmd_output['shared']) self.assertFalse(cmd_output['shared'])
# Test list # Test list
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'address scope list -f json ', 'address scope list ',
)) parse_output=True,
)
col_data = [x["IP Version"] for x in cmd_output] col_data = [x["IP Version"] for x in cmd_output]
self.assertIn(4, col_data) self.assertIn(4, col_data)
self.assertIn(6, col_data) self.assertIn(6, col_data)
# Test list --share # Test list --share
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'address scope list -f json --share', 'address scope list --share',
)) parse_output=True,
)
col_data = [x["Shared"] for x in cmd_output] col_data = [x["Shared"] for x in cmd_output]
self.assertIn(True, col_data) self.assertIn(True, col_data)
self.assertNotIn(False, col_data) self.assertNotIn(False, col_data)
# Test list --no-share # Test list --no-share
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'address scope list -f json --no-share', 'address scope list --no-share',
)) parse_output=True,
)
col_data = [x["Shared"] for x in cmd_output] col_data = [x["Shared"] for x in cmd_output]
self.assertIn(False, col_data) self.assertIn(False, col_data)
self.assertNotIn(True, col_data) self.assertNotIn(True, col_data)
@ -125,12 +131,13 @@ class AddressScopeTests(common.NetworkTests):
"""Tests create options, set, show, delete""" """Tests create options, set, show, delete"""
name = uuid.uuid4().hex name = uuid.uuid4().hex
newname = name + "_" newname = name + "_"
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'address scope create -f json ' + 'address scope create ' +
'--ip-version 4 ' + '--ip-version 4 ' +
'--no-share ' + '--no-share ' +
name name,
)) parse_output=True,
)
self.addCleanup(self.openstack, 'address scope delete ' + newname) self.addCleanup(self.openstack, 'address scope delete ' + newname)
self.assertEqual( self.assertEqual(
name, name,
@ -150,10 +157,11 @@ class AddressScopeTests(common.NetworkTests):
) )
self.assertOutput('', raw_output) self.assertOutput('', raw_output)
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'address scope show -f json ' + 'address scope show ' +
newname, newname,
)) parse_output=True,
)
self.assertEqual( self.assertEqual(
newname, newname,
cmd_output['name'], cmd_output['name'],

125
openstackclient/tests/functional/network/v2/test_floating_ip.py

@ -10,7 +10,6 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
import json
import random import random
import uuid import uuid
@ -29,18 +28,20 @@ class FloatingIpTests(common.NetworkTests):
cls.PRIVATE_NETWORK_NAME = uuid.uuid4().hex cls.PRIVATE_NETWORK_NAME = uuid.uuid4().hex
# Create a network for the floating ip # Create a network for the floating ip
json_output = json.loads(cls.openstack( json_output = cls.openstack(
'network create -f json ' + 'network create ' +
'--external ' + '--external ' +
cls.EXTERNAL_NETWORK_NAME cls.EXTERNAL_NETWORK_NAME,
)) parse_output=True,
)
cls.external_network_id = json_output["id"] cls.external_network_id = json_output["id"]
# Create a private network for the port # Create a private network for the port
json_output = json.loads(cls.openstack( json_output = cls.openstack(
'network create -f json ' + 'network create ' +
cls.PRIVATE_NETWORK_NAME cls.PRIVATE_NETWORK_NAME,
)) parse_output=True,
)
cls.private_network_id = json_output["id"] cls.private_network_id = json_output["id"]
@classmethod @classmethod
@ -81,12 +82,13 @@ class FloatingIpTests(common.NetworkTests):
)) + ".0/26" )) + ".0/26"
try: try:
# Create a subnet for the network # Create a subnet for the network
json_output = json.loads(self.openstack( json_output = self.openstack(
'subnet create -f json ' + 'subnet create ' +
'--network ' + network_name + ' ' + '--network ' + network_name + ' ' +
'--subnet-range ' + subnet + ' ' + '--subnet-range ' + subnet + ' ' +
subnet_name subnet_name,
)) parse_output=True,
)
self.assertIsNotNone(json_output["id"]) self.assertIsNotNone(json_output["id"])
subnet_id = json_output["id"] subnet_id = json_output["id"]
except Exception: except Exception:
@ -109,11 +111,12 @@ class FloatingIpTests(common.NetworkTests):
) )
self.addCleanup(self.openstack, 'subnet delete ' + ext_subnet_id) self.addCleanup(self.openstack, 'subnet delete ' + ext_subnet_id)
json_output = json.loads(self.openstack( json_output = self.openstack(
'floating ip create -f json ' + 'floating ip create ' +
'--description aaaa ' + '--description aaaa ' +
self.EXTERNAL_NETWORK_NAME self.EXTERNAL_NETWORK_NAME,
)) parse_output=True,
)
self.assertIsNotNone(json_output["id"]) self.assertIsNotNone(json_output["id"])
ip1 = json_output["id"] ip1 = json_output["id"]
self.assertEqual( self.assertEqual(
@ -121,11 +124,12 @@ class FloatingIpTests(common.NetworkTests):
json_output["description"], json_output["description"],
) )
json_output = json.loads(self.openstack( json_output = self.openstack(
'floating ip create -f json ' + 'floating ip create ' +
'--description bbbb ' + '--description bbbb ' +
self.EXTERNAL_NETWORK_NAME self.EXTERNAL_NETWORK_NAME,
)) parse_output=True,
)
self.assertIsNotNone(json_output["id"]) self.assertIsNotNone(json_output["id"])
ip2 = json_output["id"] ip2 = json_output["id"]
self.assertEqual( self.assertEqual(
@ -149,11 +153,12 @@ class FloatingIpTests(common.NetworkTests):
) )
self.addCleanup(self.openstack, 'subnet delete ' + ext_subnet_id) self.addCleanup(self.openstack, 'subnet delete ' + ext_subnet_id)
json_output = json.loads(self.openstack( json_output = self.openstack(
'floating ip create -f json ' + 'floating ip create ' +
'--description aaaa ' + '--description aaaa ' +
self.EXTERNAL_NETWORK_NAME self.EXTERNAL_NETWORK_NAME,
)) parse_output=True,
)
self.assertIsNotNone(json_output["id"]) self.assertIsNotNone(json_output["id"])
ip1 = json_output["id"] ip1 = json_output["id"]
self.addCleanup(self.openstack, 'floating ip delete ' + ip1) self.addCleanup(self.openstack, 'floating ip delete ' + ip1)
@ -164,11 +169,12 @@ class FloatingIpTests(common.NetworkTests):
self.assertIsNotNone(json_output["floating_network_id"]) self.assertIsNotNone(json_output["floating_network_id"])
fip1 = json_output["floating_ip_address"] fip1 = json_output["floating_ip_address"]
json_output = json.loads(self.openstack( json_output = self.openstack(
'floating ip create -f json ' + 'floating ip create ' +
'--description bbbb ' + '--description bbbb ' +
self.EXTERNAL_NETWORK_NAME self.EXTERNAL_NETWORK_NAME,
)) parse_output=True,
)
self.assertIsNotNone(json_output["id"]) self.assertIsNotNone(json_output["id"])
ip2 = json_output["id"] ip2 = json_output["id"]
self.addCleanup(self.openstack, 'floating ip delete ' + ip2) self.addCleanup(self.openstack, 'floating ip delete ' + ip2)
@ -180,9 +186,10 @@ class FloatingIpTests(common.NetworkTests):
fip2 = json_output["floating_ip_address"] fip2 = json_output["floating_ip_address"]
# Test list # Test list
json_output = json.loads(self.openstack( json_output = self.openstack(
'floating ip list -f json' 'floating ip list',
)) parse_output=True,
)
fip_map = { fip_map = {
item.get('ID'): item.get('ID'):
item.get('Floating IP Address') for item in json_output item.get('Floating IP Address') for item in json_output
@ -194,10 +201,11 @@ class FloatingIpTests(common.NetworkTests):
self.assertIn(fip2, fip_map.values()) self.assertIn(fip2, fip_map.values())
# Test list --long # Test list --long
json_output = json.loads(self.openstack( json_output = self.openstack(
'floating ip list -f json ' + 'floating ip list ' +
'--long' '--long',
)) parse_output=True,
)
fip_map = { fip_map = {
item.get('ID'): item.get('ID'):
item.get('Floating IP Address') for item in json_output item.get('Floating IP Address') for item in json_output
@ -214,10 +222,11 @@ class FloatingIpTests(common.NetworkTests):
# TODO(dtroyer): add more filter tests # TODO(dtroyer): add more filter tests
json_output = json.loads(self.openstack( json_output = self.openstack(
'floating ip show -f json ' + 'floating ip show ' +
ip1 ip1,
)) parse_output=True,
)
self.assertIsNotNone(json_output["id"]) self.assertIsNotNone(json_output["id"])
self.assertEqual( self.assertEqual(
ip1, ip1,
@ -251,11 +260,12 @@ class FloatingIpTests(common.NetworkTests):
self.ROUTER = uuid.uuid4().hex self.ROUTER = uuid.uuid4().hex
self.PORT_NAME = uuid.uuid4().hex self.PORT_NAME = uuid.uuid4().hex
json_output = json.loads(self.openstack( json_output = self.openstack(
'floating ip create -f json ' + 'floating ip create ' +
'--description aaaa ' + '--description aaaa ' +
self.EXTERNAL_NETWORK_NAME self.EXTERNAL_NETWORK_NAME,
)) parse_output=True,
)
self.assertIsNotNone(json_output["id"]) self.assertIsNotNone(json_output["id"])
ip1 = json_output["id"] ip1 = json_output["id"]
self.addCleanup(self.openstack, 'floating ip delete ' + ip1) self.addCleanup(self.openstack, 'floating ip delete ' + ip1)
@ -264,19 +274,21 @@ class FloatingIpTests(common.NetworkTests):
json_output["description"], json_output["description"],
) )
json_output = json.loads(self.openstack( json_output = self.openstack(
'port create -f json ' + 'port create ' +
'--network ' + self.PRIVATE_NETWORK_NAME + ' ' + '--network ' + self.PRIVATE_NETWORK_NAME + ' ' +
'--fixed-ip subnet=' + priv_subnet_id + ' ' + '--fixed-ip subnet=' + priv_subnet_id + ' ' +
self.PORT_NAME self.PORT_NAME,
)) parse_output=True,
)
self.assertIsNotNone(json_output["id"]) self.assertIsNotNone(json_output["id"])
port_id = json_output["id"] port_id = json_output["id"]
json_output = json.loads(self.openstack( json_output = self.openstack(
'router create -f json ' + 'router create ' +
self.ROUTER self.ROUTER,
)) parse_output=True,
)
self.assertIsNotNone(json_output["id"]) self.assertIsNotNone(json_output["id"])
self.addCleanup(self.openstack, 'router delete ' + self.ROUTER) self.addCleanup(self.openstack, 'router delete ' + self.ROUTER)
@ -310,10 +322,11 @@ class FloatingIpTests(common.NetworkTests):
'floating ip unset --port ' + ip1, 'floating ip unset --port ' + ip1,
) )
json_output = json.loads(self.openstack( json_output = self.openstack(
'floating ip show -f json ' + 'floating ip show ' +
ip1 ip1,
)) parse_output=True,
)
self.assertEqual( self.assertEqual(
port_id, port_id,

20
openstackclient/tests/functional/network/v2/test_ip_availability.py

@ -10,7 +10,6 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
import json
import uuid import uuid
from openstackclient.tests.functional.network.v2 import common from openstackclient.tests.functional.network.v2 import common
@ -31,12 +30,13 @@ class IPAvailabilityTests(common.NetworkTests):
'network create ' + 'network create ' +
cls.NETWORK_NAME cls.NETWORK_NAME
) )
cmd_output = json.loads(cls.openstack( cmd_output = cls.openstack(
'subnet create -f json ' + 'subnet create ' +
'--network ' + cls.NETWORK_NAME + ' ' + '--network ' + cls.NETWORK_NAME + ' ' +
'--subnet-range 10.10.10.0/24 ' + '--subnet-range 10.10.10.0/24 ' +
cls.NAME cls.NAME,
)) parse_output=True,
)
cls.assertOutput(cls.NAME, cmd_output['name']) cls.assertOutput(cls.NAME, cmd_output['name'])
@classmethod @classmethod
@ -64,15 +64,17 @@ class IPAvailabilityTests(common.NetworkTests):
def test_ip_availability_list(self): def test_ip_availability_list(self):
"""Test ip availability list""" """Test ip availability list"""
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'ip availability list -f json')) 'ip availability list',
parse_output=True,)
names = [x['Network Name'] for x in cmd_output] names = [x['Network Name'] for x in cmd_output]
self.assertIn(self.NETWORK_NAME, names) self.assertIn(self.NETWORK_NAME, names)
def test_ip_availability_show(self): def test_ip_availability_show(self):
"""Test ip availability show""" """Test ip availability show"""
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'ip availability show -f json ' + self.NETWORK_NAME)) 'ip availability show ' + self.NETWORK_NAME,
parse_output=True,)
self.assertEqual( self.assertEqual(
self.NETWORK_NAME, self.NETWORK_NAME,
cmd_output['network_name'], cmd_output['network_name'],

44
openstackclient/tests/functional/network/v2/test_l3_conntrack_helper.py

@ -11,8 +11,6 @@
# under the License. # under the License.
# #
import json
import uuid import uuid
from openstackclient.tests.functional.network.v2 import common from openstackclient.tests.functional.network.v2 import common
@ -32,9 +30,10 @@ class L3ConntrackHelperTests(common.NetworkTests):
def _create_router(self): def _create_router(self):
router_name = uuid.uuid4().hex router_name = uuid.uuid4().hex
json_output = json.loads(self.openstack( json_output = self.openstack(
'router create -f json ' + router_name 'router create ' + router_name,
)) parse_output=True,
)
self.assertIsNotNone(json_output['id']) self.assertIsNotNone(json_output['id'])
router_id = json_output['id'] router_id = json_output['id']
self.addCleanup(self.openstack, 'router delete ' + router_id) self.addCleanup(self.openstack, 'router delete ' + router_id)
@ -43,13 +42,17 @@ class L3ConntrackHelperTests(common.NetworkTests):
def _create_helpers(self, router_id, helpers): def _create_helpers(self, router_id, helpers):
created_helpers = [] created_helpers = []
for helper in helpers: for helper in helpers:
output = json.loads(self.openstack( output = self.openstack(
'network l3 conntrack helper create %(router)s ' 'network l3 conntrack helper create %(router)s '
'--helper %(helper)s --protocol %(protocol)s --port %(port)s ' '--helper %(helper)s --protocol %(protocol)s '
'-f json' % {'router': router_id, '--port %(port)s ' % {
'router': router_id,
'helper': helper['helper'], 'helper': helper['helper'],
'protocol': helper['protocol'], 'protocol': helper['protocol'],
'port': helper['port']})) 'port': helper['port'],
},
parse_output=True,
)
self.assertEqual(helper['helper'], output['helper']) self.assertEqual(helper['helper'], output['helper'])
self.assertEqual(helper['protocol'], output['protocol']) self.assertEqual(helper['protocol'], output['protocol'])
self.assertEqual(helper['port'], output['port']) self.assertEqual(helper['port'], output['port'])
@ -105,9 +108,10 @@ class L3ConntrackHelperTests(common.NetworkTests):
] ]
router_id = self._create_router() router_id = self._create_router()
self._create_helpers(router_id, helpers) self._create_helpers(router_id, helpers)
output = json.loads(self.openstack( output = self.openstack(
'network l3 conntrack helper list %s -f json ' % router_id 'network l3 conntrack helper list %s ' % router_id,
)) parse_output=True,
)
for ct in output: for ct in output:
self.assertEqual(router_id, ct.pop('Router ID')) self.assertEqual(router_id, ct.pop('Router ID'))
ct.pop("ID") ct.pop("ID")
@ -120,10 +124,14 @@ class L3ConntrackHelperTests(common.NetworkTests):
'port': 69} 'port': 69}
router_id = self._create_router() router_id = self._create_router()
created_helper = self._create_helpers(router_id, [helper])[0] created_helper = self._create_helpers(router_id, [helper])[0]
output = json.loads(self.openstack( output = self.openstack(
'network l3 conntrack helper show %(router_id)s %(ct_id)s ' 'network l3 conntrack helper show %(router_id)s %(ct_id)s '
'-f json' % { '-f json' % {
'router_id': router_id, 'ct_id': created_helper['id']})) 'router_id': router_id,
'ct_id': created_helper['id'],
},
parse_output=True,
)
self.assertEqual(helper['helper'], output['helper']) self.assertEqual(helper['helper'], output['helper'])
self.assertEqual(helper['protocol'], output['protocol']) self.assertEqual(helper['protocol'], output['protocol'])
self.assertEqual(helper['port'], output['port']) self.assertEqual(helper['port'], output['port'])
@ -136,10 +144,14 @@ class L3ConntrackHelperTests(common.NetworkTests):
'port': helper['port'] + 1}) 'port': helper['port'] + 1})
self.assertOutput('', raw_output) self.assertOutput('', raw_output)
output = json.loads(self.openstack( output = self.openstack(
'network l3 conntrack helper show %(router_id)s %(ct_id)s ' 'network l3 conntrack helper show %(router_id)s %(ct_id)s '
'-f json' % { '-f json' % {
'router_id': router_id, 'ct_id': created_helper['id']})) 'router_id': router_id,
'ct_id': created_helper['id'],
},
parse_output=True,
)
self.assertEqual(helper['port'] + 1, output['port']) self.assertEqual(helper['port'] + 1, output['port'])
self.assertEqual(helper['helper'], output['helper']) self.assertEqual(helper['helper'], output['helper'])
self.assertEqual(helper['protocol'], output['protocol']) self.assertEqual(helper['protocol'], output['protocol'])

83
openstackclient/tests/functional/network/v2/test_local_ip.py

@ -11,9 +11,7 @@
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
#
import json
import uuid import uuid
from openstackclient.tests.functional.network.v2 import common from openstackclient.tests.functional.network.v2 import common
@ -33,20 +31,22 @@ class LocalIPTests(common.NetworkTests):
def test_local_ip_create_and_delete(self): def test_local_ip_create_and_delete(self):
"""Test create, delete multiple""" """Test create, delete multiple"""
name1 = uuid.uuid4().hex name1 = uuid.uuid4().hex
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'local ip create -f json ' + 'local ip create ' +
name1 name1,
)) parse_output=True,
)
self.assertEqual( self.assertEqual(
name1, name1,
cmd_output['name'], cmd_output['name'],
) )
name2 = uuid.uuid4().hex name2 = uuid.uuid4().hex
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'local ip create -f json ' + 'local ip create ' +
name2 name2,
)) parse_output=True,
)
self.assertEqual( self.assertEqual(
name2, name2,
cmd_output['name'], cmd_output['name'],
@ -60,10 +60,10 @@ class LocalIPTests(common.NetworkTests):
def test_local_ip_list(self): def test_local_ip_list(self):
"""Test create, list filters, delete""" """Test create, list filters, delete"""
# Get project IDs # Get project IDs
cmd_output = json.loads(self.openstack('token issue -f json ')) cmd_output = self.openstack('token issue ', parse_output=True)
auth_project_id = cmd_output['project_id'] auth_project_id = cmd_output['project_id']
cmd_output = json.loads(self.openstack('project list -f json ')) cmd_output = self.openstack('project list ', parse_output=True)
admin_project_id = None admin_project_id = None
demo_project_id = None demo_project_id = None
for p in cmd_output: for p in cmd_output:
@ -82,10 +82,11 @@ class LocalIPTests(common.NetworkTests):
self.assertEqual(admin_project_id, auth_project_id) self.assertEqual(admin_project_id, auth_project_id)
name1 = uuid.uuid4().hex name1 = uuid.uuid4().hex
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'local ip create -f json ' + 'local ip create ' +
name1 name1,
)) parse_output=True,
)
self.addCleanup(self.openstack, 'local ip delete ' + name1) self.addCleanup(self.openstack, 'local ip delete ' + name1)
self.assertEqual( self.assertEqual(
admin_project_id, admin_project_id,
@ -93,11 +94,12 @@ class LocalIPTests(common.NetworkTests):
) )
name2 = uuid.uuid4().hex name2 = uuid.uuid4().hex
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'local ip create -f json ' + 'local ip create ' +
'--project ' + demo_project_id + '--project ' + demo_project_id +
' ' + name2 ' ' + name2,
)) parse_output=True,
)
self.addCleanup(self.openstack, 'local ip delete ' + name2) self.addCleanup(self.openstack, 'local ip delete ' + name2)
self.assertEqual( self.assertEqual(
demo_project_id, demo_project_id,
@ -105,27 +107,30 @@ class LocalIPTests(common.NetworkTests):
) )
# Test list # Test list
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'local ip list -f json ', 'local ip list ',
)) parse_output=True,
)
names = [x["Name"] for x in cmd_output] names = [x["Name"] for x in cmd_output]
self.assertIn(name1, names) self.assertIn(name1, names)
self.assertIn(name2, names) self.assertIn(name2, names)
# Test list --project # Test list --project
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'local ip list -f json ' + 'local ip list ' +
'--project ' + demo_project_id '--project ' + demo_project_id,
)) parse_output=True,
)
names = [x["Name"] for x in cmd_output] names = [x["Name"] for x in cmd_output]
self.assertNotIn(name1, names) self.assertNotIn(name1, names)
self.assertIn(name2, names) self.assertIn(name2, names)
# Test list --name # Test list --name
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'local ip list -f json ' + 'local ip list ' +
'--name ' + name1 '--name ' + name1,
)) parse_output=True,
)
names = [x["Name"] for x in cmd_output] names = [x["Name"] for x in cmd_output]
self.assertIn(name1, names) self.assertIn(name1, names)
self.assertNotIn(name2, names) self.assertNotIn(name2, names)
@ -134,11 +139,12 @@ class LocalIPTests(common.NetworkTests):
"""Tests create options, set, and show""" """Tests create options, set, and show"""
name = uuid.uuid4().hex name = uuid.uuid4().hex
newname = name + "_" newname = name + "_"
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'local ip create -f json ' + 'local ip create ' +
'--description aaaa ' + '--description aaaa ' +
name name,
)) parse_output=True,
)
self.addCleanup(self.openstack, 'local ip delete ' + newname) self.addCleanup(self.openstack, 'local ip delete ' + newname)
self.assertEqual(name, cmd_output['name']) self.assertEqual(name, cmd_output['name'])
self.assertEqual('aaaa', cmd_output['description']) self.assertEqual('aaaa', cmd_output['description'])
@ -153,9 +159,10 @@ class LocalIPTests(common.NetworkTests):
self.assertOutput('', raw_output) self.assertOutput('', raw_output)
# Show the updated local ip # Show the updated local ip
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'local ip show -f json ' + 'local ip show ' +
newname, newname,
)) parse_output=True,
)
self.assertEqual(newname, cmd_output['name']) self.assertEqual(newname, cmd_output['name'])
self.assertEqual('bbbb', cmd_output['description']) self.assertEqual('bbbb', cmd_output['description'])

174
openstackclient/tests/functional/network/v2/test_network.py

@ -10,7 +10,6 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
import json
import uuid import uuid
from openstackclient.tests.functional.network.v2 import common from openstackclient.tests.functional.network.v2 import common
@ -34,11 +33,12 @@ class NetworkTests(common.NetworkTagTests):
# Network create with minimum options # Network create with minimum options
name1 = uuid.uuid4().hex name1 = uuid.uuid4().hex
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'network create -f json ' + 'network create ' +
'--subnet 1.2.3.4/28 ' + '--subnet 1.2.3.4/28 ' +
name1 name1,
)) parse_output=True,
)
self.addCleanup(self.openstack, 'network delete ' + name1) self.addCleanup(self.openstack, 'network delete ' + name1)
self.assertIsNotNone(cmd_output["id"]) self.assertIsNotNone(cmd_output["id"])
@ -53,12 +53,13 @@ class NetworkTests(common.NetworkTagTests):
# Network create with more options # Network create with more options
name2 = uuid.uuid4().hex name2 = uuid.uuid4().hex
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'network create -f json ' + 'network create ' +
'--subnet 1.2.4.4/28 ' + '--subnet 1.2.4.4/28 ' +
'--share ' + '--share ' +
name2 name2,
)) parse_output=True,
)
self.addCleanup(self.openstack, 'network delete ' + name2) self.addCleanup(self.openstack, 'network delete ' + name2)
self.assertIsNotNone(cmd_output["id"]) self.assertIsNotNone(cmd_output["id"])
@ -80,10 +81,10 @@ class NetworkTests(common.NetworkTagTests):
self.skipTest("No Network service present") self.skipTest("No Network service present")
# Get project IDs # Get project IDs
cmd_output = json.loads(self.openstack('token issue -f json ')) cmd_output = self.openstack('token issue ', parse_output=True)
auth_project_id = cmd_output['project_id'] auth_project_id = cmd_output['project_id']
cmd_output = json.loads(self.openstack('project list -f json ')) cmd_output = self.openstack('project list ', parse_output=True)
admin_project_id = None admin_project_id = None
demo_project_id = None demo_project_id = None
for p in cmd_output: for p in cmd_output:
@ -103,10 +104,11 @@ class NetworkTests(common.NetworkTagTests):
# Network create with no options # Network create with no options
name1 = uuid.uuid4().hex name1 = uuid.uuid4().hex
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'network create -f json ' + 'network create ' +
name1 name1,
)) parse_output=True,
)
self.addCleanup(self.openstack, 'network delete ' + name1) self.addCleanup(self.openstack, 'network delete ' + name1)
self.assertIsNotNone(cmd_output["id"]) self.assertIsNotNone(cmd_output["id"])
@ -133,11 +135,12 @@ class NetworkTests(common.NetworkTagTests):
# Network create with options # Network create with options
name2 = uuid.uuid4().hex name2 = uuid.uuid4().hex
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'network create -f json ' + 'network create ' +
'--project demo ' + '--project demo ' +
name2 name2,
)) parse_output=True,
)
self.addCleanup(self.openstack, 'network delete ' + name2) self.addCleanup(self.openstack, 'network delete ' + name2)
self.assertIsNotNone(cmd_output["id"]) self.assertIsNotNone(cmd_output["id"])
self.assertEqual( self.assertEqual(
@ -155,11 +158,12 @@ class NetworkTests(common.NetworkTagTests):
self.skipTest("Skip Nova-net test") self.skipTest("Skip Nova-net test")
name1 = uuid.uuid4().hex name1 = uuid.uuid4().hex
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'network create -f json ' + 'network create ' +
'--subnet 9.8.7.6/28 ' + '--subnet 9.8.7.6/28 ' +
name1 name1,
)) parse_output=True,
)
self.assertIsNotNone(cmd_output["id"]) self.assertIsNotNone(cmd_output["id"])
self.assertEqual( self.assertEqual(
name1, name1,
@ -167,11 +171,12 @@ class NetworkTests(common.NetworkTagTests):
) )
name2 = uuid.uuid4().hex name2 = uuid.uuid4().hex
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'network create -f json ' + 'network create ' +
'--subnet 8.7.6.5/28 ' + '--subnet 8.7.6.5/28 ' +
name2 name2,
)) parse_output=True,
)
self.assertIsNotNone(cmd_output["id"]) self.assertIsNotNone(cmd_output["id"])
self.assertEqual( self.assertEqual(
name2, name2,
@ -184,11 +189,12 @@ class NetworkTests(common.NetworkTagTests):
self.skipTest("No Network service present") self.skipTest("No Network service present")
name1 = uuid.uuid4().hex name1 = uuid.uuid4().hex
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'network create -f json ' + 'network create ' +
'--description aaaa ' + '--description aaaa ' +
name1 name1,
)) parse_output=True,
)
self.assertIsNotNone(cmd_output["id"]) self.assertIsNotNone(cmd_output["id"])
self.assertEqual( self.assertEqual(
'aaaa', 'aaaa',
@ -196,11 +202,12 @@ class NetworkTests(common.NetworkTagTests):
) )
name2 = uuid.uuid4().hex name2 = uuid.uuid4().hex
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'network create -f json ' + 'network create ' +
'--description bbbb ' + '--description bbbb ' +
name2 name2,
)) parse_output=True,
)
self.assertIsNotNone(cmd_output["id"]) self.assertIsNotNone(cmd_output["id"])
self.assertEqual( self.assertEqual(
'bbbb', 'bbbb',
@ -217,11 +224,12 @@ class NetworkTests(common.NetworkTagTests):
network_options = '--description aaaa --no-default ' network_options = '--description aaaa --no-default '
else: else:
network_options = '--subnet 3.4.5.6/28 ' network_options = '--subnet 3.4.5.6/28 '
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'network create -f json ' + 'network create ' +
network_options + network_options +
name1 name1,
)) parse_output=True,
)
self.addCleanup(self.openstack, 'network delete %s' % name1) self.addCleanup(self.openstack, 'network delete %s' % name1)
self.assertIsNotNone(cmd_output["id"]) self.assertIsNotNone(cmd_output["id"])
if self.haz_network: if self.haz_network:
@ -254,10 +262,11 @@ class NetworkTests(common.NetworkTagTests):
network_options = '--description bbbb --disable ' network_options = '--description bbbb --disable '
else: else:
network_options = '--subnet 4.5.6.7/28 ' network_options = '--subnet 4.5.6.7/28 '
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'network create -f json --share %s%s' % 'network create --share %s%s' %
(network_options, name2) (network_options, name2),
)) parse_output=True,
)
self.addCleanup(self.openstack, 'network delete ' + name2) self.addCleanup(self.openstack, 'network delete ' + name2)
self.assertIsNotNone(cmd_output["id"]) self.assertIsNotNone(cmd_output["id"])
if self.haz_network: if self.haz_network:
@ -280,54 +289,60 @@ class NetworkTests(common.NetworkTagTests):
self.assertTrue(cmd_output["share_address"]) self.assertTrue(cmd_output["share_address"])
# Test list # Test list
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
"network list -f json " "network list ",
)) parse_output=True,
)
col_name = [x["Name"] for x in cmd_output] col_name = [x["Name"] for x in cmd_output]
self.assertIn(name1, col_name) self.assertIn(name1, col_name)
self.assertIn(name2, col_name) self.assertIn(name2, col_name)
# Test list --long # Test list --long
if self.haz_network: if self.haz_network:
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
"network list -f json --long" "network list --long",
)) parse_output=True,
)
col_name = [x["Name"] for x in cmd_output] col_name = [x["Name"] for x in cmd_output]
self.assertIn(name1, col_name) self.assertIn(name1, col_name)
self.assertIn(name2, col_name) self.assertIn(name2, col_name)
# Test list --long --enable # Test list --long --enable
if self.haz_network: if self.haz_network:
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
"network list -f json --enable --long" "network list --enable --long",
)) parse_output=True,
)
col_name = [x["Name"] for x in cmd_output] col_name = [x["Name"] for x in cmd_output]
self.assertIn(name1, col_name) self.assertIn(name1, col_name)
self.assertNotIn(name2, col_name) self.assertNotIn(name2, col_name)
# Test list --long --disable # Test list --long --disable
if self.haz_network: if self.haz_network:
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
"network list -f json --disable --long" "network list --disable --long",
)) parse_output=True,
)
col_name = [x["Name"] for x in cmd_output] col_name = [x["Name"] for x in cmd_output]
self.assertNotIn(name1, col_name) self.assertNotIn(name1, col_name)
self.assertIn(name2, col_name) self.assertIn(name2, col_name)
# Test list --share # Test list --share
if self.haz_network: if self.haz_network:
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
"network list -f json --share " "network list --share ",
)) parse_output=True,
)
col_name = [x["Name"] for x in cmd_output] col_name = [x["Name"] for x in cmd_output]
self.assertNotIn(name1, col_name) self.assertNotIn(name1, col_name)
self.assertIn(name2, col_name) self.assertIn(name2, col_name)
# Test list --no-share # Test list --no-share
if self.haz_network: if self.haz_network:
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
"network list -f json --no-share " "network list --no-share ",
)) parse_output=True,
)
col_name = [x["Name"] for x in cmd_output] col_name = [x["Name"] for x in cmd_output]
self.assertIn(name1, col_name) self.assertIn(name1, col_name)
self.assertNotIn(name2, col_name) self.assertNotIn(name2, col_name)
@ -339,9 +354,10 @@ class NetworkTests(common.NetworkTagTests):
self.skipTest("No dhcp_agent_scheduler extension present") self.skipTest("No dhcp_agent_scheduler extension present")
name1 = uuid.uuid4().hex name1 = uuid.uuid4().hex
cmd_output1 = json.loads(self.openstack( cmd_output1 = self.openstack(
'network create -f json --description aaaa %s' % name1 'network create --description aaaa %s' % name1,
)) parse_output=True,
)
self.addCleanup(self.openstack, 'network delete %s' % name1) self.addCleanup(self.openstack, 'network delete %s' % name1)
@ -349,9 +365,10 @@ class NetworkTests(common.NetworkTagTests):
network_id = cmd_output1['id'] network_id = cmd_output1['id']
# Get DHCP Agent ID # Get DHCP Agent ID
cmd_output2 = json.loads(self.openstack( cmd_output2 = self.openstack(
'network agent list -f json --agent-type dhcp' 'network agent list --agent-type dhcp',
)) parse_output=True,
)
agent_id = cmd_output2[0]['ID'] agent_id = cmd_output2[0]['ID']
# Add Agent to Network # Add Agent to Network
@ -360,9 +377,10 @@ class NetworkTests(common.NetworkTagTests):
) )
# Test network list --agent # Test network list --agent
cmd_output3 = json.loads(self.openstack( cmd_output3 = self.openstack(
'network list -f json --agent %s' % agent_id 'network list --agent %s' % agent_id,
)) parse_output=True,
)
# Cleanup # Cleanup
# Remove Agent from Network # Remove Agent from Network
@ -383,16 +401,17 @@ class NetworkTests(common.NetworkTagTests):
self.skipTest("No Network service present") self.skipTest("No Network service present")
name = uuid.uuid4().hex name = uuid.uuid4().hex
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'network create -f json ' 'network create '
'--description aaaa ' '--description aaaa '
'--enable ' '--enable '
'--no-share ' '--no-share '
'--internal ' '--internal '
'--no-default ' '--no-default '
'--enable-port-security %s' % '--enable-port-security %s' %
name name,
)) parse_output=True,
)
self.addCleanup(self.openstack, 'network delete %s' % name) self.addCleanup(self.openstack, 'network delete %s' % name)
self.assertIsNotNone(cmd_output["id"]) self.assertIsNotNone(cmd_output["id"])
self.assertEqual( self.assertEqual(
@ -425,9 +444,10 @@ class NetworkTests(common.NetworkTagTests):
) )
self.assertOutput('', raw_output) self.assertOutput('', raw_output)
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'network show -f json ' + name 'network show ' + name,
)) parse_output=True,
)
self.assertEqual( self.assertEqual(
'cccc', 'cccc',

70
openstackclient/tests/functional/network/v2/test_network_agent.py

@ -10,7 +10,6 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
import json
import uuid import uuid
from openstackclient.tests.functional.network.v2 import common from openstackclient.tests.functional.network.v2 import common
@ -33,17 +32,19 @@ class NetworkAgentTests(common.NetworkTests):
""" """
# agent list # agent list
agent_list = json.loads(self.openstack( agent_list = self.openstack(
'network agent list -f json' 'network agent list',
)) parse_output=True,
)
self.assertIsNotNone(agent_list[0]) self.assertIsNotNone(agent_list[0])
agent_ids = list([row["ID"] for row in agent_list]) agent_ids = list([row["ID"] for row in agent_list])
# agent show # agent show
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'network agent show -f json %s' % agent_ids[0] 'network agent show %s' % agent_ids[0],
)) parse_output=True,
)
self.assertEqual( self.assertEqual(
agent_ids[0], agent_ids[0],
cmd_output['id'], cmd_output['id'],
@ -60,9 +61,10 @@ class NetworkAgentTests(common.NetworkTests):
) )
self.assertOutput('', raw_output) self.assertOutput('', raw_output)
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'network agent show -f json %s' % agent_ids[0] 'network agent show %s' % agent_ids[0],
)) parse_output=True,
)
self.assertEqual( self.assertEqual(
False, False,
cmd_output['admin_state_up'], cmd_output['admin_state_up'],
@ -73,9 +75,10 @@ class NetworkAgentTests(common.NetworkTests):
) )
self.assertOutput('', raw_output) self.assertOutput('', raw_output)
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'network agent show -f json %s' % agent_ids[0] 'network agent show %s' % agent_ids[0],
)) parse_output=True,
)
self.assertEqual( self.assertEqual(
True, True,
cmd_output['admin_state_up'], cmd_output['admin_state_up'],
@ -98,9 +101,10 @@ class NetworkAgentListTests(common.NetworkTests):
self.skipTest("No dhcp_agent_scheduler extension present") self.skipTest("No dhcp_agent_scheduler extension present")
name1 = uuid.uuid4().hex name1 = uuid.uuid4().hex
cmd_output1 = json.loads(self.openstack( cmd_output1 = self.openstack(
'network create -f json --description aaaa %s' % name1 'network create --description aaaa %s' % name1,
)) parse_output=True,
)
self.addCleanup(self.openstack, 'network delete %s' % name1) self.addCleanup(self.openstack, 'network delete %s' % name1)
@ -108,9 +112,10 @@ class NetworkAgentListTests(common.NetworkTests):
network_id = cmd_output1['id'] network_id = cmd_output1['id']
# Get DHCP Agent ID # Get DHCP Agent ID
cmd_output2 = json.loads(self.openstack( cmd_output2 = self.openstack(
'network agent list -f json --agent-type dhcp' 'network agent list --agent-type dhcp',
)) parse_output=True,
)
agent_id = cmd_output2[0]['ID'] agent_id = cmd_output2[0]['ID']
# Add Agent to Network # Add Agent to Network
@ -120,9 +125,10 @@ class NetworkAgentListTests(common.NetworkTests):
) )
# Test network agent list --network # Test network agent list --network
cmd_output3 = json.loads(self.openstack( cmd_output3 = self.openstack(
'network agent list -f json --network %s' % network_id 'network agent list --network %s' % network_id,
)) parse_output=True,
)
# Cleanup # Cleanup
# Remove Agent from Network # Remove Agent from Network
@ -144,15 +150,17 @@ class NetworkAgentListTests(common.NetworkTests):
self.skipTest("No l3_agent_scheduler extension present") self.skipTest("No l3_agent_scheduler extension present")
name = uuid.uuid4().hex name = uuid.uuid4().hex
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'router create -f json %s' % name)) 'router create %s' % name,
parse_output=True,)
self.addCleanup(self.openstack, 'router delete %s' % name) self.addCleanup(self.openstack, 'router delete %s' % name)
# Get router ID # Get router ID
router_id = cmd_output['id'] router_id = cmd_output['id']
# Get l3 agent id # Get l3 agent id
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'network agent list -f json --agent-type l3')) 'network agent list --agent-type l3',
parse_output=True,)
# Check at least one L3 agent is included in the response. # Check at least one L3 agent is included in the response.
self.assertTrue(cmd_output) self.assertTrue(cmd_output)
@ -163,8 +171,9 @@ class NetworkAgentListTests(common.NetworkTests):
'network agent add router --l3 %s %s' % (agent_id, router_id)) 'network agent add router --l3 %s %s' % (agent_id, router_id))
# Test router list --agent # Test router list --agent
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'network agent list -f json --router %s' % router_id)) 'network agent list --router %s' % router_id,
parse_output=True,)
agent_ids = [x['ID'] for x in cmd_output] agent_ids = [x['ID'] for x in cmd_output]
self.assertIn(agent_id, agent_ids) self.assertIn(agent_id, agent_ids)
@ -172,7 +181,8 @@ class NetworkAgentListTests(common.NetworkTests):
# Remove router from agent # Remove router from agent
self.openstack( self.openstack(
'network agent remove router --l3 %s %s' % (agent_id, router_id)) 'network agent remove router --l3 %s %s' % (agent_id, router_id))
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'network agent list -f json --router %s' % router_id)) 'network agent list --router %s' % router_id,
parse_output=True,)
agent_ids = [x['ID'] for x in cmd_output] agent_ids = [x['ID'] for x in cmd_output]
self.assertNotIn(agent_id, agent_ids) self.assertNotIn(agent_id, agent_ids)

89
openstackclient/tests/functional/network/v2/test_network_flavor.py

@ -10,8 +10,6 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
import json
import uuid import uuid
from openstackclient.tests.functional.network.v2 import common from openstackclient.tests.functional.network.v2 import common
@ -30,17 +28,19 @@ class NetworkFlavorTests(common.NetworkTests):
"""Test add and remove network flavor to/from profile""" """Test add and remove network flavor to/from profile"""
# Create Flavor # Create Flavor
name1 = uuid.uuid4().hex name1 = uuid.uuid4().hex
cmd_output1 = json.loads(self.openstack( cmd_output1 = self.openstack(
'network flavor create -f json --description testdescription ' 'network flavor create --description testdescription '
'--enable --service-type L3_ROUTER_NAT ' + name1, '--enable --service-type L3_ROUTER_NAT ' + name1,
)) parse_output=True,
)
flavor_id = cmd_output1.get('id') flavor_id = cmd_output1.get('id')
# Create Service Flavor # Create Service Flavor
cmd_output2 = json.loads(self.openstack( cmd_output2 = self.openstack(
'network flavor profile create -f json --description ' 'network flavor profile create --description '
'fakedescription --enable --metainfo Extrainfo' 'fakedescription --enable --metainfo Extrainfo',
)) parse_output=True,
)
service_profile_id = cmd_output2.get('id') service_profile_id = cmd_output2.get('id')
self.addCleanup(self.openstack, 'network flavor delete %s' % self.addCleanup(self.openstack, 'network flavor delete %s' %
@ -53,9 +53,10 @@ class NetworkFlavorTests(common.NetworkTests):
flavor_id + ' ' + service_profile_id flavor_id + ' ' + service_profile_id
) )
cmd_output4 = json.loads(self.openstack( cmd_output4 = self.openstack(
'network flavor show -f json ' + flavor_id 'network flavor show ' + flavor_id,
)) parse_output=True,
)
service_profile_ids1 = cmd_output4.get('service_profile_ids') service_profile_ids1 = cmd_output4.get('service_profile_ids')
# Assert # Assert
@ -68,9 +69,10 @@ class NetworkFlavorTests(common.NetworkTests):
flavor_id + ' ' + service_profile_id flavor_id + ' ' + service_profile_id
) )
cmd_output6 = json.loads(self.openstack( cmd_output6 = self.openstack(
'network flavor show -f json ' + flavor_id 'network flavor show ' + flavor_id,
)) parse_output=True,
)
service_profile_ids2 = cmd_output6.get('service_profile_ids') service_profile_ids2 = cmd_output6.get('service_profile_ids')
# Assert # Assert
@ -79,10 +81,11 @@ class NetworkFlavorTests(common.NetworkTests):
def test_network_flavor_delete(self): def test_network_flavor_delete(self):
"""Test create, delete multiple""" """Test create, delete multiple"""
name1 = uuid.uuid4().hex name1 = uuid.uuid4().hex
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'network flavor create -f json --description testdescription ' 'network flavor create --description testdescription '
'--enable --service-type L3_ROUTER_NAT ' + name1, '--enable --service-type L3_ROUTER_NAT ' + name1,
)) parse_output=True,
)
self.assertEqual( self.assertEqual(
name1, name1,
cmd_output['name'], cmd_output['name'],
@ -94,10 +97,11 @@ class NetworkFlavorTests(common.NetworkTests):
) )
name2 = uuid.uuid4().hex name2 = uuid.uuid4().hex
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'network flavor create -f json --description testdescription1 ' 'network flavor create --description testdescription1 '
'--disable --service-type L3_ROUTER_NAT ' + name2, '--disable --service-type L3_ROUTER_NAT ' + name2,
)) parse_output=True,
)
self.assertEqual( self.assertEqual(
name2, name2,
cmd_output['name'], cmd_output['name'],
@ -114,10 +118,11 @@ class NetworkFlavorTests(common.NetworkTests):
def test_network_flavor_list(self): def test_network_flavor_list(self):
"""Test create defaults, list filters, delete""" """Test create defaults, list filters, delete"""
name1 = uuid.uuid4().hex name1 = uuid.uuid4().hex
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'network flavor create -f json --description testdescription ' 'network flavor create --description testdescription '
'--enable --service-type L3_ROUTER_NAT ' + name1, '--enable --service-type L3_ROUTER_NAT ' + name1,
)) parse_output=True,
)
self.addCleanup(self.openstack, "network flavor delete " + name1) self.addCleanup(self.openstack, "network flavor delete " + name1)
self.assertEqual( self.assertEqual(
name1, name1,
@ -133,10 +138,11 @@ class NetworkFlavorTests(common.NetworkTests):
) )
name2 = uuid.uuid4().hex name2 = uuid.uuid4().hex
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'network flavor create -f json --description testdescription1 ' 'network flavor create --description testdescription1 '
'--disable --service-type L3_ROUTER_NAT ' + name2, '--disable --service-type L3_ROUTER_NAT ' + name2,
)) parse_output=True,
)
self.assertEqual( self.assertEqual(
name2, name2,
cmd_output['name'], cmd_output['name'],
@ -152,8 +158,9 @@ class NetworkFlavorTests(common.NetworkTests):
self.addCleanup(self.openstack, "network flavor delete " + name2) self.addCleanup(self.openstack, "network flavor delete " + name2)
# Test list # Test list
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'network flavor list -f json ',)) 'network flavor list ',
parse_output=True,)
self.assertIsNotNone(cmd_output) self.assertIsNotNone(cmd_output)
name_list = [item.get('Name') for item in cmd_output] name_list = [item.get('Name') for item in cmd_output]
@ -164,10 +171,11 @@ class NetworkFlavorTests(common.NetworkTests):
"""Tests create options, set, show, delete""" """Tests create options, set, show, delete"""
name = uuid.uuid4().hex name = uuid.uuid4().hex
newname = name + "_" newname = name + "_"
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'network flavor create -f json --description testdescription ' 'network flavor create --description testdescription '
'--disable --service-type L3_ROUTER_NAT ' + name, '--disable --service-type L3_ROUTER_NAT ' + name,
)) parse_output=True,
)
self.addCleanup(self.openstack, "network flavor delete " + newname) self.addCleanup(self.openstack, "network flavor delete " + newname)
self.assertEqual( self.assertEqual(
name, name,
@ -187,8 +195,9 @@ class NetworkFlavorTests(common.NetworkTests):
) )
self.assertOutput('', raw_output) self.assertOutput('', raw_output)
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'network flavor show -f json ' + newname,)) 'network flavor show ' + newname,
parse_output=True,)
self.assertEqual( self.assertEqual(
newname, newname,
cmd_output['name'], cmd_output['name'],
@ -205,13 +214,15 @@ class NetworkFlavorTests(common.NetworkTests):
def test_network_flavor_show(self): def test_network_flavor_show(self):
"""Test show network flavor""" """Test show network flavor"""
name = uuid.uuid4().hex name = uuid.uuid4().hex
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'network flavor create -f json --description testdescription ' 'network flavor create --description testdescription '
'--disable --service-type L3_ROUTER_NAT ' + name, '--disable --service-type L3_ROUTER_NAT ' + name,
)) parse_output=True,
)
self.addCleanup(self.openstack, "network flavor delete " + name) self.addCleanup(self.openstack, "network flavor delete " + name)
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'network flavor show -f json ' + name,)) 'network flavor show ' + name,
parse_output=True,)
self.assertEqual( self.assertEqual(
name, name,
cmd_output['name'], cmd_output['name'],

68
openstackclient/tests/functional/network/v2/test_network_flavor_profile.py

@ -10,8 +10,6 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
import json
from openstackclient.tests.functional.network.v2 import common from openstackclient.tests.functional.network.v2 import common
@ -28,11 +26,12 @@ class NetworkFlavorProfileTests(common.NetworkTests):
self.skipTest("No Network service present") self.skipTest("No Network service present")
def test_network_flavor_profile_create(self): def test_network_flavor_profile_create(self):
json_output = json.loads(self.openstack( json_output = self.openstack(
'network flavor profile create -f json ' + 'network flavor profile create ' +
'--description ' + self.DESCRIPTION + ' ' + '--description ' + self.DESCRIPTION + ' ' +
'--enable --metainfo ' + self.METAINFO '--enable --metainfo ' + self.METAINFO,
)) parse_output=True,
)
ID = json_output.get('id') ID = json_output.get('id')
self.assertIsNotNone(ID) self.assertIsNotNone(ID)
self.assertTrue(json_output.get('enabled')) self.assertTrue(json_output.get('enabled'))
@ -50,12 +49,13 @@ class NetworkFlavorProfileTests(common.NetworkTests):
self.assertOutput('', raw_output) self.assertOutput('', raw_output)
def test_network_flavor_profile_list(self): def test_network_flavor_profile_list(self):
json_output = json.loads(self.openstack( json_output = self.openstack(
'network flavor profile create -f json ' + 'network flavor profile create ' +
'--description ' + self.DESCRIPTION + ' ' + '--description ' + self.DESCRIPTION + ' ' +
'--enable ' + '--enable ' +
'--metainfo ' + self.METAINFO '--metainfo ' + self.METAINFO,
)) parse_output=True,
)
ID1 = json_output.get('id') ID1 = json_output.get('id')
self.assertIsNotNone(ID1) self.assertIsNotNone(ID1)
self.assertTrue(json_output.get('enabled')) self.assertTrue(json_output.get('enabled'))
@ -68,12 +68,13 @@ class NetworkFlavorProfileTests(common.NetworkTests):
json_output.get('meta_info'), json_output.get('meta_info'),
) )
json_output = json.loads(self.openstack( json_output = self.openstack(
'network flavor profile create -f json ' + 'network flavor profile create ' +
'--description ' + self.DESCRIPTION + ' ' + '--description ' + self.DESCRIPTION + ' ' +
'--disable ' + '--disable ' +
'--metainfo ' + self.METAINFO '--metainfo ' + self.METAINFO,
)) parse_output=True,
)
ID2 = json_output.get('id') ID2 = json_output.get('id')
self.assertIsNotNone(ID2) self.assertIsNotNone(ID2)
self.assertFalse(json_output.get('enabled')) self.assertFalse(json_output.get('enabled'))
@ -87,9 +88,10 @@ class NetworkFlavorProfileTests(common.NetworkTests):
) )
# Test list # Test list
json_output = json.loads(self.openstack( json_output = self.openstack(
'network flavor profile list -f json' 'network flavor profile list',
)) parse_output=True,
)
self.assertIsNotNone(json_output) self.assertIsNotNone(json_output)
id_list = [item.get('ID') for item in json_output] id_list = [item.get('ID') for item in json_output]
@ -103,12 +105,13 @@ class NetworkFlavorProfileTests(common.NetworkTests):
self.assertOutput('', raw_output) self.assertOutput('', raw_output)
def test_network_flavor_profile_set(self): def test_network_flavor_profile_set(self):
json_output_1 = json.loads(self.openstack( json_output_1 = self.openstack(
'network flavor profile create -f json ' + 'network flavor profile create ' +
'--description ' + self.DESCRIPTION + ' ' + '--description ' + self.DESCRIPTION + ' ' +
'--enable ' + '--enable ' +
'--metainfo ' + self.METAINFO '--metainfo ' + self.METAINFO,
)) parse_output=True,
)
ID = json_output_1.get('id') ID = json_output_1.get('id')
self.assertIsNotNone(ID) self.assertIsNotNone(ID)
self.assertTrue(json_output_1.get('enabled')) self.assertTrue(json_output_1.get('enabled'))
@ -123,9 +126,10 @@ class NetworkFlavorProfileTests(common.NetworkTests):
self.openstack('network flavor profile set --disable ' + ID) self.openstack('network flavor profile set --disable ' + ID)
json_output = json.loads(self.openstack( json_output = self.openstack(
'network flavor profile show -f json ' + ID 'network flavor profile show ' + ID,
)) parse_output=True,
)
self.assertFalse(json_output.get('enabled')) self.assertFalse(json_output.get('enabled'))
self.assertEqual( self.assertEqual(
'fakedescription', 'fakedescription',
@ -141,17 +145,19 @@ class NetworkFlavorProfileTests(common.NetworkTests):
self.assertOutput('', raw_output) self.assertOutput('', raw_output)
def test_network_flavor_profile_show(self): def test_network_flavor_profile_show(self):
json_output_1 = json.loads(self.openstack( json_output_1 = self.openstack(
'network flavor profile create -f json ' + 'network flavor profile create ' +
'--description ' + self.DESCRIPTION + ' ' + '--description ' + self.DESCRIPTION + ' ' +
'--enable ' + '--enable ' +
'--metainfo ' + self.METAINFO '--metainfo ' + self.METAINFO,
)) parse_output=True,
)
ID = json_output_1.get('id') ID = json_output_1.get('id')
self.assertIsNotNone(ID) self.assertIsNotNone(ID)
json_output = json.loads(self.openstack( json_output = self.openstack(
'network flavor profile show -f json ' + ID 'network flavor profile show ' + ID,
)) parse_output=True,
)
self.assertEqual( self.assertEqual(
ID, ID,
json_output["id"], json_output["id"],

62
openstackclient/tests/functional/network/v2/test_network_meter.py

@ -13,7 +13,6 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
import json
import uuid import uuid
from openstackclient.tests.functional.network.v2 import common from openstackclient.tests.functional.network.v2 import common
@ -38,11 +37,12 @@ class TestMeter(common.NetworkTests):
name1 = uuid.uuid4().hex name1 = uuid.uuid4().hex
name2 = uuid.uuid4().hex name2 = uuid.uuid4().hex
description = 'fakedescription' description = 'fakedescription'
json_output = json.loads(self.openstack( json_output = self.openstack(
'network meter create -f json ' + 'network meter create ' +
' --description ' + description + ' ' + ' --description ' + description + ' ' +
name1 name1,
)) parse_output=True,
)
self.assertEqual( self.assertEqual(
name1, name1,
json_output.get('name'), json_output.get('name'),
@ -54,11 +54,12 @@ class TestMeter(common.NetworkTests):
json_output.get('description'), json_output.get('description'),
) )
json_output_2 = json.loads(self.openstack( json_output_2 = self.openstack(
'network meter create -f json ' + 'network meter create ' +
'--description ' + description + ' ' + '--description ' + description + ' ' +
name2 name2,
)) parse_output=True,
)
self.assertEqual( self.assertEqual(
name2, name2,
json_output_2.get('name'), json_output_2.get('name'),
@ -78,12 +79,13 @@ class TestMeter(common.NetworkTests):
def test_meter_list(self): def test_meter_list(self):
"""Test create, list filters, delete""" """Test create, list filters, delete"""
name1 = uuid.uuid4().hex name1 = uuid.uuid4().hex
json_output = json.loads(self.openstack( json_output = self.openstack(
'network meter create -f json ' + 'network meter create ' +
'--description Test1 ' + '--description Test1 ' +
'--share ' + '--share ' +
name1 name1,
)) parse_output=True,
)
self.addCleanup( self.addCleanup(
self.openstack, self.openstack,
'network meter delete ' + name1 'network meter delete ' + name1
@ -96,12 +98,13 @@ class TestMeter(common.NetworkTests):
self.assertTrue(json_output.get('shared')) self.assertTrue(json_output.get('shared'))
name2 = uuid.uuid4().hex name2 = uuid.uuid4().hex
json_output_2 = json.loads(self.openstack( json_output_2 = self.openstack(
'network meter create -f json ' + 'network meter create ' +
'--description Test2 ' + '--description Test2 ' +
'--no-share ' + '--no-share ' +
name2 name2,
)) parse_output=True,
)
self.addCleanup(self.openstack, 'network meter delete ' + name2) self.addCleanup(self.openstack, 'network meter delete ' + name2)
self.assertEqual( self.assertEqual(
@ -112,7 +115,7 @@ class TestMeter(common.NetworkTests):
json_output_2.get('shared'), json_output_2.get('shared'),
) )
raw_output = json.loads(self.openstack('network meter list -f json')) raw_output = self.openstack('network meter list', parse_output=True)
name_list = [item.get('Name') for item in raw_output] name_list = [item.get('Name') for item in raw_output]
self.assertIn(name1, name_list) self.assertIn(name1, name_list)
self.assertIn(name2, name_list) self.assertIn(name2, name_list)
@ -121,18 +124,20 @@ class TestMeter(common.NetworkTests):
"""Test create, show, delete""" """Test create, show, delete"""
name1 = uuid.uuid4().hex name1 = uuid.uuid4().hex
description = 'fakedescription' description = 'fakedescription'
json_output = json.loads(self.openstack( json_output = self.openstack(
'network meter create -f json ' + 'network meter create ' +
' --description ' + description + ' ' + ' --description ' + description + ' ' +
name1 name1,
)) parse_output=True,
)
meter_id = json_output.get('id') meter_id = json_output.get('id')
self.addCleanup(self.openstack, 'network meter delete ' + name1) self.addCleanup(self.openstack, 'network meter delete ' + name1)
# Test show with ID # Test show with ID
json_output = json.loads(self.openstack( json_output = self.openstack(
'network meter show -f json ' + meter_id 'network meter show ' + meter_id,
)) parse_output=True,
)
self.assertFalse(json_output.get('shared')) self.assertFalse(json_output.get('shared'))
self.assertEqual( self.assertEqual(
'fakedescription', 'fakedescription',
@ -144,9 +149,10 @@ class TestMeter(common.NetworkTests):
) )
# Test show with name # Test show with name
json_output = json.loads(self.openstack( json_output = self.openstack(
'network meter show -f json ' + name1 'network meter show ' + name1,
)) parse_output=True,
)
self.assertEqual( self.assertEqual(
meter_id, meter_id,
json_output.get('id'), json_output.get('id'),

60
openstackclient/tests/functional/network/v2/test_network_meter_rule.py

@ -13,7 +13,6 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
import json
import uuid import uuid
from openstackclient.tests.functional.network.v2 import common from openstackclient.tests.functional.network.v2 import common
@ -31,10 +30,11 @@ class TestMeterRule(common.NetworkTests):
if cls.haz_network: if cls.haz_network:
cls.METER_NAME = uuid.uuid4().hex cls.METER_NAME = uuid.uuid4().hex
json_output = json.loads(cls.openstack( json_output = cls.openstack(
'network meter create -f json ' + 'network meter create ' +
cls.METER_NAME cls.METER_NAME,
)) parse_output=True,
)
cls.METER_ID = json_output.get('id') cls.METER_ID = json_output.get('id')
@classmethod @classmethod
@ -57,11 +57,12 @@ class TestMeterRule(common.NetworkTests):
def test_meter_rule_delete(self): def test_meter_rule_delete(self):
"""test create, delete""" """test create, delete"""
json_output = json.loads(self.openstack( json_output = self.openstack(
'network meter rule create -f json ' + 'network meter rule create ' +
'--remote-ip-prefix 10.0.0.0/8 ' + '--remote-ip-prefix 10.0.0.0/8 ' +
self.METER_ID self.METER_ID,
)) parse_output=True,
)
rule_id = json_output.get('id') rule_id = json_output.get('id')
re_ip = json_output.get('remote_ip_prefix') re_ip = json_output.get('remote_ip_prefix')
@ -77,11 +78,12 @@ class TestMeterRule(common.NetworkTests):
def test_meter_rule_list(self): def test_meter_rule_list(self):
"""Test create, list, delete""" """Test create, list, delete"""
json_output = json.loads(self.openstack( json_output = self.openstack(
'network meter rule create -f json ' + 'network meter rule create ' +
'--remote-ip-prefix 10.0.0.0/8 ' + '--remote-ip-prefix 10.0.0.0/8 ' +
self.METER_ID self.METER_ID,
)) parse_output=True,
)
rule_id_1 = json_output.get('id') rule_id_1 = json_output.get('id')
self.addCleanup( self.addCleanup(
self.openstack, self.openstack,
@ -92,11 +94,12 @@ class TestMeterRule(common.NetworkTests):
json_output.get('remote_ip_prefix') json_output.get('remote_ip_prefix')
) )
json_output_1 = json.loads(self.openstack( json_output_1 = self.openstack(
'network meter rule create -f json ' + 'network meter rule create ' +
'--remote-ip-prefix 11.0.0.0/8 ' + '--remote-ip-prefix 11.0.0.0/8 ' +
self.METER_ID self.METER_ID,
)) parse_output=True,
)
rule_id_2 = json_output_1.get('id') rule_id_2 = json_output_1.get('id')
self.addCleanup( self.addCleanup(
self.openstack, self.openstack,
@ -107,9 +110,10 @@ class TestMeterRule(common.NetworkTests):
json_output_1.get('remote_ip_prefix') json_output_1.get('remote_ip_prefix')
) )
json_output = json.loads(self.openstack( json_output = self.openstack(
'network meter rule list -f json' 'network meter rule list',
)) parse_output=True,
)
rule_id_list = [item.get('ID') for item in json_output] rule_id_list = [item.get('ID') for item in json_output]
ip_prefix_list = [item.get('Remote IP Prefix') for item in json_output] ip_prefix_list = [item.get('Remote IP Prefix') for item in json_output]
self.assertIn(rule_id_1, rule_id_list) self.assertIn(rule_id_1, rule_id_list)
@ -119,12 +123,13 @@ class TestMeterRule(common.NetworkTests):
def test_meter_rule_show(self): def test_meter_rule_show(self):
"""Test create, show, delete""" """Test create, show, delete"""
json_output = json.loads(self.openstack( json_output = self.openstack(
'network meter rule create -f json ' + 'network meter rule create ' +
'--remote-ip-prefix 10.0.0.0/8 ' + '--remote-ip-prefix 10.0.0.0/8 ' +
'--egress ' + '--egress ' +
self.METER_ID self.METER_ID,
)) parse_output=True,
)
rule_id = json_output.get('id') rule_id = json_output.get('id')
self.assertEqual( self.assertEqual(
@ -132,9 +137,10 @@ class TestMeterRule(common.NetworkTests):
json_output.get('direction') json_output.get('direction')
) )
json_output = json.loads(self.openstack( json_output = self.openstack(
'network meter rule show -f json ' + rule_id 'network meter rule show ' + rule_id,
)) parse_output=True,
)
self.assertEqual( self.assertEqual(
'10.0.0.0/8', '10.0.0.0/8',
json_output.get('remote_ip_prefix') json_output.get('remote_ip_prefix')

100
openstackclient/tests/functional/network/v2/test_network_ndp_proxy.py

@ -10,9 +10,6 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
import json
from openstackclient.tests.functional.network.v2 import common from openstackclient.tests.functional.network.v2 import common
@ -36,38 +33,45 @@ class L3NDPProxyTests(common.NetworkTests):
self.SUBNET_P_NAME = self.getUniqueString() self.SUBNET_P_NAME = self.getUniqueString()
self.created_ndp_proxies = [] self.created_ndp_proxies = []
json_output = json.loads( json_output = self.openstack(
self.openstack( 'address scope create --ip-version 6 '
'address scope create -f json --ip-version 6 ' '%(address_s_name)s' % {'address_s_name': self.ADDR_SCOPE_NAME},
'%(address_s_name)s' % { parse_output=True,
'address_s_name': self.ADDR_SCOPE_NAME})) )
self.assertIsNotNone(json_output['id']) self.assertIsNotNone(json_output['id'])
self.ADDRESS_SCOPE_ID = json_output['id'] self.ADDRESS_SCOPE_ID = json_output['id']
json_output = json.loads( json_output = self.openstack(
self.openstack( 'subnet pool create %(subnet_p_name)s '
'subnet pool create -f json %(subnet_p_name)s '
'--address-scope %(address_scope)s ' '--address-scope %(address_scope)s '
'--pool-prefix 2001:db8::/96 --default-prefix-length 112' % { '--pool-prefix 2001:db8::/96 --default-prefix-length 112' % {
'subnet_p_name': self.SUBNET_P_NAME, 'subnet_p_name': self.SUBNET_P_NAME,
'address_scope': self.ADDRESS_SCOPE_ID})) 'address_scope': self.ADDRESS_SCOPE_ID,
},
parse_output=True,
)
self.assertIsNotNone(json_output['id']) self.assertIsNotNone(json_output['id'])
self.SUBNET_POOL_ID = json_output['id'] self.SUBNET_POOL_ID = json_output['id']
json_output = json.loads( json_output = self.openstack(
self.openstack('network create -f json ' 'network create --external ' + self.EXT_NET_NAME,
'--external ' + self.EXT_NET_NAME)) parse_output=True,
)
self.assertIsNotNone(json_output['id']) self.assertIsNotNone(json_output['id'])
self.EXT_NET_ID = json_output['id'] self.EXT_NET_ID = json_output['id']
json_output = json.loads( json_output = self.openstack(
self.openstack( 'subnet create --ip-version 6 --subnet-pool '
'subnet create -f json --ip-version 6 --subnet-pool '
'%(subnet_pool)s --network %(net_id)s %(sub_name)s' % { '%(subnet_pool)s --network %(net_id)s %(sub_name)s' % {
'subnet_pool': self.SUBNET_POOL_ID, 'subnet_pool': self.SUBNET_POOL_ID,
'net_id': self.EXT_NET_ID, 'net_id': self.EXT_NET_ID,
'sub_name': self.EXT_SUB_NAME})) 'sub_name': self.EXT_SUB_NAME,
},
parse_output=True,
)
self.assertIsNotNone(json_output['id']) self.assertIsNotNone(json_output['id'])
self.EXT_SUB_ID = json_output['id'] self.EXT_SUB_ID = json_output['id']
json_output = json.loads( json_output = self.openstack(
self.openstack('router create -f json ' + self.ROT_NAME)) 'router create ' + self.ROT_NAME,
parse_output=True,
)
self.assertIsNotNone(json_output['id']) self.assertIsNotNone(json_output['id'])
self.ROT_ID = json_output['id'] self.ROT_ID = json_output['id']
output = self.openstack( output = self.openstack(
@ -77,29 +81,36 @@ class L3NDPProxyTests(common.NetworkTests):
self.assertEqual('', output) self.assertEqual('', output)
output = self.openstack('router set --enable-ndp-proxy ' + self.ROT_ID) output = self.openstack('router set --enable-ndp-proxy ' + self.ROT_ID)
self.assertEqual('', output) self.assertEqual('', output)
json_output = json.loads( json_output = self.openstack(
self.openstack( 'router show -c enable_ndp_proxy ' + self.ROT_ID,
'router show -f json -c enable_ndp_proxy ' + self.ROT_ID)) parse_output=True,
)
self.assertTrue(json_output['enable_ndp_proxy']) self.assertTrue(json_output['enable_ndp_proxy'])
json_output = json.loads( json_output = self.openstack(
self.openstack('network create -f json ' + self.INT_NET_NAME)) 'network create ' + self.INT_NET_NAME,
parse_output=True,
)
self.assertIsNotNone(json_output['id']) self.assertIsNotNone(json_output['id'])
self.INT_NET_ID = json_output['id'] self.INT_NET_ID = json_output['id']
json_output = json.loads( json_output = self.openstack(
self.openstack( 'subnet create --ip-version 6 --subnet-pool '
'subnet create -f json --ip-version 6 --subnet-pool '
'%(subnet_pool)s --network %(net_id)s %(sub_name)s' % { '%(subnet_pool)s --network %(net_id)s %(sub_name)s' % {
'subnet_pool': self.SUBNET_POOL_ID, 'subnet_pool': self.SUBNET_POOL_ID,
'net_id': self.INT_NET_ID, 'net_id': self.INT_NET_ID,
'sub_name': self.INT_SUB_NAME})) 'sub_name': self.INT_SUB_NAME,
},
parse_output=True,
)
self.assertIsNotNone(json_output['id']) self.assertIsNotNone(json_output['id'])
self.INT_SUB_ID = json_output['id'] self.INT_SUB_ID = json_output['id']
json_output = json.loads( json_output = self.openstack(
self.openstack( 'port create --network %(net_id)s '
'port create -f json --network %(net_id)s '
'%(port_name)s' % { '%(port_name)s' % {
'net_id': self.INT_NET_ID, 'net_id': self.INT_NET_ID,
'port_name': self.INT_PORT_NAME})) 'port_name': self.INT_PORT_NAME,
},
parse_output=True,
)
self.assertIsNotNone(json_output['id']) self.assertIsNotNone(json_output['id'])
self.INT_PORT_ID = json_output['id'] self.INT_PORT_ID = json_output['id']
self.INT_PORT_ADDRESS = json_output['fixed_ips'][0]['ip_address'] self.INT_PORT_ADDRESS = json_output['fixed_ips'][0]['ip_address']
@ -142,14 +153,16 @@ class L3NDPProxyTests(common.NetworkTests):
def _create_ndp_proxies(self, ndp_proxies): def _create_ndp_proxies(self, ndp_proxies):
for ndp_proxy in ndp_proxies: for ndp_proxy in ndp_proxies:
output = json.loads( output = self.openstack(
self.openstack(
'router ndp proxy create %(router)s --name %(name)s ' 'router ndp proxy create %(router)s --name %(name)s '
'--port %(port)s --ip-address %(address)s -f json' % { '--port %(port)s --ip-address %(address)s' % {
'router': ndp_proxy['router_id'], 'router': ndp_proxy['router_id'],
'name': ndp_proxy['name'], 'name': ndp_proxy['name'],
'port': ndp_proxy['port_id'], 'port': ndp_proxy['port_id'],
'address': ndp_proxy['address']})) 'address': ndp_proxy['address'],
},
parse_output=True,
)
self.assertEqual(ndp_proxy['router_id'], output['router_id']) self.assertEqual(ndp_proxy['router_id'], output['router_id'])
self.assertEqual(ndp_proxy['port_id'], output['port_id']) self.assertEqual(ndp_proxy['port_id'], output['port_id'])
self.assertEqual(ndp_proxy['address'], output['ip_address']) self.assertEqual(ndp_proxy['address'], output['ip_address'])
@ -173,8 +186,9 @@ class L3NDPProxyTests(common.NetworkTests):
'port_id': self.INT_PORT_ID, 'port_id': self.INT_PORT_ID,
'address': self.INT_PORT_ADDRESS} 'address': self.INT_PORT_ADDRESS}
self._create_ndp_proxies([ndp_proxies]) self._create_ndp_proxies([ndp_proxies])
ndp_proxy = json.loads(self.openstack( ndp_proxy = self.openstack(
'router ndp proxy list -f json'))[0] 'router ndp proxy list',
parse_output=True,)[0]
self.assertEqual(ndp_proxies['name'], ndp_proxy['Name']) self.assertEqual(ndp_proxies['name'], ndp_proxy['Name'])
self.assertEqual(ndp_proxies['router_id'], ndp_proxy['Router ID']) self.assertEqual(ndp_proxies['router_id'], ndp_proxy['Router ID'])
self.assertEqual(ndp_proxies['address'], ndp_proxy['IP Address']) self.assertEqual(ndp_proxies['address'], ndp_proxy['IP Address'])
@ -192,8 +206,10 @@ class L3NDPProxyTests(common.NetworkTests):
'router ndp proxy set --description %s %s' % ( 'router ndp proxy set --description %s %s' % (
description, ndp_proxy_id)) description, ndp_proxy_id))
self.assertEqual('', output) self.assertEqual('', output)
json_output = json.loads( json_output = self.openstack(
self.openstack('router ndp proxy show -f json ' + ndp_proxy_id)) 'router ndp proxy show ' + ndp_proxy_id,
parse_output=True,
)
self.assertEqual(ndp_proxies['name'], json_output['name']) self.assertEqual(ndp_proxies['name'], json_output['name'])
self.assertEqual(ndp_proxies['router_id'], json_output['router_id']) self.assertEqual(ndp_proxies['router_id'], json_output['router_id'])
self.assertEqual(ndp_proxies['port_id'], json_output['port_id']) self.assertEqual(ndp_proxies['port_id'], json_output['port_id'])

46
openstackclient/tests/functional/network/v2/test_network_qos_policy.py

@ -13,7 +13,6 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
import json
import uuid import uuid
from openstackclient.tests.functional.network.v2 import common from openstackclient.tests.functional.network.v2 import common
@ -31,7 +30,7 @@ class NetworkQosPolicyTests(common.NetworkTests):
def test_qos_rule_create_delete(self): def test_qos_rule_create_delete(self):
# This is to check the output of qos policy delete # This is to check the output of qos policy delete
policy_name = uuid.uuid4().hex policy_name = uuid.uuid4().hex
self.openstack('network qos policy create -f json ' + policy_name) self.openstack('network qos policy create ' + policy_name)
raw_output = self.openstack( raw_output = self.openstack(
'network qos policy delete ' + 'network qos policy delete ' +
policy_name policy_name
@ -40,25 +39,28 @@ class NetworkQosPolicyTests(common.NetworkTests):
def test_qos_policy_list(self): def test_qos_policy_list(self):
policy_name = uuid.uuid4().hex policy_name = uuid.uuid4().hex
json_output = json.loads(self.openstack( json_output = self.openstack(
'network qos policy create -f json ' + 'network qos policy create ' +
policy_name policy_name,
)) parse_output=True,
)
self.addCleanup(self.openstack, self.addCleanup(self.openstack,
'network qos policy delete ' + policy_name) 'network qos policy delete ' + policy_name)
self.assertEqual(policy_name, json_output['name']) self.assertEqual(policy_name, json_output['name'])
json_output = json.loads(self.openstack( json_output = self.openstack(
'network qos policy list -f json' 'network qos policy list',
)) parse_output=True,
)
self.assertIn(policy_name, [p['Name'] for p in json_output]) self.assertIn(policy_name, [p['Name'] for p in json_output])
def test_qos_policy_set(self): def test_qos_policy_set(self):
policy_name = uuid.uuid4().hex policy_name = uuid.uuid4().hex
json_output = json.loads(self.openstack( json_output = self.openstack(
'network qos policy create -f json ' + 'network qos policy create ' +
policy_name policy_name,
)) parse_output=True,
)
self.addCleanup(self.openstack, self.addCleanup(self.openstack,
'network qos policy delete ' + policy_name) 'network qos policy delete ' + policy_name)
self.assertEqual(policy_name, json_output['name']) self.assertEqual(policy_name, json_output['name'])
@ -69,10 +71,11 @@ class NetworkQosPolicyTests(common.NetworkTests):
policy_name policy_name
) )
json_output = json.loads(self.openstack( json_output = self.openstack(
'network qos policy show -f json ' + 'network qos policy show ' +
policy_name policy_name,
)) parse_output=True,
)
self.assertTrue(json_output['shared']) self.assertTrue(json_output['shared'])
self.openstack( self.openstack(
@ -81,9 +84,10 @@ class NetworkQosPolicyTests(common.NetworkTests):
'--no-default ' + '--no-default ' +
policy_name policy_name
) )
json_output = json.loads(self.openstack( json_output = self.openstack(
'network qos policy show -f json ' + 'network qos policy show ' +
policy_name policy_name,
)) parse_output=True,
)
self.assertFalse(json_output['shared']) self.assertFalse(json_output['shared'])
self.assertFalse(json_output['is_default']) self.assertFalse(json_output['is_default'])

167
openstackclient/tests/functional/network/v2/test_network_qos_rule.py

@ -13,7 +13,6 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
import json
import uuid import uuid
from openstackclient.tests.functional.network.v2 import common from openstackclient.tests.functional.network.v2 import common
@ -35,13 +34,14 @@ class NetworkQosRuleTestsMinimumBandwidth(common.NetworkTests):
) )
self.addCleanup(self.openstack, self.addCleanup(self.openstack,
'network qos policy delete %s' % self.QOS_POLICY_NAME) 'network qos policy delete %s' % self.QOS_POLICY_NAME)
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'network qos rule create -f json ' 'network qos rule create '
'--type minimum-bandwidth ' '--type minimum-bandwidth '
'--min-kbps 2800 ' '--min-kbps 2800 '
'--egress %s' % '--egress %s' %
self.QOS_POLICY_NAME self.QOS_POLICY_NAME,
)) parse_output=True,
)
self.RULE_ID = cmd_output['id'] self.RULE_ID = cmd_output['id']
self.addCleanup(self.openstack, self.addCleanup(self.openstack,
'network qos rule delete %s %s' % 'network qos rule delete %s %s' %
@ -51,37 +51,43 @@ class NetworkQosRuleTestsMinimumBandwidth(common.NetworkTests):
def test_qos_rule_create_delete(self): def test_qos_rule_create_delete(self):
# This is to check the output of qos rule delete # This is to check the output of qos rule delete
policy_name = uuid.uuid4().hex policy_name = uuid.uuid4().hex
self.openstack('network qos policy create -f json %s' % policy_name) self.openstack('network qos policy create %s' % policy_name)
self.addCleanup(self.openstack, self.addCleanup(self.openstack,
'network qos policy delete %s' % policy_name) 'network qos policy delete %s' % policy_name)
rule = json.loads(self.openstack( rule = self.openstack(
'network qos rule create -f json ' 'network qos rule create '
'--type minimum-bandwidth ' '--type minimum-bandwidth '
'--min-kbps 2800 ' '--min-kbps 2800 '
'--egress %s' % policy_name '--egress %s' % policy_name,
)) parse_output=True,
)
raw_output = self.openstack( raw_output = self.openstack(
'network qos rule delete %s %s' % 'network qos rule delete %s %s' %
(policy_name, rule['id'])) (policy_name, rule['id']))
self.assertEqual('', raw_output) self.assertEqual('', raw_output)
def test_qos_rule_list(self): def test_qos_rule_list(self):
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'network qos rule list -f json %s' % self.QOS_POLICY_NAME)) 'network qos rule list %s' % self.QOS_POLICY_NAME,
parse_output=True,)
self.assertIn(self.RULE_ID, [rule['ID'] for rule in cmd_output]) self.assertIn(self.RULE_ID, [rule['ID'] for rule in cmd_output])
def test_qos_rule_show(self): def test_qos_rule_show(self):
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'network qos rule show -f json %s %s' % 'network qos rule show %s %s' %
(self.QOS_POLICY_NAME, self.RULE_ID))) (self.QOS_POLICY_NAME, self.RULE_ID),
parse_output=True,
)
self.assertEqual(self.RULE_ID, cmd_output['id']) self.assertEqual(self.RULE_ID, cmd_output['id'])
def test_qos_rule_set(self): def test_qos_rule_set(self):
self.openstack('network qos rule set --min-kbps 7500 %s %s' % self.openstack('network qos rule set --min-kbps 7500 %s %s' %
(self.QOS_POLICY_NAME, self.RULE_ID)) (self.QOS_POLICY_NAME, self.RULE_ID))
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'network qos rule show -f json %s %s' % 'network qos rule show %s %s' %
(self.QOS_POLICY_NAME, self.RULE_ID))) (self.QOS_POLICY_NAME, self.RULE_ID),
parse_output=True,
)
self.assertEqual(7500, cmd_output['min_kbps']) self.assertEqual(7500, cmd_output['min_kbps'])
@ -101,13 +107,14 @@ class NetworkQosRuleTestsMinimumPacketRate(common.NetworkTests):
) )
self.addCleanup(self.openstack, self.addCleanup(self.openstack,
'network qos policy delete %s' % self.QOS_POLICY_NAME) 'network qos policy delete %s' % self.QOS_POLICY_NAME)
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'network qos rule create -f json ' 'network qos rule create '
'--type minimum-packet-rate ' '--type minimum-packet-rate '
'--min-kpps 2800 ' '--min-kpps 2800 '
'--egress %s' % '--egress %s' %
self.QOS_POLICY_NAME self.QOS_POLICY_NAME,
)) parse_output=True,
)
self.RULE_ID = cmd_output['id'] self.RULE_ID = cmd_output['id']
self.addCleanup(self.openstack, self.addCleanup(self.openstack,
'network qos rule delete %s %s' % 'network qos rule delete %s %s' %
@ -117,37 +124,43 @@ class NetworkQosRuleTestsMinimumPacketRate(common.NetworkTests):
def test_qos_rule_create_delete(self): def test_qos_rule_create_delete(self):
# This is to check the output of qos rule delete # This is to check the output of qos rule delete
policy_name = uuid.uuid4().hex policy_name = uuid.uuid4().hex
self.openstack('network qos policy create -f json %s' % policy_name) self.openstack('network qos policy create %s' % policy_name)
self.addCleanup(self.openstack, self.addCleanup(self.openstack,
'network qos policy delete %s' % policy_name) 'network qos policy delete %s' % policy_name)
rule = json.loads(self.openstack( rule = self.openstack(
'network qos rule create -f json ' 'network qos rule create '
'--type minimum-packet-rate ' '--type minimum-packet-rate '
'--min-kpps 2800 ' '--min-kpps 2800 '
'--egress %s' % policy_name '--egress %s' % policy_name,
)) parse_output=True,
)
raw_output = self.openstack( raw_output = self.openstack(
'network qos rule delete %s %s' % 'network qos rule delete %s %s' %
(policy_name, rule['id'])) (policy_name, rule['id']))
self.assertEqual('', raw_output) self.assertEqual('', raw_output)
def test_qos_rule_list(self): def test_qos_rule_list(self):
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'network qos rule list -f json %s' % self.QOS_POLICY_NAME)) 'network qos rule list %s' % self.QOS_POLICY_NAME,
parse_output=True,)
self.assertIn(self.RULE_ID, [rule['ID'] for rule in cmd_output]) self.assertIn(self.RULE_ID, [rule['ID'] for rule in cmd_output])
def test_qos_rule_show(self): def test_qos_rule_show(self):
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'network qos rule show -f json %s %s' % 'network qos rule show %s %s' %
(self.QOS_POLICY_NAME, self.RULE_ID))) (self.QOS_POLICY_NAME, self.RULE_ID),
parse_output=True,
)
self.assertEqual(self.RULE_ID, cmd_output['id']) self.assertEqual(self.RULE_ID, cmd_output['id'])
def test_qos_rule_set(self): def test_qos_rule_set(self):
self.openstack('network qos rule set --min-kpps 7500 --any %s %s' % self.openstack('network qos rule set --min-kpps 7500 --any %s %s' %
(self.QOS_POLICY_NAME, self.RULE_ID)) (self.QOS_POLICY_NAME, self.RULE_ID))
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'network qos rule show -f json %s %s' % 'network qos rule show %s %s' %
(self.QOS_POLICY_NAME, self.RULE_ID))) (self.QOS_POLICY_NAME, self.RULE_ID),
parse_output=True,
)
self.assertEqual(7500, cmd_output['min_kpps']) self.assertEqual(7500, cmd_output['min_kpps'])
self.assertEqual('any', cmd_output['direction']) self.assertEqual('any', cmd_output['direction'])
@ -167,12 +180,13 @@ class NetworkQosRuleTestsDSCPMarking(common.NetworkTests):
) )
self.addCleanup(self.openstack, self.addCleanup(self.openstack,
'network qos policy delete %s' % self.QOS_POLICY_NAME) 'network qos policy delete %s' % self.QOS_POLICY_NAME)
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'network qos rule create -f json ' 'network qos rule create '
'--type dscp-marking ' '--type dscp-marking '
'--dscp-mark 8 %s' % '--dscp-mark 8 %s' %
self.QOS_POLICY_NAME self.QOS_POLICY_NAME,
)) parse_output=True,
)
self.RULE_ID = cmd_output['id'] self.RULE_ID = cmd_output['id']
self.addCleanup(self.openstack, self.addCleanup(self.openstack,
'network qos rule delete %s %s' % 'network qos rule delete %s %s' %
@ -182,36 +196,42 @@ class NetworkQosRuleTestsDSCPMarking(common.NetworkTests):
def test_qos_rule_create_delete(self): def test_qos_rule_create_delete(self):
# This is to check the output of qos rule delete # This is to check the output of qos rule delete
policy_name = uuid.uuid4().hex policy_name = uuid.uuid4().hex
self.openstack('network qos policy create -f json %s' % policy_name) self.openstack('network qos policy create %s' % policy_name)
self.addCleanup(self.openstack, self.addCleanup(self.openstack,
'network qos policy delete %s' % policy_name) 'network qos policy delete %s' % policy_name)
rule = json.loads(self.openstack( rule = self.openstack(
'network qos rule create -f json ' 'network qos rule create '
'--type dscp-marking ' '--type dscp-marking '
'--dscp-mark 8 %s' % policy_name '--dscp-mark 8 %s' % policy_name,
)) parse_output=True,
)
raw_output = self.openstack( raw_output = self.openstack(
'network qos rule delete %s %s' % 'network qos rule delete %s %s' %
(policy_name, rule['id'])) (policy_name, rule['id']))
self.assertEqual('', raw_output) self.assertEqual('', raw_output)
def test_qos_rule_list(self): def test_qos_rule_list(self):
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'network qos rule list -f json %s' % self.QOS_POLICY_NAME)) 'network qos rule list %s' % self.QOS_POLICY_NAME,
parse_output=True,)
self.assertIn(self.RULE_ID, [rule['ID'] for rule in cmd_output]) self.assertIn(self.RULE_ID, [rule['ID'] for rule in cmd_output])
def test_qos_rule_show(self): def test_qos_rule_show(self):
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'network qos rule show -f json %s %s' % 'network qos rule show %s %s' %
(self.QOS_POLICY_NAME, self.RULE_ID))) (self.QOS_POLICY_NAME, self.RULE_ID),
parse_output=True,
)
self.assertEqual(self.RULE_ID, cmd_output['id']) self.assertEqual(self.RULE_ID, cmd_output['id'])
def test_qos_rule_set(self): def test_qos_rule_set(self):
self.openstack('network qos rule set --dscp-mark 32 %s %s' % self.openstack('network qos rule set --dscp-mark 32 %s %s' %
(self.QOS_POLICY_NAME, self.RULE_ID)) (self.QOS_POLICY_NAME, self.RULE_ID))
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'network qos rule show -f json %s %s' % 'network qos rule show %s %s' %
(self.QOS_POLICY_NAME, self.RULE_ID))) (self.QOS_POLICY_NAME, self.RULE_ID),
parse_output=True,
)
self.assertEqual(32, cmd_output['dscp_mark']) self.assertEqual(32, cmd_output['dscp_mark'])
@ -230,13 +250,14 @@ class NetworkQosRuleTestsBandwidthLimit(common.NetworkTests):
) )
self.addCleanup(self.openstack, self.addCleanup(self.openstack,
'network qos policy delete %s' % self.QOS_POLICY_NAME) 'network qos policy delete %s' % self.QOS_POLICY_NAME)
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'network qos rule create -f json ' 'network qos rule create '
'--type bandwidth-limit ' '--type bandwidth-limit '
'--max-kbps 10000 ' '--max-kbps 10000 '
'--egress %s' % '--egress %s' %
self.QOS_POLICY_NAME self.QOS_POLICY_NAME,
)) parse_output=True,
)
self.RULE_ID = cmd_output['id'] self.RULE_ID = cmd_output['id']
self.addCleanup(self.openstack, self.addCleanup(self.openstack,
'network qos rule delete %s %s' % 'network qos rule delete %s %s' %
@ -246,31 +267,35 @@ class NetworkQosRuleTestsBandwidthLimit(common.NetworkTests):
def test_qos_rule_create_delete(self): def test_qos_rule_create_delete(self):
# This is to check the output of qos rule delete # This is to check the output of qos rule delete
policy_name = uuid.uuid4().hex policy_name = uuid.uuid4().hex
self.openstack('network qos policy create -f json %s' % policy_name) self.openstack('network qos policy create %s' % policy_name)
self.addCleanup(self.openstack, self.addCleanup(self.openstack,
'network qos policy delete %s' % policy_name) 'network qos policy delete %s' % policy_name)
rule = json.loads(self.openstack( rule = self.openstack(
'network qos rule create -f json ' 'network qos rule create '
'--type bandwidth-limit ' '--type bandwidth-limit '
'--max-kbps 10000 ' '--max-kbps 10000 '
'--max-burst-kbits 1400 ' '--max-burst-kbits 1400 '
'--egress %s' % policy_name '--egress %s' % policy_name,
)) parse_output=True,
)
raw_output = self.openstack( raw_output = self.openstack(
'network qos rule delete %s %s' % 'network qos rule delete %s %s' %
(policy_name, rule['id'])) (policy_name, rule['id']))
self.assertEqual('', raw_output) self.assertEqual('', raw_output)
def test_qos_rule_list(self): def test_qos_rule_list(self):
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'network qos rule list -f json %s' % 'network qos rule list %s' %
self.QOS_POLICY_NAME)) self.QOS_POLICY_NAME,
parse_output=True,)
self.assertIn(self.RULE_ID, [rule['ID'] for rule in cmd_output]) self.assertIn(self.RULE_ID, [rule['ID'] for rule in cmd_output])
def test_qos_rule_show(self): def test_qos_rule_show(self):
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'network qos rule show -f json %s %s' % 'network qos rule show %s %s' %
(self.QOS_POLICY_NAME, self.RULE_ID))) (self.QOS_POLICY_NAME, self.RULE_ID),
parse_output=True,
)
self.assertEqual(self.RULE_ID, cmd_output['id']) self.assertEqual(self.RULE_ID, cmd_output['id'])
def test_qos_rule_set(self): def test_qos_rule_set(self):
@ -278,9 +303,11 @@ class NetworkQosRuleTestsBandwidthLimit(common.NetworkTests):
'--max-burst-kbits 1800 ' '--max-burst-kbits 1800 '
'--ingress %s %s' % '--ingress %s %s' %
(self.QOS_POLICY_NAME, self.RULE_ID)) (self.QOS_POLICY_NAME, self.RULE_ID))
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'network qos rule show -f json %s %s' % 'network qos rule show %s %s' %
(self.QOS_POLICY_NAME, self.RULE_ID))) (self.QOS_POLICY_NAME, self.RULE_ID),
parse_output=True,
)
self.assertEqual(15000, cmd_output['max_kbps']) self.assertEqual(15000, cmd_output['max_kbps'])
self.assertEqual(1800, cmd_output['max_burst_kbps']) self.assertEqual(1800, cmd_output['max_burst_kbps'])
self.assertEqual('ingress', cmd_output['direction']) self.assertEqual('ingress', cmd_output['direction'])

14
openstackclient/tests/functional/network/v2/test_network_qos_rule_type.py

@ -13,8 +13,6 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
import json
from openstackclient.tests.functional.network.v2 import common from openstackclient.tests.functional.network.v2 import common
@ -31,14 +29,18 @@ class NetworkQosRuleTypeTests(common.NetworkTests):
self.skipTest("No Network service present") self.skipTest("No Network service present")
def test_qos_rule_type_list(self): def test_qos_rule_type_list(self):
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'network qos rule type list -f json')) 'network qos rule type list -f json',
parse_output=True,
)
for rule_type in self.AVAILABLE_RULE_TYPES: for rule_type in self.AVAILABLE_RULE_TYPES:
self.assertIn(rule_type, [x['Type'] for x in cmd_output]) self.assertIn(rule_type, [x['Type'] for x in cmd_output])
def test_qos_rule_type_details(self): def test_qos_rule_type_details(self):
for rule_type in self.AVAILABLE_RULE_TYPES: for rule_type in self.AVAILABLE_RULE_TYPES:
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'network qos rule type show %s -f json' % rule_type)) 'network qos rule type show %s -f json' % rule_type,
parse_output=True,
)
self.assertEqual(rule_type, cmd_output['rule_type_name']) self.assertEqual(rule_type, cmd_output['rule_type_name'])
self.assertIn("drivers", cmd_output.keys()) self.assertIn("drivers", cmd_output.keys())

35
openstackclient/tests/functional/network/v2/test_network_rbac.py

@ -10,7 +10,6 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
import json
import uuid import uuid
from openstackclient.tests.functional.network.v2 import common from openstackclient.tests.functional.network.v2 import common
@ -32,41 +31,47 @@ class NetworkRBACTests(common.NetworkTests):
self.NET_NAME = uuid.uuid4().hex self.NET_NAME = uuid.uuid4().hex
self.PROJECT_NAME = uuid.uuid4().hex self.PROJECT_NAME = uuid.uuid4().hex
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'network create -f json ' + self.NET_NAME 'network create ' + self.NET_NAME,
)) parse_output=True,
)
self.addCleanup(self.openstack, self.addCleanup(self.openstack,
'network delete ' + cmd_output['id']) 'network delete ' + cmd_output['id'])
self.OBJECT_ID = cmd_output['id'] self.OBJECT_ID = cmd_output['id']
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'network rbac create -f json ' + 'network rbac create ' +
self.OBJECT_ID + self.OBJECT_ID +
' --action access_as_shared' + ' --action access_as_shared' +
' --target-project admin' + ' --target-project admin' +
' --type network' ' --type network',
)) parse_output=True,
)
self.addCleanup(self.openstack, self.addCleanup(self.openstack,
'network rbac delete ' + cmd_output['id']) 'network rbac delete ' + cmd_output['id'])
self.ID = cmd_output['id'] self.ID = cmd_output['id']
self.assertEqual(self.OBJECT_ID, cmd_output['object_id']) self.assertEqual(self.OBJECT_ID, cmd_output['object_id'])
def test_network_rbac_list(self): def test_network_rbac_list(self):
cmd_output = json.loads(self.openstack('network rbac list -f json')) cmd_output = self.openstack('network rbac list', parse_output=True)
self.assertIn(self.ID, [rbac['ID'] for rbac in cmd_output]) self.assertIn(self.ID, [rbac['ID'] for rbac in cmd_output])
def test_network_rbac_show(self): def test_network_rbac_show(self):
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'network rbac show -f json ' + self.ID)) 'network rbac show ' + self.ID,
parse_output=True,)
self.assertEqual(self.ID, cmd_output['id']) self.assertEqual(self.ID, cmd_output['id'])
def test_network_rbac_set(self): def test_network_rbac_set(self):
project_id = json.loads(self.openstack( project_id = self.openstack(
'project create -f json ' + self.PROJECT_NAME))['id'] 'project create ' + self.PROJECT_NAME,
parse_output=True,)['id']
self.openstack('network rbac set ' + self.ID + self.openstack('network rbac set ' + self.ID +
' --target-project ' + self.PROJECT_NAME) ' --target-project ' + self.PROJECT_NAME)
cmd_output_rbac = json.loads(self.openstack( cmd_output_rbac = self.openstack(
'network rbac show -f json ' + self.ID)) 'network rbac show ' + self.ID,
parse_output=True,
)
self.assertEqual(project_id, cmd_output_rbac['target_project_id']) self.assertEqual(project_id, cmd_output_rbac['target_project_id'])
raw_output_project = self.openstack( raw_output_project = self.openstack(
'project delete ' + self.PROJECT_NAME) 'project delete ' + self.PROJECT_NAME)

58
openstackclient/tests/functional/network/v2/test_network_segment.py

@ -10,7 +10,6 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
import json
import uuid import uuid
from openstackclient.tests.functional.network.v2 import common from openstackclient.tests.functional.network.v2 import common
@ -27,10 +26,9 @@ class NetworkSegmentTests(common.NetworkTests):
cls.PHYSICAL_NETWORK_NAME = uuid.uuid4().hex cls.PHYSICAL_NETWORK_NAME = uuid.uuid4().hex
# Create a network for the all subnet tests # Create a network for the all subnet tests
cmd_output = json.loads(cls.openstack( cmd_output = cls.openstack(
'network create -f json ' + 'network create ' + cls.NETWORK_NAME, parse_output=True,
cls.NETWORK_NAME )
))
# Get network_id for assertEqual # Get network_id for assertEqual
cls.NETWORK_ID = cmd_output["id"] cls.NETWORK_ID = cmd_output["id"]
@ -54,13 +52,14 @@ class NetworkSegmentTests(common.NetworkTests):
def test_network_segment_create_delete(self): def test_network_segment_create_delete(self):
name = uuid.uuid4().hex name = uuid.uuid4().hex
json_output = json.loads(self.openstack( json_output = self.openstack(
' network segment create -f json ' + ' network segment create ' +
'--network ' + self.NETWORK_ID + ' ' + '--network ' + self.NETWORK_ID + ' ' +
'--network-type geneve ' + '--network-type geneve ' +
'--segment 2055 ' + '--segment 2055 ' +
name name,
)) parse_output=True,
)
self.assertEqual( self.assertEqual(
name, name,
json_output["name"], json_output["name"],
@ -73,13 +72,14 @@ class NetworkSegmentTests(common.NetworkTests):
def test_network_segment_list(self): def test_network_segment_list(self):
name = uuid.uuid4().hex name = uuid.uuid4().hex
json_output = json.loads(self.openstack( json_output = self.openstack(
' network segment create -f json ' + ' network segment create ' +
'--network ' + self.NETWORK_ID + ' ' + '--network ' + self.NETWORK_ID + ' ' +
'--network-type geneve ' + '--network-type geneve ' +
'--segment 2055 ' + '--segment 2055 ' +
name name,
)) parse_output=True,
)
network_segment_id = json_output.get('id') network_segment_id = json_output.get('id')
network_segment_name = json_output.get('name') network_segment_name = json_output.get('name')
self.addCleanup( self.addCleanup(
@ -91,9 +91,10 @@ class NetworkSegmentTests(common.NetworkTests):
json_output["name"], json_output["name"],
) )
json_output = json.loads(self.openstack( json_output = self.openstack(
'network segment list -f json' 'network segment list',
)) parse_output=True,
)
item_map = { item_map = {
item.get('ID'): item.get('Name') for item in json_output item.get('ID'): item.get('Name') for item in json_output
} }
@ -102,21 +103,23 @@ class NetworkSegmentTests(common.NetworkTests):
def test_network_segment_set_show(self): def test_network_segment_set_show(self):
name = uuid.uuid4().hex name = uuid.uuid4().hex
json_output = json.loads(self.openstack( json_output = self.openstack(
' network segment create -f json ' + ' network segment create ' +
'--network ' + self.NETWORK_ID + ' ' + '--network ' + self.NETWORK_ID + ' ' +
'--network-type geneve ' + '--network-type geneve ' +
'--segment 2055 ' + '--segment 2055 ' +
name name,
)) parse_output=True,
)
self.addCleanup( self.addCleanup(
self.openstack, self.openstack,
'network segment delete ' + name 'network segment delete ' + name
) )
extension_output = json.loads(self.openstack( extension_output = self.openstack(
"extension list -f json " "extension list ",
)) parse_output=True,
)
ext_alias = [x["Alias"] for x in extension_output] ext_alias = [x["Alias"] for x in extension_output]
if "standard-attr-segment" in ext_alias: if "standard-attr-segment" in ext_alias:
self.assertEqual( self.assertEqual(
@ -136,10 +139,11 @@ class NetworkSegmentTests(common.NetworkTests):
) )
self.assertOutput('', cmd_output) self.assertOutput('', cmd_output)
json_output = json.loads(self.openstack( json_output = self.openstack(
'network segment show -f json ' + 'network segment show ' +
name name,
)) parse_output=True,
)
self.assertEqual( self.assertEqual(
new_description, new_description,
json_output["description"], json_output["description"],

54
openstackclient/tests/functional/network/v2/test_network_segment_range.py

@ -14,7 +14,6 @@
# under the License. # under the License.
# #
import json
import uuid import uuid
from openstackclient.tests.functional.network.v2 import common from openstackclient.tests.functional.network.v2 import common
@ -34,18 +33,20 @@ class NetworkSegmentRangeTests(common.NetworkTests):
def test_network_segment_range_create_delete(self): def test_network_segment_range_create_delete(self):
# Make a project # Make a project
project_id = json.loads(self.openstack( project_id = self.openstack(
'project create -f json ' + self.PROJECT_NAME))['id'] 'project create ' + self.PROJECT_NAME,
parse_output=True,)['id']
name = uuid.uuid4().hex name = uuid.uuid4().hex
json_output = json.loads(self.openstack( json_output = self.openstack(
' network segment range create -f json ' + ' network segment range create ' +
'--private ' + '--private ' +
"--project " + self.PROJECT_NAME + " " + "--project " + self.PROJECT_NAME + " " +
'--network-type vxlan ' + '--network-type vxlan ' +
'--minimum 2005 ' + '--minimum 2005 ' +
'--maximum 2009 ' + '--maximum 2009 ' +
name name,
)) parse_output=True,
)
self.assertEqual( self.assertEqual(
name, name,
json_output["name"], json_output["name"],
@ -65,14 +66,15 @@ class NetworkSegmentRangeTests(common.NetworkTests):
def test_network_segment_range_list(self): def test_network_segment_range_list(self):
name = uuid.uuid4().hex name = uuid.uuid4().hex
json_output = json.loads(self.openstack( json_output = self.openstack(
' network segment range create -f json ' + ' network segment range create ' +
'--shared ' + '--shared ' +
'--network-type geneve ' + '--network-type geneve ' +
'--minimum 2013 ' + '--minimum 2013 ' +
'--maximum 2017 ' + '--maximum 2017 ' +
name name,
)) parse_output=True,
)
network_segment_range_id = json_output.get('id') network_segment_range_id = json_output.get('id')
network_segment_range_name = json_output.get('name') network_segment_range_name = json_output.get('name')
self.addCleanup( self.addCleanup(
@ -84,9 +86,10 @@ class NetworkSegmentRangeTests(common.NetworkTests):
json_output["name"], json_output["name"],
) )
json_output = json.loads(self.openstack( json_output = self.openstack(
'network segment range list -f json' 'network segment range list',
)) parse_output=True,
)
item_map = { item_map = {
item.get('ID'): item.get('Name') for item in json_output item.get('ID'): item.get('Name') for item in json_output
} }
@ -94,18 +97,20 @@ class NetworkSegmentRangeTests(common.NetworkTests):
self.assertIn(network_segment_range_name, item_map.values()) self.assertIn(network_segment_range_name, item_map.values())
def test_network_segment_range_set_show(self): def test_network_segment_range_set_show(self):
project_id = json.loads(self.openstack( project_id = self.openstack(
'project create -f json ' + self.PROJECT_NAME))['id'] 'project create ' + self.PROJECT_NAME,
parse_output=True,)['id']
name = uuid.uuid4().hex name = uuid.uuid4().hex
json_output = json.loads(self.openstack( json_output = self.openstack(
' network segment range create -f json ' + ' network segment range create ' +
'--private ' + '--private ' +
"--project " + self.PROJECT_NAME + " " + "--project " + self.PROJECT_NAME + " " +
'--network-type geneve ' + '--network-type geneve ' +
'--minimum 2021 ' + '--minimum 2021 ' +
'--maximum 2025 ' + '--maximum 2025 ' +
name name,
)) parse_output=True,
)
self.addCleanup( self.addCleanup(
self.openstack, self.openstack,
'network segment range delete ' + name 'network segment range delete ' + name
@ -127,10 +132,11 @@ class NetworkSegmentRangeTests(common.NetworkTests):
) )
self.assertOutput('', cmd_output) self.assertOutput('', cmd_output)
json_output = json.loads(self.openstack( json_output = self.openstack(
'network segment range show -f json ' + 'network segment range show ' +
name name,
)) parse_output=True,
)
self.assertEqual( self.assertEqual(
new_minimum, new_minimum,
json_output["minimum"], json_output["minimum"],

14
openstackclient/tests/functional/network/v2/test_network_service_provider.py

@ -13,8 +13,6 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
import json
from openstackclient.tests.functional.network.v2 import common from openstackclient.tests.functional.network.v2 import common
@ -29,13 +27,15 @@ class TestNetworkServiceProvider(common.NetworkTests):
# NOTE(slaweq): # NOTE(slaweq):
# that tests should works only when "standard" Neutron L3 agent is # that tests should works only when "standard" Neutron L3 agent is
# used, as e.g. OVN L3 plugin don't supports that. # used, as e.g. OVN L3 plugin don't supports that.
l3_agent_list = json.loads(self.openstack( l3_agent_list = self.openstack(
'network agent list -f json --agent-type l3 -c ID' 'network agent list --agent-type l3 -c ID',
)) parse_output=True,
)
if not l3_agent_list: if not l3_agent_list:
self.skipTest("No Neutron L3 Agents present") self.skipTest("No Neutron L3 Agents present")
def test_network_service_provider_list(self): def test_network_service_provider_list(self):
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'network service provider list -f json')) 'network service provider list',
parse_output=True,)
self.assertIn('L3_ROUTER_NAT', [x['Service Type'] for x in cmd_output]) self.assertIn('L3_ROUTER_NAT', [x['Service Type'] for x in cmd_output])

154
openstackclient/tests/functional/network/v2/test_port.py

@ -10,7 +10,6 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
import json
import uuid import uuid
from openstackclient.tests.functional.network.v2 import common from openstackclient.tests.functional.network.v2 import common
@ -55,19 +54,21 @@ class PortTests(common.NetworkTagTests):
def test_port_delete(self): def test_port_delete(self):
"""Test create, delete multiple""" """Test create, delete multiple"""
json_output = json.loads(self.openstack( json_output = self.openstack(
'port create -f json --network %s %s' % 'port create --network %s %s' %
(self.NETWORK_NAME, self.NAME) (self.NETWORK_NAME, self.NAME),
)) parse_output=True,
)
id1 = json_output.get('id') id1 = json_output.get('id')
self.assertIsNotNone(id1) self.assertIsNotNone(id1)
self.assertIsNotNone(json_output.get('mac_address')) self.assertIsNotNone(json_output.get('mac_address'))
self.assertEqual(self.NAME, json_output.get('name')) self.assertEqual(self.NAME, json_output.get('name'))
json_output = json.loads(self.openstack( json_output = self.openstack(
'port create -f json --network %s %sx' % 'port create --network %s %sx' %
(self.NETWORK_NAME, self.NAME) (self.NETWORK_NAME, self.NAME),
)) parse_output=True,
)
id2 = json_output.get('id') id2 = json_output.get('id')
self.assertIsNotNone(id2) self.assertIsNotNone(id2)
self.assertIsNotNone(json_output.get('mac_address')) self.assertIsNotNone(json_output.get('mac_address'))
@ -79,10 +80,11 @@ class PortTests(common.NetworkTagTests):
def test_port_list(self): def test_port_list(self):
"""Test create defaults, list, delete""" """Test create defaults, list, delete"""
json_output = json.loads(self.openstack( json_output = self.openstack(
'port create -f json --network %s %s' % 'port create --network %s %s' %
(self.NETWORK_NAME, self.NAME) (self.NETWORK_NAME, self.NAME),
)) parse_output=True,
)
id1 = json_output.get('id') id1 = json_output.get('id')
self.assertIsNotNone(id1) self.assertIsNotNone(id1)
mac1 = json_output.get('mac_address') mac1 = json_output.get('mac_address')
@ -90,10 +92,11 @@ class PortTests(common.NetworkTagTests):
self.addCleanup(self.openstack, 'port delete %s' % id1) self.addCleanup(self.openstack, 'port delete %s' % id1)
self.assertEqual(self.NAME, json_output.get('name')) self.assertEqual(self.NAME, json_output.get('name'))
json_output = json.loads(self.openstack( json_output = self.openstack(
'port create -f json --network %s %sx' % 'port create --network %s %sx' %
(self.NETWORK_NAME, self.NAME) (self.NETWORK_NAME, self.NAME),
)) parse_output=True,
)
id2 = json_output.get('id') id2 = json_output.get('id')
self.assertIsNotNone(id2) self.assertIsNotNone(id2)
mac2 = json_output.get('mac_address') mac2 = json_output.get('mac_address')
@ -102,9 +105,10 @@ class PortTests(common.NetworkTagTests):
self.assertEqual(self.NAME + 'x', json_output.get('name')) self.assertEqual(self.NAME + 'x', json_output.get('name'))
# Test list # Test list
json_output = json.loads(self.openstack( json_output = self.openstack(
'port list -f json' 'port list',
)) parse_output=True,
)
item_map = {item.get('ID'): item.get('MAC Address') for item in item_map = {item.get('ID'): item.get('MAC Address') for item in
json_output} json_output}
self.assertIn(id1, item_map.keys()) self.assertIn(id1, item_map.keys())
@ -113,17 +117,19 @@ class PortTests(common.NetworkTagTests):
self.assertIn(mac2, item_map.values()) self.assertIn(mac2, item_map.values())
# Test list --long # Test list --long
json_output = json.loads(self.openstack( json_output = self.openstack(
'port list --long -f json' 'port list --long',
)) parse_output=True,
)
id_list = [item.get('ID') for item in json_output] id_list = [item.get('ID') for item in json_output]
self.assertIn(id1, id_list) self.assertIn(id1, id_list)
self.assertIn(id2, id_list) self.assertIn(id2, id_list)
# Test list --mac-address # Test list --mac-address
json_output = json.loads(self.openstack( json_output = self.openstack(
'port list -f json --mac-address %s' % mac2 'port list --mac-address %s' % mac2,
)) parse_output=True,
)
item_map = {item.get('ID'): item.get('MAC Address') for item in item_map = {item.get('ID'): item.get('MAC Address') for item in
json_output} json_output}
self.assertNotIn(id1, item_map.keys()) self.assertNotIn(id1, item_map.keys())
@ -132,9 +138,10 @@ class PortTests(common.NetworkTagTests):
self.assertIn(mac2, item_map.values()) self.assertIn(mac2, item_map.values())
# Test list with unknown fields # Test list with unknown fields
json_output = json.loads(self.openstack( json_output = self.openstack(
'port list -f json -c ID -c Name -c device_id' 'port list -c ID -c Name -c device_id',
)) parse_output=True,
)
id_list = [p['ID'] for p in json_output] id_list = [p['ID'] for p in json_output]
self.assertIn(id1, id_list) self.assertIn(id1, id_list)
self.assertIn(id2, id_list) self.assertIn(id2, id_list)
@ -144,13 +151,14 @@ class PortTests(common.NetworkTagTests):
def test_port_set(self): def test_port_set(self):
"""Test create, set, show, delete""" """Test create, set, show, delete"""
name = uuid.uuid4().hex name = uuid.uuid4().hex
json_output = json.loads(self.openstack( json_output = self.openstack(
'port create -f json ' 'port create '
'--network %s ' '--network %s '
'--description xyzpdq ' '--description xyzpdq '
'--disable %s' % '--disable %s' %
(self.NETWORK_NAME, name) (self.NETWORK_NAME, name),
)) parse_output=True,
)
id1 = json_output.get('id') id1 = json_output.get('id')
self.addCleanup(self.openstack, 'port delete %s' % id1) self.addCleanup(self.openstack, 'port delete %s' % id1)
self.assertEqual(name, json_output.get('name')) self.assertEqual(name, json_output.get('name'))
@ -163,9 +171,10 @@ class PortTests(common.NetworkTagTests):
) )
self.assertOutput('', raw_output) self.assertOutput('', raw_output)
json_output = json.loads(self.openstack( json_output = self.openstack(
'port show -f json %s' % name 'port show %s' % name,
)) parse_output=True,
)
sg_id = json_output.get('security_group_ids')[0] sg_id = json_output.get('security_group_ids')[0]
self.assertEqual(name, json_output.get('name')) self.assertEqual(name, json_output.get('name'))
@ -177,17 +186,19 @@ class PortTests(common.NetworkTagTests):
'port unset --security-group %s %s' % (sg_id, id1)) 'port unset --security-group %s %s' % (sg_id, id1))
self.assertOutput('', raw_output) self.assertOutput('', raw_output)
json_output = json.loads(self.openstack( json_output = self.openstack(
'port show -f json %s' % name 'port show %s' % name,
)) parse_output=True,
)
self.assertEqual([], json_output.get('security_group_ids')) self.assertEqual([], json_output.get('security_group_ids'))
def test_port_admin_set(self): def test_port_admin_set(self):
"""Test create, set (as admin), show, delete""" """Test create, set (as admin), show, delete"""
json_output = json.loads(self.openstack( json_output = self.openstack(
'port create -f json ' 'port create '
'--network %s %s' % (self.NETWORK_NAME, self.NAME) '--network %s %s' % (self.NETWORK_NAME, self.NAME),
)) parse_output=True,
)
id_ = json_output.get('id') id_ = json_output.get('id')
self.addCleanup(self.openstack, 'port delete %s' % id_) self.addCleanup(self.openstack, 'port delete %s' % id_)
@ -196,36 +207,40 @@ class PortTests(common.NetworkTagTests):
'port set --mac-address 11:22:33:44:55:66 %s' % 'port set --mac-address 11:22:33:44:55:66 %s' %
self.NAME) self.NAME)
self.assertOutput('', raw_output) self.assertOutput('', raw_output)
json_output = json.loads(self.openstack( json_output = self.openstack(
'port show -f json %s' % self.NAME 'port show %s' % self.NAME,
)) parse_output=True,
)
self.assertEqual(json_output.get('mac_address'), '11:22:33:44:55:66') self.assertEqual(json_output.get('mac_address'), '11:22:33:44:55:66')
def test_port_set_sg(self): def test_port_set_sg(self):
"""Test create, set, show, delete""" """Test create, set, show, delete"""
sg_name1 = uuid.uuid4().hex sg_name1 = uuid.uuid4().hex
json_output = json.loads(self.openstack( json_output = self.openstack(
'security group create -f json %s' % 'security group create %s' %
sg_name1 sg_name1,
)) parse_output=True,
)
sg_id1 = json_output.get('id') sg_id1 = json_output.get('id')
self.addCleanup(self.openstack, 'security group delete %s' % sg_id1) self.addCleanup(self.openstack, 'security group delete %s' % sg_id1)
sg_name2 = uuid.uuid4().hex sg_name2 = uuid.uuid4().hex
json_output = json.loads(self.openstack( json_output = self.openstack(
'security group create -f json %s' % 'security group create %s' %
sg_name2 sg_name2,
)) parse_output=True,
)
sg_id2 = json_output.get('id') sg_id2 = json_output.get('id')
self.addCleanup(self.openstack, 'security group delete %s' % sg_id2) self.addCleanup(self.openstack, 'security group delete %s' % sg_id2)
name = uuid.uuid4().hex name = uuid.uuid4().hex
json_output = json.loads(self.openstack( json_output = self.openstack(
'port create -f json ' 'port create '
'--network %s ' '--network %s '
'--security-group %s %s' % '--security-group %s %s' %
(self.NETWORK_NAME, sg_name1, name) (self.NETWORK_NAME, sg_name1, name),
)) parse_output=True,
)
id1 = json_output.get('id') id1 = json_output.get('id')
self.addCleanup(self.openstack, 'port delete %s' % id1) self.addCleanup(self.openstack, 'port delete %s' % id1)
self.assertEqual(name, json_output.get('name')) self.assertEqual(name, json_output.get('name'))
@ -238,9 +253,10 @@ class PortTests(common.NetworkTagTests):
) )
self.assertOutput('', raw_output) self.assertOutput('', raw_output)
json_output = json.loads(self.openstack( json_output = self.openstack(
'port show -f json %s' % name 'port show %s' % name,
)) parse_output=True,
)
self.assertEqual(name, json_output.get('name')) self.assertEqual(name, json_output.get('name'))
# NOTE(amotoki): The order of the field is not predictable, # NOTE(amotoki): The order of the field is not predictable,
self.assertIsInstance(json_output.get('security_group_ids'), list) self.assertIsInstance(json_output.get('security_group_ids'), list)
@ -251,16 +267,18 @@ class PortTests(common.NetworkTagTests):
'port unset --security-group %s %s' % (sg_id1, id1)) 'port unset --security-group %s %s' % (sg_id1, id1))
self.assertOutput('', raw_output) self.assertOutput('', raw_output)
json_output = json.loads(self.openstack( json_output = self.openstack(
'port show -f json %s' % name 'port show %s' % name,
)) parse_output=True,
)
self.assertEqual( self.assertEqual(
[sg_id2], [sg_id2],
json_output.get('security_group_ids') json_output.get('security_group_ids')
) )
def _create_resource_for_tag_test(self, name, args): def _create_resource_for_tag_test(self, name, args):
return json.loads(self.openstack( return self.openstack(
'{} create -f json --network {} {} {}' '{} create --network {} {} {}'
.format(self.base_command, self.NETWORK_NAME, args, name) .format(self.base_command, self.NETWORK_NAME, args, name),
)) parse_output=True,
)

154
openstackclient/tests/functional/network/v2/test_router.py

@ -10,7 +10,6 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
import json
import uuid import uuid
from openstackclient.tests.functional.network.v2 import common from openstackclient.tests.functional.network.v2 import common
@ -31,18 +30,20 @@ class RouterTests(common.NetworkTagTests):
"""Test create options, delete multiple""" """Test create options, delete multiple"""
name1 = uuid.uuid4().hex name1 = uuid.uuid4().hex
name2 = uuid.uuid4().hex name2 = uuid.uuid4().hex
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'router create -f json ' + 'router create ' +
name1 name1,
)) parse_output=True,
)
self.assertEqual( self.assertEqual(
name1, name1,
cmd_output["name"], cmd_output["name"],
) )
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'router create -f json ' + 'router create ' +
name2 name2,
)) parse_output=True,
)
self.assertEqual( self.assertEqual(
name2, name2,
cmd_output["name"], cmd_output["name"],
@ -55,10 +56,10 @@ class RouterTests(common.NetworkTagTests):
def test_router_list(self): def test_router_list(self):
"""Test create, list filter""" """Test create, list filter"""
# Get project IDs # Get project IDs
cmd_output = json.loads(self.openstack('token issue -f json ')) cmd_output = self.openstack('token issue', parse_output=True)
auth_project_id = cmd_output['project_id'] auth_project_id = cmd_output['project_id']
cmd_output = json.loads(self.openstack('project list -f json ')) cmd_output = self.openstack('project list', parse_output=True)
admin_project_id = None admin_project_id = None
demo_project_id = None demo_project_id = None
for p in cmd_output: for p in cmd_output:
@ -78,11 +79,12 @@ class RouterTests(common.NetworkTagTests):
name1 = uuid.uuid4().hex name1 = uuid.uuid4().hex
name2 = uuid.uuid4().hex name2 = uuid.uuid4().hex
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'router create -f json ' + 'router create ' +
'--disable ' + '--disable ' +
name1 name1,
)) parse_output=True,
)
self.addCleanup(self.openstack, 'router delete ' + name1) self.addCleanup(self.openstack, 'router delete ' + name1)
self.assertEqual( self.assertEqual(
@ -97,11 +99,12 @@ class RouterTests(common.NetworkTagTests):
admin_project_id, admin_project_id,
cmd_output["project_id"], cmd_output["project_id"],
) )
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'router create -f json ' + 'router create ' +
'--project ' + demo_project_id + '--project ' + demo_project_id +
' ' + name2 ' ' + name2,
)) parse_output=True,
)
self.addCleanup(self.openstack, 'router delete ' + name2) self.addCleanup(self.openstack, 'router delete ' + name2)
self.assertEqual( self.assertEqual(
@ -118,37 +121,41 @@ class RouterTests(common.NetworkTagTests):
) )
# Test list --project # Test list --project
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'router list -f json ' + 'router list ' +
'--project ' + demo_project_id '--project ' + demo_project_id,
)) parse_output=True,
)
names = [x["Name"] for x in cmd_output] names = [x["Name"] for x in cmd_output]
self.assertNotIn(name1, names) self.assertNotIn(name1, names)
self.assertIn(name2, names) self.assertIn(name2, names)
# Test list --disable # Test list --disable
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'router list -f json ' + 'router list ' +
'--disable ' '--disable ',
)) parse_output=True,
)
names = [x["Name"] for x in cmd_output] names = [x["Name"] for x in cmd_output]
self.assertIn(name1, names) self.assertIn(name1, names)
self.assertNotIn(name2, names) self.assertNotIn(name2, names)
# Test list --name # Test list --name
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'router list -f json ' + 'router list ' +
'--name ' + name1 '--name ' + name1,
)) parse_output=True,
)
names = [x["Name"] for x in cmd_output] names = [x["Name"] for x in cmd_output]
self.assertIn(name1, names) self.assertIn(name1, names)
self.assertNotIn(name2, names) self.assertNotIn(name2, names)
# Test list --long # Test list --long
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'router list -f json ' + 'router list ' +
'--long ' '--long ',
)) parse_output=True,
)
names = [x["Name"] for x in cmd_output] names = [x["Name"] for x in cmd_output]
self.assertIn(name1, names) self.assertIn(name1, names)
self.assertIn(name2, names) self.assertIn(name2, names)
@ -160,15 +167,17 @@ class RouterTests(common.NetworkTagTests):
self.skipTest("No l3_agent_scheduler extension present") self.skipTest("No l3_agent_scheduler extension present")
name = uuid.uuid4().hex name = uuid.uuid4().hex
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'router create -f json ' + name)) 'router create ' + name,
parse_output=True,)
self.addCleanup(self.openstack, 'router delete ' + name) self.addCleanup(self.openstack, 'router delete ' + name)
# Get router ID # Get router ID
router_id = cmd_output['id'] router_id = cmd_output['id']
# Get l3 agent id # Get l3 agent id
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'network agent list -f json --agent-type l3')) 'network agent list --agent-type l3',
parse_output=True,)
# Check at least one L3 agent is included in the response. # Check at least one L3 agent is included in the response.
self.assertTrue(cmd_output) self.assertTrue(cmd_output)
@ -178,16 +187,18 @@ class RouterTests(common.NetworkTagTests):
self.openstack( self.openstack(
'network agent add router --l3 ' + agent_id + ' ' + router_id) 'network agent add router --l3 ' + agent_id + ' ' + router_id)
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'router list -f json --agent ' + agent_id)) 'router list --agent ' + agent_id,
parse_output=True,)
router_ids = [x['ID'] for x in cmd_output] router_ids = [x['ID'] for x in cmd_output]
self.assertIn(router_id, router_ids) self.assertIn(router_id, router_ids)
# Remove router from agent # Remove router from agent
self.openstack( self.openstack(
'network agent remove router --l3 ' + agent_id + ' ' + router_id) 'network agent remove router --l3 ' + agent_id + ' ' + router_id)
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'router list -f json --agent ' + agent_id)) 'router list --agent ' + agent_id,
parse_output=True,)
router_ids = [x['ID'] for x in cmd_output] router_ids = [x['ID'] for x in cmd_output]
self.assertNotIn(router_id, router_ids) self.assertNotIn(router_id, router_ids)
@ -196,11 +207,12 @@ class RouterTests(common.NetworkTagTests):
name = uuid.uuid4().hex name = uuid.uuid4().hex
new_name = name + "_" new_name = name + "_"
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'router create -f json ' + 'router create ' +
'--description aaaa ' + '--description aaaa ' +
name name,
)) parse_output=True,
)
self.addCleanup(self.openstack, 'router delete ' + new_name) self.addCleanup(self.openstack, 'router delete ' + new_name)
self.assertEqual( self.assertEqual(
name, name,
@ -221,10 +233,11 @@ class RouterTests(common.NetworkTagTests):
) )
self.assertOutput('', cmd_output) self.assertOutput('', cmd_output)
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'router show -f json ' + 'router show ' +
new_name new_name,
)) parse_output=True,
)
self.assertEqual( self.assertEqual(
new_name, new_name,
cmd_output["name"], cmd_output["name"],
@ -247,10 +260,11 @@ class RouterTests(common.NetworkTagTests):
'--external-gateway ' + '--external-gateway ' +
new_name new_name
) )
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'router show -f json ' + 'router show ' +
new_name new_name,
)) parse_output=True,
)
self.assertIsNone(cmd_output["external_gateway_info"]) self.assertIsNone(cmd_output["external_gateway_info"])
def _test_set_router_distributed(self, router_name): def _test_set_router_distributed(self, router_name):
@ -265,10 +279,11 @@ class RouterTests(common.NetworkTagTests):
) )
self.assertOutput('', cmd_output) self.assertOutput('', cmd_output)
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'router show -f json ' + 'router show ' +
router_name router_name,
)) parse_output=True,
)
self.assertTrue(cmd_output["distributed"]) self.assertTrue(cmd_output["distributed"])
self.assertIsNotNone(cmd_output["external_gateway_info"]) self.assertIsNotNone(cmd_output["external_gateway_info"])
@ -292,25 +307,28 @@ class RouterTests(common.NetworkTagTests):
self.addCleanup(self.openstack, 'router remove subnet %s %s' % ( self.addCleanup(self.openstack, 'router remove subnet %s %s' % (
router_name, subnet_name)) router_name, subnet_name))
out1 = json.loads(self.openstack( out1 = self.openstack(
'router add route -f json %s ' 'router add route %s '
'--route destination=10.0.10.0/24,gateway=10.0.0.10' % '--route destination=10.0.10.0/24,gateway=10.0.0.10' %
router_name)), router_name,
parse_output=True,),
self.assertEqual(1, len(out1[0]['routes'])) self.assertEqual(1, len(out1[0]['routes']))
self.addCleanup( self.addCleanup(
self.openstack, 'router set %s --no-route' % router_name) self.openstack, 'router set %s --no-route' % router_name)
out2 = json.loads(self.openstack( out2 = self.openstack(
'router add route -f json %s ' 'router add route %s '
'--route destination=10.0.10.0/24,gateway=10.0.0.10 ' '--route destination=10.0.10.0/24,gateway=10.0.0.10 '
'--route destination=10.0.11.0/24,gateway=10.0.0.11' % '--route destination=10.0.11.0/24,gateway=10.0.0.11' %
router_name)), router_name,
parse_output=True,),
self.assertEqual(2, len(out2[0]['routes'])) self.assertEqual(2, len(out2[0]['routes']))
out3 = json.loads(self.openstack( out3 = self.openstack(
'router remove route -f json %s ' 'router remove route %s '
'--route destination=10.0.11.0/24,gateway=10.0.0.11 ' '--route destination=10.0.11.0/24,gateway=10.0.0.11 '
'--route destination=10.0.12.0/24,gateway=10.0.0.12' % '--route destination=10.0.12.0/24,gateway=10.0.0.12' %
router_name)), router_name,
parse_output=True,),
self.assertEqual(1, len(out3[0]['routes'])) self.assertEqual(1, len(out3[0]['routes']))

24
openstackclient/tests/functional/network/v2/test_security_group.py

@ -10,7 +10,6 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
import json
import uuid import uuid
from openstackclient.tests.functional.network.v2 import common from openstackclient.tests.functional.network.v2 import common
@ -27,16 +26,17 @@ class SecurityGroupTests(common.NetworkTests):
self.NAME = uuid.uuid4().hex self.NAME = uuid.uuid4().hex
self.OTHER_NAME = uuid.uuid4().hex self.OTHER_NAME = uuid.uuid4().hex
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'security group create -f json ' + 'security group create ' +
self.NAME self.NAME,
)) parse_output=True,
)
self.addCleanup(self.openstack, self.addCleanup(self.openstack,
'security group delete ' + cmd_output['id']) 'security group delete ' + cmd_output['id'])
self.assertEqual(self.NAME, cmd_output['name']) self.assertEqual(self.NAME, cmd_output['name'])
def test_security_group_list(self): def test_security_group_list(self):
cmd_output = json.loads(self.openstack('security group list -f json')) cmd_output = self.openstack('security group list', parse_output=True)
self.assertIn(self.NAME, [sg['Name'] for sg in cmd_output]) self.assertIn(self.NAME, [sg['Name'] for sg in cmd_output])
def test_security_group_set(self): def test_security_group_set(self):
@ -47,13 +47,17 @@ class SecurityGroupTests(common.NetworkTests):
) )
self.assertEqual('', raw_output) self.assertEqual('', raw_output)
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'security group show -f json ' + other_name)) 'security group show ' + other_name,
parse_output=True,
)
self.assertEqual('NSA', cmd_output['description']) self.assertEqual('NSA', cmd_output['description'])
self.assertFalse(cmd_output['stateful']) self.assertFalse(cmd_output['stateful'])
def test_security_group_show(self): def test_security_group_show(self):
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'security group show -f json ' + self.NAME)) 'security group show ' + self.NAME,
parse_output=True,
)
self.assertEqual(self.NAME, cmd_output['name']) self.assertEqual(self.NAME, cmd_output['name'])
self.assertTrue(cmd_output['stateful']) self.assertTrue(cmd_output['stateful'])

31
openstackclient/tests/functional/network/v2/test_security_group_rule.py

@ -10,7 +10,6 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
import json
import uuid import uuid
from openstackclient.tests.functional.network.v2 import common from openstackclient.tests.functional.network.v2 import common
@ -28,32 +27,38 @@ class SecurityGroupRuleTests(common.NetworkTests):
self.SECURITY_GROUP_NAME = uuid.uuid4().hex self.SECURITY_GROUP_NAME = uuid.uuid4().hex
# Create the security group to hold the rule # Create the security group to hold the rule
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'security group create -f json ' + 'security group create ' +
self.SECURITY_GROUP_NAME self.SECURITY_GROUP_NAME,
)) parse_output=True,
)
self.addCleanup(self.openstack, self.addCleanup(self.openstack,
'security group delete ' + self.SECURITY_GROUP_NAME) 'security group delete ' + self.SECURITY_GROUP_NAME)
self.assertEqual(self.SECURITY_GROUP_NAME, cmd_output['name']) self.assertEqual(self.SECURITY_GROUP_NAME, cmd_output['name'])
# Create the security group rule. # Create the security group rule.
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'security group rule create -f json ' + 'security group rule create ' +
self.SECURITY_GROUP_NAME + ' ' + self.SECURITY_GROUP_NAME + ' ' +
'--protocol tcp --dst-port 80:80 ' + '--protocol tcp --dst-port 80:80 ' +
'--ingress --ethertype IPv4 ' '--ingress --ethertype IPv4 ',
)) parse_output=True,
)
self.addCleanup(self.openstack, self.addCleanup(self.openstack,
'security group rule delete ' + cmd_output['id']) 'security group rule delete ' + cmd_output['id'])
self.SECURITY_GROUP_RULE_ID = cmd_output['id'] self.SECURITY_GROUP_RULE_ID = cmd_output['id']
def test_security_group_rule_list(self): def test_security_group_rule_list(self):
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'security group rule list -f json ' + self.SECURITY_GROUP_NAME)) 'security group rule list ' + self.SECURITY_GROUP_NAME,
parse_output=True,
)
self.assertIn(self.SECURITY_GROUP_RULE_ID, self.assertIn(self.SECURITY_GROUP_RULE_ID,
[rule['ID'] for rule in cmd_output]) [rule['ID'] for rule in cmd_output])
def test_security_group_rule_show(self): def test_security_group_rule_show(self):
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'security group rule show -f json ' + self.SECURITY_GROUP_RULE_ID)) 'security group rule show ' + self.SECURITY_GROUP_RULE_ID,
parse_output=True,
)
self.assertEqual(self.SECURITY_GROUP_RULE_ID, cmd_output['id']) self.assertEqual(self.SECURITY_GROUP_RULE_ID, cmd_output['id'])

92
openstackclient/tests/functional/network/v2/test_subnet.py

@ -10,7 +10,6 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
import json
import random import random
import uuid import uuid
@ -29,10 +28,11 @@ class SubnetTests(common.NetworkTagTests):
cls.NETWORK_NAME = uuid.uuid4().hex cls.NETWORK_NAME = uuid.uuid4().hex
# Create a network for the all subnet tests # Create a network for the all subnet tests
cmd_output = json.loads(cls.openstack( cmd_output = cls.openstack(
'network create -f json ' + 'network create ' +
cls.NETWORK_NAME cls.NETWORK_NAME,
)) parse_output=True,
)
# Get network_id for assertEqual # Get network_id for assertEqual
cls.NETWORK_ID = cmd_output["id"] cls.NETWORK_ID = cmd_output["id"]
@ -57,7 +57,7 @@ class SubnetTests(common.NetworkTagTests):
def test_subnet_create_and_delete(self): def test_subnet_create_and_delete(self):
"""Test create, delete multiple""" """Test create, delete multiple"""
name1 = uuid.uuid4().hex name1 = uuid.uuid4().hex
cmd = ('subnet create -f json --network ' + cmd = ('subnet create --network ' +
self.NETWORK_NAME + self.NETWORK_NAME +
' --subnet-range') ' --subnet-range')
cmd_output = self._subnet_create(cmd, name1) cmd_output = self._subnet_create(cmd, name1)
@ -70,7 +70,7 @@ class SubnetTests(common.NetworkTagTests):
cmd_output["network_id"], cmd_output["network_id"],
) )
name2 = uuid.uuid4().hex name2 = uuid.uuid4().hex
cmd = ('subnet create -f json --network ' + cmd = ('subnet create --network ' +
self.NETWORK_NAME + self.NETWORK_NAME +
' --subnet-range') ' --subnet-range')
cmd_output = self._subnet_create(cmd, name2) cmd_output = self._subnet_create(cmd, name2)
@ -91,7 +91,7 @@ class SubnetTests(common.NetworkTagTests):
"""Test create, list filter""" """Test create, list filter"""
name1 = uuid.uuid4().hex name1 = uuid.uuid4().hex
name2 = uuid.uuid4().hex name2 = uuid.uuid4().hex
cmd = ('subnet create -f json ' + cmd = ('subnet create ' +
'--network ' + self.NETWORK_NAME + '--network ' + self.NETWORK_NAME +
' --dhcp --subnet-range') ' --dhcp --subnet-range')
cmd_output = self._subnet_create(cmd, name1) cmd_output = self._subnet_create(cmd, name1)
@ -114,7 +114,7 @@ class SubnetTests(common.NetworkTagTests):
cmd_output["ip_version"], cmd_output["ip_version"],
) )
cmd = ('subnet create -f json ' + cmd = ('subnet create ' +
'--network ' + self.NETWORK_NAME + '--network ' + self.NETWORK_NAME +
' --ip-version 6 --no-dhcp ' + ' --ip-version 6 --no-dhcp ' +
'--subnet-range') '--subnet-range')
@ -139,46 +139,51 @@ class SubnetTests(common.NetworkTagTests):
) )
# Test list --long # Test list --long
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'subnet list -f json ' + 'subnet list ' +
'--long ' '--long ',
)) parse_output=True,
)
names = [x["Name"] for x in cmd_output] names = [x["Name"] for x in cmd_output]
self.assertIn(name1, names) self.assertIn(name1, names)
self.assertIn(name2, names) self.assertIn(name2, names)
# Test list --name # Test list --name
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'subnet list -f json ' + 'subnet list ' +
'--name ' + name1 '--name ' + name1,
)) parse_output=True,
)
names = [x["Name"] for x in cmd_output] names = [x["Name"] for x in cmd_output]
self.assertIn(name1, names) self.assertIn(name1, names)
self.assertNotIn(name2, names) self.assertNotIn(name2, names)
# Test list --ip-version # Test list --ip-version
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'subnet list -f json ' + 'subnet list ' +
'--ip-version 6' '--ip-version 6',
)) parse_output=True,
)
names = [x["Name"] for x in cmd_output] names = [x["Name"] for x in cmd_output]
self.assertNotIn(name1, names) self.assertNotIn(name1, names)
self.assertIn(name2, names) self.assertIn(name2, names)
# Test list --network # Test list --network
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'subnet list -f json ' + 'subnet list ' +
'--network ' + self.NETWORK_ID '--network ' + self.NETWORK_ID,
)) parse_output=True,
)
names = [x["Name"] for x in cmd_output] names = [x["Name"] for x in cmd_output]
self.assertIn(name1, names) self.assertIn(name1, names)
self.assertIn(name2, names) self.assertIn(name2, names)
# Test list --no-dhcp # Test list --no-dhcp
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'subnet list -f json ' + 'subnet list ' +
'--no-dhcp ' '--no-dhcp ',
)) parse_output=True,
)
names = [x["Name"] for x in cmd_output] names = [x["Name"] for x in cmd_output]
self.assertNotIn(name1, names) self.assertNotIn(name1, names)
self.assertIn(name2, names) self.assertIn(name2, names)
@ -188,7 +193,7 @@ class SubnetTests(common.NetworkTagTests):
name = uuid.uuid4().hex name = uuid.uuid4().hex
new_name = name + "_" new_name = name + "_"
cmd = ('subnet create -f json ' + cmd = ('subnet create ' +
'--network ' + self.NETWORK_NAME + '--network ' + self.NETWORK_NAME +
' --description aaaa --subnet-range') ' --description aaaa --subnet-range')
cmd_output = self._subnet_create(cmd, name) cmd_output = self._subnet_create(cmd, name)
@ -215,10 +220,11 @@ class SubnetTests(common.NetworkTagTests):
) )
self.assertOutput('', cmd_output) self.assertOutput('', cmd_output)
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'subnet show -f json ' + 'subnet show ' +
new_name new_name,
)) parse_output=True,
)
self.assertEqual( self.assertEqual(
new_name, new_name,
cmd_output["name"], cmd_output["name"],
@ -248,10 +254,11 @@ class SubnetTests(common.NetworkTagTests):
) )
self.assertOutput('', cmd_output) self.assertOutput('', cmd_output)
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'subnet show -f json ' + 'subnet show ' +
new_name new_name,
)) parse_output=True,
)
self.assertEqual( self.assertEqual(
[], [],
cmd_output["service_types"], cmd_output["service_types"],
@ -274,10 +281,11 @@ class SubnetTests(common.NetworkTagTests):
(hex(random.randint(0, 65535))[2:] for _ in range(7)) (hex(random.randint(0, 65535))[2:] for _ in range(7))
)) + ":0/112" )) + ":0/112"
try: try:
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
cmd + ' ' + subnet + ' ' + cmd + ' ' + subnet + ' ' +
name name,
)) parse_output=True,
)
except Exception: except Exception:
if (i == 3): if (i == 3):
# raise the exception at the last time # raise the exception at the last time
@ -289,7 +297,7 @@ class SubnetTests(common.NetworkTagTests):
return cmd_output return cmd_output
def _create_resource_for_tag_test(self, name, args): def _create_resource_for_tag_test(self, name, args):
cmd = ('subnet create -f json --network ' + cmd = ('subnet create --network ' +
self.NETWORK_NAME + ' ' + args + self.NETWORK_NAME + ' ' + args +
' --subnet-range') ' --subnet-range')
return self._subnet_create(cmd, name) return self._subnet_create(cmd, name)

59
openstackclient/tests/functional/network/v2/test_subnet_pool.py

@ -10,7 +10,6 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
import json
import random import random
import uuid import uuid
@ -61,10 +60,10 @@ class SubnetPoolTests(common.NetworkTagTests):
def test_subnet_pool_list(self): def test_subnet_pool_list(self):
"""Test create, list filter""" """Test create, list filter"""
cmd_output = json.loads(self.openstack('token issue -f json')) cmd_output = self.openstack('token issue', parse_output=True)
auth_project_id = cmd_output['project_id'] auth_project_id = cmd_output['project_id']
cmd_output = json.loads(self.openstack('project list -f json')) cmd_output = self.openstack('project list', parse_output=True)
admin_project_id = None admin_project_id = None
demo_project_id = None demo_project_id = None
for p in cmd_output: for p in cmd_output:
@ -131,37 +130,41 @@ class SubnetPoolTests(common.NetworkTagTests):
) )
# Test list --project # Test list --project
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'subnet pool list -f json ' + 'subnet pool list ' +
'--project ' + demo_project_id '--project ' + demo_project_id,
)) parse_output=True,
)
names = [x["Name"] for x in cmd_output] names = [x["Name"] for x in cmd_output]
self.assertIn(name1, names) self.assertIn(name1, names)
self.assertNotIn(name2, names) self.assertNotIn(name2, names)
# Test list --share # Test list --share
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'subnet pool list -f json ' + 'subnet pool list ' +
'--share' '--share',
)) parse_output=True,
)
names = [x["Name"] for x in cmd_output] names = [x["Name"] for x in cmd_output]
self.assertNotIn(name1, names) self.assertNotIn(name1, names)
self.assertIn(name2, names) self.assertIn(name2, names)
# Test list --name # Test list --name
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'subnet pool list -f json ' + 'subnet pool list ' +
'--name ' + name1 '--name ' + name1,
)) parse_output=True,
)
names = [x["Name"] for x in cmd_output] names = [x["Name"] for x in cmd_output]
self.assertIn(name1, names) self.assertIn(name1, names)
self.assertNotIn(name2, names) self.assertNotIn(name2, names)
# Test list --long # Test list --long
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'subnet pool list -f json ' + 'subnet pool list ' +
'--long ' '--long ',
)) parse_output=True,
)
names = [x["Name"] for x in cmd_output] names = [x["Name"] for x in cmd_output]
self.assertIn(name1, names) self.assertIn(name1, names)
self.assertIn(name2, names) self.assertIn(name2, names)
@ -227,10 +230,11 @@ class SubnetPoolTests(common.NetworkTagTests):
) )
self.assertOutput('', cmd_output) self.assertOutput('', cmd_output)
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'subnet pool show -f json ' + 'subnet pool show ' +
new_name new_name,
)) parse_output=True,
)
self.assertEqual( self.assertEqual(
new_name, new_name,
cmd_output["name"], cmd_output["name"],
@ -307,12 +311,13 @@ class SubnetPoolTests(common.NetworkTagTests):
)) + ":0:0/96" )) + ":0:0/96"
try: try:
cmd_output = json.loads(self.openstack( cmd_output = self.openstack(
'subnet pool create -f json ' + 'subnet pool create ' +
cmd + ' ' + cmd + ' ' +
'--pool-prefix ' + pool_prefix + ' ' + '--pool-prefix ' + pool_prefix + ' ' +
name name,
)) parse_output=True,
)
except Exception: except Exception:
if (i == 3): if (i == 3):
# Raise the exception the last time # Raise the exception the last time