9bab0960b6
This change condenses the directory structure to something more similar to what we had before while producing similar packages. It also introduces version.py which allows us to get the version from git tags (or a fallback version if not available). Fixes lp bug 889336 Fixes lp bug 888795 Change-Id: I86136bd9dbabb5eb1f8366ed665ed9b54f695124
626 lines
22 KiB
Python
626 lines
22 KiB
Python
# vim: tabstop=4 shiftwidth=4 softtabstop=4
|
|
|
|
# Copyright 2011 Cisco Systems
|
|
# All Rights Reserved.
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License"); you may
|
|
# not use this file except in compliance with the License. You may obtain
|
|
# a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
# License for the specific language governing permissions and limitations
|
|
# under the License.
|
|
# @author: Tyler Smith, Cisco Systems
|
|
|
|
import logging
|
|
import unittest
|
|
import re
|
|
|
|
from quantum.common.serializer import Serializer
|
|
from quantum.client import Client
|
|
|
|
LOG = logging.getLogger('quantum.tests.test_api')
|
|
|
|
# Set a couple tenants to use for testing
|
|
TENANT_1 = 'totore'
|
|
TENANT_2 = 'totore2'
|
|
|
|
|
|
class ServerStub():
|
|
"""This class stubs a basic server for the API client to talk to"""
|
|
|
|
class Response(object):
|
|
"""This class stubs a basic response to send the API client"""
|
|
def __init__(self, content=None, status=None):
|
|
self.content = content
|
|
self.status = status
|
|
|
|
def read(self):
|
|
return self.content
|
|
|
|
def status(self):
|
|
return self.status
|
|
|
|
# To test error codes, set the host to 10.0.0.1, and the port to the code
|
|
def __init__(self, host, port=9696, key_file="", cert_file=""):
|
|
self.host = host
|
|
self.port = port
|
|
self.key_file = key_file
|
|
self.cert_file = cert_file
|
|
|
|
def request(self, method, action, body, headers):
|
|
self.method = method
|
|
self.action = action
|
|
self.body = body
|
|
|
|
def status(self, status=None):
|
|
return status or 200
|
|
|
|
def getresponse(self):
|
|
res = self.Response(status=self.status())
|
|
|
|
# If the host is 10.0.0.1, return the port as an error code
|
|
if self.host == "10.0.0.1":
|
|
res.status = self.port
|
|
return res
|
|
|
|
# Extract important information from the action string to assure sanity
|
|
match = re.search('tenants/(.+?)/(.+)\.(json|xml)$', self.action)
|
|
|
|
tenant = match.group(1)
|
|
path = match.group(2)
|
|
format = match.group(3)
|
|
|
|
data = {'data': {'method': self.method, 'action': self.action,
|
|
'body': self.body, 'tenant': tenant, 'path': path,
|
|
'format': format, 'key_file': self.key_file,
|
|
'cert_file': self.cert_file}}
|
|
|
|
# Serialize it to the proper format so the API client can handle it
|
|
if data['data']['format'] == 'json':
|
|
res.content = Serializer().serialize(data, "application/json")
|
|
else:
|
|
res.content = Serializer().serialize(data, "application/xml")
|
|
return res
|
|
|
|
|
|
class APITest(unittest.TestCase):
|
|
|
|
def setUp(self):
|
|
""" Setups a test environment for the API client """
|
|
HOST = '127.0.0.1'
|
|
PORT = 9696
|
|
USE_SSL = False
|
|
|
|
self.client = Client(HOST, PORT, USE_SSL, TENANT_1, 'json', ServerStub)
|
|
|
|
def _assert_sanity(self, call, status, method, path, data=[], params={}):
|
|
""" Perform common assertions to test the sanity of client requests """
|
|
|
|
# Handle an error case first
|
|
if status != 200:
|
|
(self.client.host, self.client.port) = ("10.0.0.1", status)
|
|
self.assertRaises(Exception, call, *data, **params)
|
|
return
|
|
|
|
# Make the call, then get the data from the root node and assert it
|
|
data = call(*data, **params)['data']
|
|
|
|
self.assertEqual(data['method'], method)
|
|
self.assertEqual(data['format'], params['format'])
|
|
self.assertEqual(data['tenant'], params['tenant'])
|
|
self.assertEqual(data['path'], path)
|
|
|
|
return data
|
|
|
|
def _test_list_networks(self, tenant=TENANT_1, format='json', status=200):
|
|
LOG.debug("_test_list_networks - tenant:%s "\
|
|
"- format:%s - START", format, tenant)
|
|
|
|
self._assert_sanity(self.client.list_networks,
|
|
status,
|
|
"GET",
|
|
"networks",
|
|
data=[],
|
|
params={'tenant': tenant, 'format': format})
|
|
|
|
LOG.debug("_test_list_networks - tenant:%s "\
|
|
"- format:%s - END", format, tenant)
|
|
|
|
def _test_show_network_details(self,
|
|
tenant=TENANT_1, format='json', status=200):
|
|
LOG.debug("_test_show_network_details - tenant:%s "\
|
|
"- format:%s - START", format, tenant)
|
|
|
|
self._assert_sanity(self.client.show_network_details,
|
|
status,
|
|
"GET",
|
|
"networks/001",
|
|
data=["001"],
|
|
params={'tenant': tenant, 'format': format})
|
|
|
|
LOG.debug("_test_show_network_details - tenant:%s "\
|
|
"- format:%s - END", format, tenant)
|
|
|
|
def _test_create_network(self, tenant=TENANT_1, format='json', status=200):
|
|
LOG.debug("_test_create_network - tenant:%s "\
|
|
"- format:%s - START", format, tenant)
|
|
|
|
self._assert_sanity(self.client.create_network,
|
|
status,
|
|
"POST",
|
|
"networks",
|
|
data=[{'network': {'net-name': 'testNetwork'}}],
|
|
params={'tenant': tenant, 'format': format})
|
|
|
|
LOG.debug("_test_create_network - tenant:%s "\
|
|
"- format:%s - END", format, tenant)
|
|
|
|
def _test_update_network(self, tenant=TENANT_1, format='json', status=200):
|
|
LOG.debug("_test_update_network - tenant:%s "\
|
|
"- format:%s - START", format, tenant)
|
|
|
|
self._assert_sanity(self.client.update_network,
|
|
status,
|
|
"PUT",
|
|
"networks/001",
|
|
data=["001",
|
|
{'network': {'net-name': 'newName'}}],
|
|
params={'tenant': tenant, 'format': format})
|
|
|
|
LOG.debug("_test_update_network - tenant:%s "\
|
|
"- format:%s - END", format, tenant)
|
|
|
|
def _test_delete_network(self, tenant=TENANT_1, format='json', status=200):
|
|
LOG.debug("_test_delete_network - tenant:%s "\
|
|
"- format:%s - START", format, tenant)
|
|
|
|
self._assert_sanity(self.client.delete_network,
|
|
status,
|
|
"DELETE",
|
|
"networks/001",
|
|
data=["001"],
|
|
params={'tenant': tenant, 'format': format})
|
|
|
|
LOG.debug("_test_delete_network - tenant:%s "\
|
|
"- format:%s - END", format, tenant)
|
|
|
|
def _test_list_ports(self, tenant=TENANT_1, format='json', status=200):
|
|
LOG.debug("_test_list_ports - tenant:%s "\
|
|
"- format:%s - START", format, tenant)
|
|
|
|
self._assert_sanity(self.client.list_ports,
|
|
status,
|
|
"GET",
|
|
"networks/001/ports",
|
|
data=["001"],
|
|
params={'tenant': tenant, 'format': format})
|
|
|
|
LOG.debug("_test_list_ports - tenant:%s "\
|
|
"- format:%s - END", format, tenant)
|
|
|
|
def _test_show_port_details(self,
|
|
tenant=TENANT_1, format='json', status=200):
|
|
LOG.debug("_test_show_port_details - tenant:%s "\
|
|
"- format:%s - START", format, tenant)
|
|
|
|
self._assert_sanity(self.client.show_port_details,
|
|
status,
|
|
"GET",
|
|
"networks/001/ports/001",
|
|
data=["001", "001"],
|
|
params={'tenant': tenant, 'format': format})
|
|
|
|
LOG.debug("_test_show_port_details - tenant:%s "\
|
|
"- format:%s - END", format, tenant)
|
|
|
|
def _test_create_port(self, tenant=TENANT_1, format='json', status=200):
|
|
LOG.debug("_test_create_port - tenant:%s "\
|
|
"- format:%s - START", format, tenant)
|
|
|
|
self._assert_sanity(self.client.create_port,
|
|
status,
|
|
"POST",
|
|
"networks/001/ports",
|
|
data=["001"],
|
|
params={'tenant': tenant, 'format': format})
|
|
|
|
LOG.debug("_test_create_port - tenant:%s "\
|
|
"- format:%s - END", format, tenant)
|
|
|
|
def _test_delete_port(self, tenant=TENANT_1, format='json', status=200):
|
|
LOG.debug("_test_delete_port - tenant:%s "\
|
|
"- format:%s - START", format, tenant)
|
|
|
|
self._assert_sanity(self.client.delete_port,
|
|
status,
|
|
"DELETE",
|
|
"networks/001/ports/001",
|
|
data=["001", "001"],
|
|
params={'tenant': tenant, 'format': format})
|
|
|
|
LOG.debug("_test_delete_port - tenant:%s "\
|
|
"- format:%s - END", format, tenant)
|
|
|
|
def _test_update_port(self, tenant=TENANT_1, format='json', status=200):
|
|
LOG.debug("_test_update_port - tenant:%s "\
|
|
"- format:%s - START", format, tenant)
|
|
|
|
self._assert_sanity(self.client.update_port,
|
|
status,
|
|
"PUT",
|
|
"networks/001/ports/001",
|
|
data=["001", "001",
|
|
{'port': {'state': 'ACTIVE'}}],
|
|
params={'tenant': tenant, 'format': format})
|
|
|
|
LOG.debug("_test_update_port - tenant:%s "\
|
|
"- format:%s - END", format, tenant)
|
|
|
|
def _test_show_port_attachment(self,
|
|
tenant=TENANT_1, format='json', status=200):
|
|
LOG.debug("_test_show_port_attachment - tenant:%s "\
|
|
"- format:%s - START", format, tenant)
|
|
|
|
self._assert_sanity(self.client.show_port_attachment,
|
|
status,
|
|
"GET",
|
|
"networks/001/ports/001/attachment",
|
|
data=["001", "001"],
|
|
params={'tenant': tenant, 'format': format})
|
|
|
|
LOG.debug("_test_show_port_attachment - tenant:%s "\
|
|
"- format:%s - END", format, tenant)
|
|
|
|
def _test_attach_resource(self, tenant=TENANT_1,
|
|
format='json', status=200):
|
|
LOG.debug("_test_attach_resource - tenant:%s "\
|
|
"- format:%s - START", format, tenant)
|
|
|
|
self._assert_sanity(self.client.attach_resource,
|
|
status,
|
|
"PUT",
|
|
"networks/001/ports/001/attachment",
|
|
data=["001", "001",
|
|
{'resource': {'id': '1234'}}],
|
|
params={'tenant': tenant, 'format': format})
|
|
|
|
LOG.debug("_test_attach_resource - tenant:%s "\
|
|
"- format:%s - END", format, tenant)
|
|
|
|
def _test_detach_resource(self, tenant=TENANT_1,
|
|
format='json', status=200):
|
|
LOG.debug("_test_detach_resource - tenant:%s "\
|
|
"- format:%s - START", format, tenant)
|
|
|
|
self._assert_sanity(self.client.detach_resource,
|
|
status,
|
|
"DELETE",
|
|
"networks/001/ports/001/attachment",
|
|
data=["001", "001"],
|
|
params={'tenant': tenant, 'format': format})
|
|
|
|
LOG.debug("_test_detach_resource - tenant:%s "\
|
|
"- format:%s - END", format, tenant)
|
|
|
|
def _test_ssl_certificates(self, tenant=TENANT_1,
|
|
format='json', status=200):
|
|
LOG.debug("_test_ssl_certificates - tenant:%s "\
|
|
"- format:%s - START", format, tenant)
|
|
|
|
# Set SSL, and our cert file
|
|
self.client.use_ssl = True
|
|
cert_file = "/fake.cert"
|
|
self.client.key_file = self.client.cert_file = cert_file
|
|
|
|
data = self._assert_sanity(self.client.list_networks,
|
|
status,
|
|
"GET",
|
|
"networks",
|
|
data=[],
|
|
params={'tenant': tenant, 'format': format})
|
|
|
|
self.assertEquals(data["key_file"], cert_file)
|
|
self.assertEquals(data["cert_file"], cert_file)
|
|
|
|
LOG.debug("_test_ssl_certificates - tenant:%s "\
|
|
"- format:%s - END", format, tenant)
|
|
|
|
def test_list_networks_json(self):
|
|
self._test_list_networks(format='json')
|
|
|
|
def test_list_networks_xml(self):
|
|
self._test_list_networks(format='xml')
|
|
|
|
def test_list_networks_alt_tenant(self):
|
|
self._test_list_networks(tenant=TENANT_2)
|
|
|
|
def test_list_networks_error_470(self):
|
|
self._test_list_networks(status=470)
|
|
|
|
def test_list_networks_error_401(self):
|
|
self._test_list_networks(status=401)
|
|
|
|
def test_show_network_details_json(self):
|
|
self._test_show_network_details(format='json')
|
|
|
|
def test_show_network_details_xml(self):
|
|
self._test_show_network_details(format='xml')
|
|
|
|
def test_show_network_details_alt_tenant(self):
|
|
self._test_show_network_details(tenant=TENANT_2)
|
|
|
|
def test_show_network_details_error_470(self):
|
|
self._test_show_network_details(status=470)
|
|
|
|
def test_show_network_details_error_401(self):
|
|
self._test_show_network_details(status=401)
|
|
|
|
def test_show_network_details_error_420(self):
|
|
self._test_show_network_details(status=420)
|
|
|
|
def test_create_network_json(self):
|
|
self._test_create_network(format='json')
|
|
|
|
def test_create_network_xml(self):
|
|
self._test_create_network(format='xml')
|
|
|
|
def test_create_network_alt_tenant(self):
|
|
self._test_create_network(tenant=TENANT_2)
|
|
|
|
def test_create_network_error_470(self):
|
|
self._test_create_network(status=470)
|
|
|
|
def test_create_network_error_401(self):
|
|
self._test_create_network(status=401)
|
|
|
|
def test_create_network_error_400(self):
|
|
self._test_create_network(status=400)
|
|
|
|
def test_create_network_error_422(self):
|
|
self._test_create_network(status=422)
|
|
|
|
def test_update_network_json(self):
|
|
self._test_update_network(format='json')
|
|
|
|
def test_update_network_xml(self):
|
|
self._test_update_network(format='xml')
|
|
|
|
def test_update_network_alt_tenant(self):
|
|
self._test_update_network(tenant=TENANT_2)
|
|
|
|
def test_update_network_error_470(self):
|
|
self._test_update_network(status=470)
|
|
|
|
def test_update_network_error_401(self):
|
|
self._test_update_network(status=401)
|
|
|
|
def test_update_network_error_400(self):
|
|
self._test_update_network(status=400)
|
|
|
|
def test_update_network_error_420(self):
|
|
self._test_update_network(status=420)
|
|
|
|
def test_update_network_error_422(self):
|
|
self._test_update_network(status=422)
|
|
|
|
def test_delete_network_json(self):
|
|
self._test_delete_network(format='json')
|
|
|
|
def test_delete_network_xml(self):
|
|
self._test_delete_network(format='xml')
|
|
|
|
def test_delete_network_alt_tenant(self):
|
|
self._test_delete_network(tenant=TENANT_2)
|
|
|
|
def test_delete_network_error_470(self):
|
|
self._test_delete_network(status=470)
|
|
|
|
def test_delete_network_error_401(self):
|
|
self._test_delete_network(status=401)
|
|
|
|
def test_delete_network_error_420(self):
|
|
self._test_delete_network(status=420)
|
|
|
|
def test_delete_network_error_421(self):
|
|
self._test_delete_network(status=421)
|
|
|
|
def test_list_ports_json(self):
|
|
self._test_list_ports(format='json')
|
|
|
|
def test_list_ports_xml(self):
|
|
self._test_list_ports(format='xml')
|
|
|
|
def test_list_ports_alt_tenant(self):
|
|
self._test_list_ports(tenant=TENANT_2)
|
|
|
|
def test_list_ports_error_470(self):
|
|
self._test_list_ports(status=470)
|
|
|
|
def test_list_ports_error_401(self):
|
|
self._test_list_ports(status=401)
|
|
|
|
def test_list_ports_error_420(self):
|
|
self._test_list_ports(status=420)
|
|
|
|
def test_show_port_details_json(self):
|
|
self._test_list_ports(format='json')
|
|
|
|
def test_show_port_details_xml(self):
|
|
self._test_list_ports(format='xml')
|
|
|
|
def test_show_port_details_alt_tenant(self):
|
|
self._test_list_ports(tenant=TENANT_2)
|
|
|
|
def test_show_port_details_error_470(self):
|
|
self._test_show_port_details(status=470)
|
|
|
|
def test_show_port_details_error_401(self):
|
|
self._test_show_port_details(status=401)
|
|
|
|
def test_show_port_details_error_420(self):
|
|
self._test_show_port_details(status=420)
|
|
|
|
def test_show_port_details_error_430(self):
|
|
self._test_show_port_details(status=430)
|
|
|
|
def test_create_port_json(self):
|
|
self._test_create_port(format='json')
|
|
|
|
def test_create_port_xml(self):
|
|
self._test_create_port(format='xml')
|
|
|
|
def test_create_port_alt_tenant(self):
|
|
self._test_create_port(tenant=TENANT_2)
|
|
|
|
def test_create_port_error_470(self):
|
|
self._test_create_port(status=470)
|
|
|
|
def test_create_port_error_401(self):
|
|
self._test_create_port(status=401)
|
|
|
|
def test_create_port_error_400(self):
|
|
self._test_create_port(status=400)
|
|
|
|
def test_create_port_error_420(self):
|
|
self._test_create_port(status=420)
|
|
|
|
def test_create_port_error_430(self):
|
|
self._test_create_port(status=430)
|
|
|
|
def test_create_port_error_431(self):
|
|
self._test_create_port(status=431)
|
|
|
|
def test_delete_port_json(self):
|
|
self._test_delete_port(format='json')
|
|
|
|
def test_delete_port_xml(self):
|
|
self._test_delete_port(format='xml')
|
|
|
|
def test_delete_port_alt_tenant(self):
|
|
self._test_delete_port(tenant=TENANT_2)
|
|
|
|
def test_delete_port_error_470(self):
|
|
self._test_delete_port(status=470)
|
|
|
|
def test_delete_port_error_401(self):
|
|
self._test_delete_port(status=401)
|
|
|
|
def test_delete_port_error_420(self):
|
|
self._test_delete_port(status=420)
|
|
|
|
def test_delete_port_error_430(self):
|
|
self._test_delete_port(status=430)
|
|
|
|
def test_delete_port_error_432(self):
|
|
self._test_delete_port(status=432)
|
|
|
|
def test_update_port_json(self):
|
|
self._test_update_port(format='json')
|
|
|
|
def test_update_port_xml(self):
|
|
self._test_update_port(format='xml')
|
|
|
|
def test_update_port_alt_tenant(self):
|
|
self._test_update_port(tenant=TENANT_2)
|
|
|
|
def test_update_port_error_470(self):
|
|
self._test_update_port(status=470)
|
|
|
|
def test_update_port_error_401(self):
|
|
self._test_update_port(status=401)
|
|
|
|
def test_update_port_error_400(self):
|
|
self._test_update_port(status=400)
|
|
|
|
def test_update_port_error_420(self):
|
|
self._test_update_port(status=420)
|
|
|
|
def test_update_port_error_430(self):
|
|
self._test_update_port(status=430)
|
|
|
|
def test_update_port_error_431(self):
|
|
self._test_update_port(status=431)
|
|
|
|
def test_show_port_attachment_json(self):
|
|
self._test_show_port_attachment(format='json')
|
|
|
|
def test_show_port_attachment_xml(self):
|
|
self._test_show_port_attachment(format='xml')
|
|
|
|
def test_show_port_attachment_alt_tenant(self):
|
|
self._test_show_port_attachment(tenant=TENANT_2)
|
|
|
|
def test_show_port_attachment_error_470(self):
|
|
self._test_show_port_attachment(status=470)
|
|
|
|
def test_show_port_attachment_error_401(self):
|
|
self._test_show_port_attachment(status=401)
|
|
|
|
def test_show_port_attachment_error_400(self):
|
|
self._test_show_port_attachment(status=400)
|
|
|
|
def test_show_port_attachment_error_420(self):
|
|
self._test_show_port_attachment(status=420)
|
|
|
|
def test_show_port_attachment_error_430(self):
|
|
self._test_show_port_attachment(status=430)
|
|
|
|
def test_attach_resource_json(self):
|
|
self._test_attach_resource(format='json')
|
|
|
|
def test_attach_resource_xml(self):
|
|
self._test_attach_resource(format='xml')
|
|
|
|
def test_attach_resource_alt_tenant(self):
|
|
self._test_attach_resource(tenant=TENANT_2)
|
|
|
|
def test_attach_resource_error_470(self):
|
|
self._test_attach_resource(status=470)
|
|
|
|
def test_attach_resource_error_401(self):
|
|
self._test_attach_resource(status=401)
|
|
|
|
def test_attach_resource_error_400(self):
|
|
self._test_attach_resource(status=400)
|
|
|
|
def test_attach_resource_error_420(self):
|
|
self._test_attach_resource(status=420)
|
|
|
|
def test_attach_resource_error_430(self):
|
|
self._test_attach_resource(status=430)
|
|
|
|
def test_attach_resource_error_432(self):
|
|
self._test_attach_resource(status=432)
|
|
|
|
def test_attach_resource_error_440(self):
|
|
self._test_attach_resource(status=440)
|
|
|
|
def test_detach_resource_json(self):
|
|
self._test_detach_resource(format='json')
|
|
|
|
def test_detach_resource_xml(self):
|
|
self._test_detach_resource(format='xml')
|
|
|
|
def test_detach_resource_alt_tenant(self):
|
|
self._test_detach_resource(tenant=TENANT_2)
|
|
|
|
def test_detach_resource_error_470(self):
|
|
self._test_detach_resource(status=470)
|
|
|
|
def test_detach_resource_error_401(self):
|
|
self._test_detach_resource(status=401)
|
|
|
|
def test_detach_resource_error_420(self):
|
|
self._test_detach_resource(status=420)
|
|
|
|
def test_detach_resource_error_430(self):
|
|
self._test_detach_resource(status=430)
|
|
|
|
def test_ssl_certificates(self):
|
|
self._test_ssl_certificates()
|