def test_version_zero_can_match(self):
"""If a version is '0.0' we want to it be able to match."""
version = microversion_parse.Version(0, 0)
min_version = microversion_parse.Version(0, 0)
max_version = microversion_parse.Version(0, 0)
version.min_version = min_version
version.max_version = max_version
self.assertTrue(version.matches())
def setUp(self):
super(TestEnsureConsumer, self).setUp()
self.conf = cfg.ConfigOpts()
self.useFixture(config_fixture.Config(self.conf))
conf.register_opts(self.conf)
self.mock_project_get = self.useFixture(fixtures.MockPatch(
'placement.objects.project.'
'Project.get_by_external_id')).mock
self.mock_user_get = self.useFixture(fixtures.MockPatch(
'placement.objects.user.'
'User.get_by_external_id')).mock
self.mock_consumer_get = self.useFixture(fixtures.MockPatch(
'placement.objects.consumer.'
'Consumer.get_by_uuid')).mock
self.mock_project_create = self.useFixture(fixtures.MockPatch(
'placement.objects.project.'
'Project.create')).mock
self.mock_user_create = self.useFixture(fixtures.MockPatch(
'placement.objects.user.'
'User.create')).mock
self.mock_consumer_create = self.useFixture(fixtures.MockPatch(
'placement.objects.consumer.'
'Consumer.create')).mock
self.mock_consumer_update = self.useFixture(fixtures.MockPatch(
'placement.objects.consumer.'
'Consumer.update')).mock
self.ctx = context.RequestContext(user_id='fake', project_id='fake')
self.ctx.config = self.conf
self.consumer_id = uuidsentinel.consumer
self.project_id = uuidsentinel.project
self.user_id = uuidsentinel.user
mv_parsed = microversion_parse.Version(1, 27)
mv_parsed.max_version = microversion_parse.parse_version_string(
microversion.max_version_string())
mv_parsed.min_version = microversion_parse.parse_version_string(
microversion.min_version_string())
self.before_version = mv_parsed
mv_parsed = microversion_parse.Version(1, 28)
mv_parsed.max_version = microversion_parse.parse_version_string(
microversion.max_version_string())
mv_parsed.min_version = microversion_parse.parse_version_string(
microversion.min_version_string())
self.after_version = mv_parsed
mv_parsed = microversion_parse.Version(1, 38)
mv_parsed.max_version = microversion_parse.parse_version_string(
microversion.max_version_string())
mv_parsed.min_version = microversion_parse.parse_version_string(
microversion.min_version_string())
self.cons_type_req_version = mv_parsed
def test_version_zero_no_defaults(self):
"""Any version, even 0.0, should never match without a min
and max being set.
"""
version = microversion_parse.Version(0, 0)
self.assertFalse(version.matches())
class SchemaValidationTestCasesV1(SchemaValidationMixin):
MIN_SCHEMA_VERSION = microversion_parse.Version(1, 0)
MAX_SCHEMA_VERSION = microversion_parse.Version(1, 0)
@ddt.unpack
@ddt.file_data('provider_config_data/v1/validation_error_test_data.yaml')
def test_validation_errors(self, config, expected_messages):
self.run_test_validation_errors(config, expected_messages)
@ddt.unpack
@ddt.file_data('provider_config_data/v1/validation_success_test_data.yaml')
def test_validation_success(self, config):
self.run_test_validation_success(config)
def test_schema_version_matching(self):
self.run_schema_version_matching(self.MIN_SCHEMA_VERSION,
self.MAX_SCHEMA_VERSION)
def test_methods_structure(self):
"""Test that VERSIONED_METHODS gets data as expected."""
self.assertEqual(0, len(microversion.VERSIONED_METHODS))
fully_qualified_method = microversion._fully_qualified_name(handler)
microversion.version_handler('1.1', '1.10')(handler)
microversion.version_handler('2.0')(handler)
methods_data = microversion.VERSIONED_METHODS[fully_qualified_method]
stored_method_data = methods_data[-1]
self.assertEqual(2, len(methods_data))
self.assertEqual(microversion_parse.Version(1, 1),
stored_method_data[0])
self.assertEqual(microversion_parse.Version(1, 10),
stored_method_data[1])
self.assertEqual(handler, stored_method_data[2])
self.assertEqual(microversion_parse.Version(2, 0), methods_data[0][0])
def run_schema_version_matching(self, min_schema_version,
max_schema_version):
# note _load_yaml_file is mocked so the value is not important
# however it may appear in logs messages so changing it could
# result in tests failing unless the expected_messages field
# is updated in the test data.
path = 'test_path'
# test exactly min and max versions are supported
self.set_config(
config={'meta': {
'schema_version': str(min_schema_version)
}})
provider_config._parse_provider_yaml(path)
self.set_config(
config={'meta': {
'schema_version': str(max_schema_version)
}})
provider_config._parse_provider_yaml(path)
self.mock_LOG.warning.assert_not_called()
# test max major+1 raises
higher_major = microversion_parse.Version(
major=max_schema_version.major + 1, minor=max_schema_version.minor)
self.set_config(config={'meta': {'schema_version': str(higher_major)}})
self.assertRaises(nova_exc.ProviderConfigException,
provider_config._parse_provider_yaml, path)
# test max major with max minor+1 is logged
higher_minor = microversion_parse.Version(
major=max_schema_version.major, minor=max_schema_version.minor + 1)
expected_log_call = (
"Provider config file [%(path)s] is at schema version "
"%(schema_version)s. Nova supports the major version, but "
"not the minor. Some fields may be ignored." % {
"path": path,
"schema_version": higher_minor
})
self.set_config(config={'meta': {'schema_version': str(higher_minor)}})
provider_config._parse_provider_yaml(path)
self.mock_LOG.warning.assert_called_once_with(expected_log_call)
def _get_req(qstring, version):
req = webob.Request.blank('?' + qstring, )
mv_parsed = microversion_parse.Version(*version)
mv_parsed.max_version = microversion_parse.parse_version_string(
microversion.max_version_string())
mv_parsed.min_version = microversion_parse.parse_version_string(
microversion.min_version_string())
req.environ[placement.microversion.MICROVERSION_ENVIRON] = mv_parsed
return req
def _environ(path='/moo', method='GET'):
return {
'PATH_INFO': path,
'REQUEST_METHOD': method,
'SERVER_NAME': 'example.com',
'SERVER_PORT': '80',
'wsgi.url_scheme': 'http',
# The microversion version value is not used, but it
# needs to be set to avoid a KeyError.
microversion.MICROVERSION_ENVIRON: microversion_parse.Version(1, 12),
}
def do_parse(qstring, version=(1, 18)):
"""Converts a querystring to a MultiDict, mimicking request.GET, and
runs parse_qs_request_groups on it.
"""
req = webob.Request.blank('?' + qstring)
mv_parsed = microversion_parse.Version(*version)
mv_parsed.max_version = microversion_parse.parse_version_string(
microversion.max_version_string())
mv_parsed.min_version = microversion_parse.parse_version_string(
microversion.min_version_string())
req.environ['placement.microversion'] = mv_parsed
return util.parse_qs_request_groups(req)
def do_parse(qstring, version=(1, 18)):
"""Converts a querystring to a MultiDict, mimicking request.GET, and
runs dict_from_request on it.
"""
req = webob.Request.blank('?' + qstring)
mv_parsed = microversion_parse.Version(*version)
mv_parsed.max_version = microversion_parse.parse_version_string(
microversion.max_version_string())
mv_parsed.min_version = microversion_parse.parse_version_string(
microversion.min_version_string())
req.environ['placement.microversion'] = mv_parsed
d = pl.RequestGroup.dict_from_request(req)
# Sort for easier testing
return [d[suff] for suff in sorted(d)]
def setUp(self):
super(TestEnsureConsumer, self).setUp()
self.mock_project_get = self.useFixture(fixtures.MockPatch(
'placement.objects.project.'
'Project.get_by_external_id')).mock
self.mock_user_get = self.useFixture(fixtures.MockPatch(
'placement.objects.user.'
'User.get_by_external_id')).mock
self.mock_consumer_get = self.useFixture(fixtures.MockPatch(
'placement.objects.consumer.'
'Consumer.get_by_uuid')).mock
self.mock_project_create = self.useFixture(fixtures.MockPatch(
'placement.objects.project.'
'Project.create')).mock
self.mock_user_create = self.useFixture(fixtures.MockPatch(
'placement.objects.user.'
'User.create')).mock
self.mock_consumer_create = self.useFixture(fixtures.MockPatch(
'placement.objects.consumer.'
'Consumer.create')).mock
self.ctx = mock.sentinel.ctx
self.consumer_id = uuidsentinel.consumer
self.project_id = uuidsentinel.project
self.user_id = uuidsentinel.user
mv_parsed = microversion_parse.Version(1, 27)
mv_parsed.max_version = microversion_parse.parse_version_string(
microversion.max_version_string())
mv_parsed.min_version = microversion_parse.parse_version_string(
microversion.min_version_string())
self.before_version = mv_parsed
mv_parsed = microversion_parse.Version(1, 28)
mv_parsed.max_version = microversion_parse.parse_version_string(
microversion.max_version_string())
mv_parsed.min_version = microversion_parse.parse_version_string(
microversion.min_version_string())
self.after_version = mv_parsed
def test_adapt_whitespace(self):
version = microversion_parse.parse_version_string(' 1.1 ')
self.assertEqual((1, 1), version)
self.assertEqual(microversion_parse.Version(1, 1), version)
def test_good_version(self):
version = microversion_parse.parse_version_string('1.1')
self.assertEqual((1, 1), version)
self.assertEqual(microversion_parse.Version(1, 1), version)
def test_version_matches_inclusive(self):
max_version = microversion_parse.Version(1, 5)
min_version = microversion_parse.Version(1, 5)
self.assertTrue(self.version.matches(min_version, max_version))
def test_version_matches(self):
max_version = microversion_parse.Version(1, 20)
min_version = microversion_parse.Version(1, 3)
self.assertTrue(self.version.matches(min_version, max_version))
self.assertFalse(self.version.matches(max_version, min_version))
def setUp(self):
super(TestVersion, self).setUp()
self.version = microversion_parse.Version(1, 5)
