def test_not_match_version_string(self):
version_negotiation = vn.VersionNegotiationFilter(
self._version_controller_factory, None, None)
request = webob.Request({})
match = version_negotiation._match_version_string("invalid", request)
self.assertFalse(match)
def test_request_path_is_empty(self, mock_vc):
vnf = vn.VersionNegotiationFilter(None, None)
request = webob.Request({'PATH_INFO': '/'})
response = vnf.process_request(request)
self.assertIs(mock_vc.return_value, response)
def test_return_version_controller_when_request_path_is_empty(self):
version_negotiation = vn.VersionNegotiationFilter(
self._version_controller_factory, None, None)
request = webob.Request({'PATH_INFO': '/'})
response = version_negotiation.process_request(request)
self.assertIsInstance(response, VersionController)
def test_request_path_contains_unknown_version(self):
version_negotiation = vn.VersionNegotiationFilter(
self._version_controller_factory, None, None)
request = webob.Request({'PATH_INFO': 'v2.0/resource'})
response = version_negotiation.process_request(request)
self.assertIsInstance(response, VersionController)
def test_removes_version_from_request_path(self):
version_negotiation = vn.VersionNegotiationFilter(
self._version_controller_factory, None, None)
expected_path = 'resource'
request = webob.Request({'PATH_INFO': 'v1.0/%s' % expected_path})
response = version_negotiation.process_request(request)
self.assertIsNone(response)
self.assertEqual(expected_path, request.path_info_peek())
def test_check_version_request_latest(self):
request = webob.Request({'PATH_INFO': 'resource'})
request.headers[wsgi.API_VERSION_KEY] = 'cluster Latest'
version_negotiation = vn.VersionNegotiationFilter(
self._version_controller_factory, None, None)
version_negotiation.check_version_request(request)
self.assertIsNotNone(request.version_request)
expected = os_ver.max_api_version()
self.assertEqual(expected, request.version_request)
def test_check_version_request_default(self):
request = webob.Request({'PATH_INFO': 'resource'})
request.headers[wsgi.API_VERSION_KEY] = 'compute 2.0'
version_negotiation = vn.VersionNegotiationFilter(
self._version_controller_factory, None, None)
version_negotiation.check_version_request(request)
self.assertIsNotNone(request.version_request)
expected = vr.APIVersionRequest(wsgi.DEFAULT_API_VERSION)
self.assertEqual(expected, request.version_request)
def test_removes_version_from_request_path(self, mock_vc):
vnf = vn.VersionNegotiationFilter(None, None)
self.patchobject(vnf, '_check_version_request')
expected_path = 'resource'
request = webob.Request({'PATH_INFO': 'v1.0/%s' % expected_path})
response = vnf.process_request(request)
self.assertIsNone(response)
self.assertEqual(expected_path, request.path_info_peek())
def test__get_controller_not_match_version(self, mock_vc):
gvc = mock_vc.return_value
gvc.get_controller = mock.Mock(return_value=None)
vnf = vn.VersionNegotiationFilter(None, None)
request = webob.Request({})
res = vnf._get_controller("invalid", request)
self.assertIsNone(res)
self.assertEqual(0, gvc.get_controller.call_count)
def test_no_URI_version_accept_header_contains_invalid_MIME_type(self):
version_negotiation = vn.VersionNegotiationFilter(
self._version_controller_factory, None, None)
request = webob.Request({'PATH_INFO': 'resource'})
request.headers['Accept'] = 'application/invalidMIMEType'
response = version_negotiation.process_request(request)
self.assertIsInstance(response, webob.exc.HTTPNotFound)
request.headers['Accept'] = ''
response = version_negotiation.process_request(request)
self.assertIsInstance(response, webob.exc.HTTPNotFound)
def test__check_version_request_invalid_format(self, mock_vc):
controller = mock.Mock()
request = webob.Request({'PATH_INFO': 'resource'})
request.headers[wsgi.API_VERSION_KEY] = 'clustering 2.03'
vnf = vn.VersionNegotiationFilter(None, None)
ex = self.assertRaises(webob.exc.HTTPBadRequest,
vnf._check_version_request, request, controller)
self.assertEqual(
"API Version String '2.03' is of invalid format. It "
"must be of format 'major.minor'.", six.text_type(ex))
def test_full_version_on_request_path(self, mock_vc):
vnf = vn.VersionNegotiationFilter(None, None)
self.patchobject(vnf, '_check_version_request')
fake_vc = mock.Mock(return_value={'foo': 'bar'})
self.patchobject(vnf.versions_app,
'get_controller',
return_value=fake_vc)
request = webob.Request({'PATH_INFO': 'v1.0'})
response = vnf.process_request(request)
self.assertEqual({'foo': 'bar'}, response)
def test_check_version_request_invalid_format(self):
request = webob.Request({'PATH_INFO': 'resource'})
request.headers[wsgi.API_VERSION_KEY] = 'cluster 2.03'
version_negotiation = vn.VersionNegotiationFilter(
self._version_controller_factory, None, None)
ex = self.assertRaises(webob.exc.HTTPBadRequest,
version_negotiation.check_version_request,
request)
self.assertEqual("API Version String (2.03) is of invalid format. It "
"must be of format 'major.minor'.",
six.text_type(ex))
def test_match_version_string(self):
version_negotiation = vn.VersionNegotiationFilter(
self._version_controller_factory, None, None)
request = webob.Request({})
major_version = 1
minor_version = 0
match = version_negotiation._match_version_string(
'v{0}.{1}'.format(major_version, minor_version), request)
self.assertTrue(match)
self.assertEqual(major_version, request.environ['api.major_version'])
self.assertEqual(minor_version, request.environ['api.minor_version'])
def test_request_path_contains_unknown_version(self, mock_vc):
vnf = vn.VersionNegotiationFilter(None, None)
gvc = mock_vc.return_value
gvc.get_controller = mock.Mock(return_value=None)
self.patchobject(vnf, '_check_version_request')
request = webob.Request({'PATH_INFO': 'v2.0/resource'})
request.headers['Accept'] = '*/*'
response = vnf.process_request(request)
self.assertIs(mock_vc.return_value, response)
def test__check_version_request_default(self, mock_vc):
controller = mock.Mock()
controller.DEFAULT_API_VERSION = "1.0"
request = webob.Request({'PATH_INFO': 'resource'})
request.headers[wsgi.API_VERSION_KEY] = 'compute 2.0'
vnf = vn.VersionNegotiationFilter(None, None)
vnf._check_version_request(request, controller)
self.assertIsNotNone(request.version_request)
expected = vr.APIVersionRequest(controller.DEFAULT_API_VERSION)
self.assertEqual(expected, request.version_request)
def test_accept_header_contains_unknown_version(self):
version_negotiation = vn.VersionNegotiationFilter(
self._version_controller_factory, None, None)
request = webob.Request({'PATH_INFO': 'resource'})
request.headers['Accept'] = 'application/vnd.openstack.clustering-v2.0'
response = version_negotiation.process_request(request)
self.assertIsInstance(response, VersionController)
request.headers['Accept'] = 'application/vnd.openstack.clustering-vab'
response = version_negotiation.process_request(request)
self.assertIsNone(response)
def test_accept_header_contains_valid_version(self):
version_negotiation = vn.VersionNegotiationFilter(
self._version_controller_factory, None, None)
major_version = 1
minor_version = 0
request = webob.Request({'PATH_INFO': 'resource'})
request.headers['Accept'] = 'application/vnd.openstack.clustering-v1.0'
response = version_negotiation.process_request(request)
self.assertIsNone(response)
self.assertEqual(major_version, request.environ['api.major_version'])
self.assertEqual(minor_version, request.environ['api.minor_version'])
def test_request_path_contains_valid_version(self):
version_negotiation = vn.VersionNegotiationFilter(
self._version_controller_factory, None, None)
major = 1
minor = 0
request = webob.Request({'PATH_INFO':
'v{0}.{1}/resource'.format(major, minor)})
response = version_negotiation.process_request(request)
self.assertIsNone(response)
self.assertEqual(major, request.environ['api.major'])
self.assertEqual(minor, request.environ['api.minor'])
def test__check_version_request_latest(self, mock_vc):
controller = mock.Mock()
controller.max_api_version = mock.Mock(return_value='12.34')
request = webob.Request({'PATH_INFO': 'resource'})
request.headers[wsgi.API_VERSION_KEY] = 'clustering Latest'
vnf = vn.VersionNegotiationFilter(None, None)
vnf._check_version_request(request, controller)
self.assertIsNotNone(request.version_request)
expected = '12.34'
self.assertEqual(expected, request.version_request)
def test_accept_header_contains_valid_version(self, mock_vc):
vnf = vn.VersionNegotiationFilter(None, None)
self.patchobject(vnf, '_check_version_request')
major = 1
minor = 0
request = webob.Request({'PATH_INFO': 'resource'})
request.headers['Accept'] = 'application/vnd.openstack.clustering-v1.0'
response = vnf.process_request(request)
self.assertIsNone(response)
self.assertEqual(major, request.environ['api.major'])
self.assertEqual(minor, request.environ['api.minor'])
def test__get_version_controller_shorter_version(self, mock_vc):
gvc = mock_vc.return_value
xvc = mock.Mock()
gvc.get_controller = mock.Mock(return_value=xvc)
vnf = vn.VersionNegotiationFilter(None, None)
request = webob.Request({})
res = vnf._get_controller('v1', request)
self.assertEqual(xvc, res)
self.assertEqual(1, request.environ['api.major'])
self.assertEqual(0, request.environ['api.minor'])
gvc.get_controller.assert_called_once_with('1.0')
def test_accept_header_contains_unknown_version(self, mock_vc):
vnf = vn.VersionNegotiationFilter(None, None)
self.patchobject(vnf, '_check_version_request')
request = webob.Request({'PATH_INFO': 'resource'})
request.headers['Accept'] = 'application/vnd.openstack.clustering-v2.0'
response = vnf.process_request(request)
self.assertIsNone(response)
request.headers['Accept'] = 'application/vnd.openstack.clustering-vab'
response = vnf.process_request(request)
self.assertIsInstance(response, webob.exc.HTTPNotFound)
def test_check_version_request_invalid_version(self):
request = webob.Request({'PATH_INFO': 'resource'})
request.headers[wsgi.API_VERSION_KEY] = 'cluster 2.3'
version_negotiation = vn.VersionNegotiationFilter(
self._version_controller_factory, None, None)
ex = self.assertRaises(exception.InvalidGlobalAPIVersion,
version_negotiation.check_version_request,
request)
expected = ("Version 2.3 is not supported by the API. Minimum is "
"%(min_ver)s and maximum is %(max_ver)s." %
{'min_ver': str(os_ver.min_api_version()),
'max_ver': str(os_ver.max_api_version())})
self.assertEqual(expected, six.text_type(ex))
def test__check_version_request(self, mock_vc):
controller = mock.Mock()
minv = vr.APIVersionRequest('1.0')
maxv = vr.APIVersionRequest('1.3')
controller.min_api_version = mock.Mock(return_value=minv)
controller.max_api_version = mock.Mock(return_value=maxv)
request = webob.Request({'PATH_INFO': 'resource'})
request.headers[wsgi.API_VERSION_KEY] = 'clustering 1.0,compute 2.0'
vnf = vn.VersionNegotiationFilter(None, None)
vnf._check_version_request(request, controller)
self.assertIsNotNone(request.version_request)
expected = vr.APIVersionRequest('1.0')
self.assertEqual(expected, request.version_request)
def test_no_URI_version_accept_with_invalid_MIME_type(self, mock_vc):
vnf = vn.VersionNegotiationFilter(None, None)
gvc = mock_vc.return_value
gvc.get_controller = mock.Mock(side_effect=[None, None])
self.patchobject(vnf, '_check_version_request')
request = webob.Request({'PATH_INFO': 'resource'})
request.headers['Accept'] = 'application/invalidMIMEType'
response = vnf.process_request(request)
self.assertIsInstance(response, webob.exc.HTTPNotFound)
request.headers['Accept'] = ''
response = vnf.process_request(request)
self.assertEqual(gvc, response)
def test_request_path_contains_valid_version(self, mock_vc):
vnf = vn.VersionNegotiationFilter(None, None)
gvc = mock_vc.return_value
x_controller = mock.Mock()
gvc.get_controller = mock.Mock(return_value=x_controller)
mock_check = self.patchobject(vnf, '_check_version_request')
major = 1
minor = 0
request = webob.Request({'PATH_INFO': 'v1.0/resource'})
response = vnf.process_request(request)
self.assertIsNone(response)
self.assertEqual(major, request.environ['api.major'])
self.assertEqual(minor, request.environ['api.minor'])
gvc.get_controller.assert_called_once_with('1.0')
mock_check.assert_called_once_with(request, x_controller)
def test_accept_header_contains_simple_version(self, mock_vc):
vnf = vn.VersionNegotiationFilter(None, None)
self.patchobject(vnf, '_check_version_request')
fake_vc = mock.Mock(return_value={'foo': 'bar'})
self.patchobject(vnf.versions_app,
'get_controller',
return_value=fake_vc)
major = 1
minor = 0
request = webob.Request({'PATH_INFO': ''})
request.headers['Accept'] = 'application/vnd.openstack.clustering-v1.0'
response = vnf.process_request(request)
self.assertEqual(major, request.environ['api.major'])
self.assertEqual(minor, request.environ['api.minor'])
self.assertEqual({'foo': 'bar'}, response)
def test__check_version_request_invalid_version(self, mock_vc):
controller = mock.Mock()
minv = vr.APIVersionRequest('1.0')
maxv = vr.APIVersionRequest('1.100')
controller.min_api_version = mock.Mock(return_value=minv)
controller.max_api_version = mock.Mock(return_value=maxv)
request = webob.Request({'PATH_INFO': 'resource'})
request.headers[wsgi.API_VERSION_KEY] = 'clustering 2.3'
vnf = vn.VersionNegotiationFilter(None, None)
ex = self.assertRaises(exception.InvalidGlobalAPIVersion,
vnf._check_version_request, request, controller)
expected = ("Version '2.3' is not supported by the API. Minimum is "
"'%(min_ver)s' and maximum is '%(max_ver)s'." % {
'min_ver': str(minv),
'max_ver': str(maxv)
})
self.assertEqual(expected, six.text_type(ex))
def version_filter(app, conf, **local_conf):
return vn.VersionNegotiationFilter(app, conf)
