def setUp(self): super(ProfileTypeTest, self).setUp() self.ctx = utils.dummy_context(project='profile_type_test_project') self.eng = service.EngineService('host-a', 'topic-a') self.eng.init_tgm() environment.global_env().register_profile('TestProfile', fakes.TestProfile)
def setUp(self): super(TriggerTest, self).setUp() self.ctx = utils.dummy_context(project='trigger_test_project') self.eng = service.EngineService('host-a', 'topic-a') self.eng.init_tgm() environment.global_env().register_trigger('TestTrigger', fakes.TestTrigger)
def setUp(self): super(PolicyTypeTest, self).setUp() self.ctx = utils.dummy_context(project='policy_type_test_project') self.eng = service.EngineService('host-a', 'topic-a') self.eng.init_tgm() environment.global_env().register_policy('TestPolicy', fakes.TestPolicy)
def setUp(self): super(PolicyTypeTest, self).setUp() self.ctx = utils.dummy_context(tenant_id='policy_type_test_tenant') self.eng = service.EngineService('host-a', 'topic-a') self.eng.init_tgm() environment.global_env().register_policy('TestPolicy', fakes.TestPolicy)
def setUp(self): super(TestPolicyBase, self).setUp() self.ctx = utils.dummy_context() environment.global_env().register_policy('senlin.policy.dummy-1.0', DummyPolicy) environment.global_env().register_policy('senlin.policy.dummy-1.1', DummyPolicy) self.spec = parser.simple_parse(sample_policy)
def setUp(self): super(PolicyTest, self).setUp() self.ctx = utils.dummy_context(project='policy_test_project') self.eng = service.EngineService('host-a', 'topic-a') self.eng.init_tgm() environment.global_env().register_policy('TestPolicy', fakes.TestPolicy) self.spec = { 'type': 'TestPolicy', 'version': '1.0', 'properties': { 'KEY1': 'value1', 'KEY2': 2, } }
def _setup_fakes(self): """Set up fake policy for the purpose of testing. This method is provided in a standalone function because not all test cases need such a set up. """ environment.global_env().register_policy('TestPolicy-1.0', fakes.TestPolicy) self.spec = { 'type': 'TestPolicy', 'version': '1.0', 'properties': { 'KEY2': 6 } }
def test_node_create_profile_type_not_match(self, notify): env = environment.global_env() env.register_profile('SecondProfile', fakes.TestProfile) new_spec = { 'type': 'SecondProfile', 'version': '1.0', 'properties': { 'INT': 20, 'STR': 'string' } } cluster_profile = self.eng.profile_create(self.ctx, 'cp', new_spec) cluster = self.eng.cluster_create(self.ctx, 'c-1', 0, cluster_profile['id']) ex = self.assertRaises(rpc.ExpectedException, self.eng.node_create, self.ctx, 'n-1', self.profile['id'], cluster_id=cluster['id']) self.assertEqual(exception.ProfileTypeNotMatch, ex.exc_info[0]) self.assertEqual( "Node and cluster have different profile type, " "operation aborted.", six.text_type(ex.exc_info[1]))
def test_node_join_profile_type_not_match(self, notify): # prepare a cluster with different profile type env = environment.global_env() env.register_profile('OtherProfileType', fakes.TestProfile) other_spec = { 'type': 'OtherProfileType', 'version': '1.0', 'properties': { 'INT': 20, 'STR': 'okay', } } other_profile = self.eng.profile_create(self.ctx, 'new-profile', other_spec) c = self.eng.cluster_create(self.ctx, 'c-1', 0, other_profile['id']) cluster_id = c['id'] node = self.eng.node_create(self.ctx, 'node1', self.profile['id']) node_id = node['id'] ex = self.assertRaises(rpc.ExpectedException, self.eng.node_join, self.ctx, node_id, cluster_id) self.assertEqual(exception.ProfileTypeNotMatch, ex.exc_info[0]) self.assertEqual( 'Node and cluster have different profile type, ' 'operation aborted.', six.text_type(ex.exc_info[1]))
def test_node_join_profile_type_not_match(self, notify): # prepare a cluster with different profile type env = environment.global_env() env.register_profile('OtherProfileType', fakes.TestProfile) other_spec = { 'type': 'OtherProfileType', 'version': '1.0', 'properties': { 'INT': 20, 'STR': 'okay', } } other_profile = self.eng.profile_create(self.ctx, 'new-profile', other_spec) c = self.eng.cluster_create(self.ctx, 'c-1', 0, other_profile['id']) cluster_id = c['id'] node = self.eng.node_create(self.ctx, 'node1', self.profile['id']) node_id = node['id'] ex = self.assertRaises(rpc.ExpectedException, self.eng.node_join, self.ctx, node_id, cluster_id) self.assertEqual(exception.ProfileTypeNotMatch, ex.exc_info[0]) self.assertEqual('Node and cluster have different profile type, ' 'operation aborted.', six.text_type(ex.exc_info[1]))
def test_create_default(self): ge = environment.global_env() e = environment.Environment() reg_prof = e.profile_registry reg_plcy = e.policy_registry reg_trig = e.trigger_registry reg_driv = e.driver_registry self.assertEqual({}, e.params) self.assertEqual('profiles', reg_prof.registry_name) self.assertEqual('policies', reg_plcy.registry_name) self.assertEqual('triggers', reg_trig.registry_name) self.assertEqual('drivers', reg_driv.registry_name) self.assertFalse(reg_prof.is_global) self.assertFalse(reg_plcy.is_global) self.assertFalse(reg_trig.is_global) self.assertFalse(reg_driv.is_global) self.assertEqual('profiles', ge.profile_registry.registry_name) self.assertEqual('policies', ge.policy_registry.registry_name) self.assertEqual('triggers', ge.trigger_registry.registry_name) self.assertEqual('drivers', ge.driver_registry.registry_name) self.assertEqual(ge.profile_registry, reg_prof.global_registry) self.assertEqual(ge.policy_registry, reg_plcy.global_registry) self.assertEqual(ge.trigger_registry, reg_trig.global_registry) self.assertEqual(ge.driver_registry, reg_driv.global_registry)
def test_create_default(self): ge = environment.global_env() e = environment.Environment() reg_prof = e.profile_registry reg_plcy = e.policy_registry reg_trig = e.trigger_registry reg_driv = e.driver_registry self.assertEqual({}, e.params) self.assertEqual("profiles", reg_prof.registry_name) self.assertEqual("policies", reg_plcy.registry_name) self.assertEqual("triggers", reg_trig.registry_name) self.assertEqual("drivers", reg_driv.registry_name) self.assertFalse(reg_prof.is_global) self.assertFalse(reg_plcy.is_global) self.assertFalse(reg_trig.is_global) self.assertFalse(reg_driv.is_global) self.assertEqual("profiles", ge.profile_registry.registry_name) self.assertEqual("policies", ge.policy_registry.registry_name) self.assertEqual("triggers", ge.trigger_registry.registry_name) self.assertEqual("drivers", ge.driver_registry.registry_name) self.assertEqual(ge.profile_registry, reg_prof.global_registry) self.assertEqual(ge.policy_registry, reg_plcy.global_registry) self.assertEqual(ge.trigger_registry, reg_trig.global_registry) self.assertEqual(ge.driver_registry, reg_driv.global_registry)
def test_cluster_add_nodes_node_profile_type_not_match(self, notify): c = self.eng.cluster_create(self.ctx, 'c-1', 0, self.profile['id']) # Register a different profile env = environment.global_env() env.register_profile('DiffProfileType', fakes.TestProfile) new_spec = { 'type': 'DiffProfileType', 'version': '1.0', 'properties': { 'INT': 10, 'STR': 'string' }, } new_profile = self.eng.profile_create(self.ctx, 'p-test', new_spec, permission='1111') nodes = self._prepare_nodes(self.ctx, count=1, profile_id=new_profile['id']) ex = self.assertRaises(rpc.ExpectedException, self.eng.cluster_add_nodes, self.ctx, c['id'], nodes) self.assertEqual(exception.ProfileTypeNotMatch, ex.exc_info[0]) msg = _("Profile type of nodes %s does not match with " "cluster") % nodes self.assertEqual(msg, six.text_type(ex.exc_info[1]))
def setUp(self): super(ClusterTest, self).setUp() self.ctx = utils.dummy_context(project='cluster_test_project') self.eng = service.EngineService('host-a', 'topic-a') self.eng.init_tgm() self.eng.dispatcher = mock.Mock() env = environment.global_env() env.register_profile('TestProfile', fakes.TestProfile) env.register_policy('TestPolicy', fakes.TestPolicy) spec = { 'type': 'TestProfile', 'version': '1.0', 'properties': {'INT': 10, 'STR': 'string'}, } self.profile = self.eng.profile_create(self.ctx, 'p-test', spec, permission='1111') spec = { 'type': 'TestPolicy', 'version': '1.0', 'properties': {'KEY2': 3} } self.policy = self.eng.policy_create(self.ctx, 'policy_1', spec, cooldown=60, level=50)
def setUp(self): super(TestProfileBase, self).setUp() self.ctx = utils.dummy_context(project='profile_test_project') g_env = environment.global_env() g_env.register_profile('os.dummy-1.0', DummyProfile) g_env.register_profile('os.dummy-1.1', DummyProfile) self.spec = parser.simple_parse(sample_profile)
def test_cluster_update_update_to_diff_profile_type(self, notify): # Register a different profile env = environment.global_env() env.register_profile('DiffProfileType', fakes.TestProfile) new_spec = { 'type': 'DiffProfileType', 'version': '1.0', 'properties': { 'INT': 10, 'STR': 'string' }, } new_profile = self.eng.profile_create(self.ctx, 'p-test', new_spec, permission='1111') c = self.eng.cluster_create(self.ctx, 'c-1', 0, self.profile['id']) ex = self.assertRaises(rpc.ExpectedException, self.eng.cluster_update, self.ctx, c['id'], profile_id=new_profile['id']) self.assertEqual(exception.ProfileTypeNotMatch, ex.exc_info[0])
def _setup_fakes(self): """Set up fake proflie for the purpose of testing. This method is provided in a standalone function because not all test cases need such a set up. """ environment.global_env().register_profile('TestProfile-1.0', fakes.TestProfile) self.spec = { 'type': 'TestProfile', 'version': '1.0', 'properties': { 'INT': 1, 'STR': 'str', 'LIST': ['v1', 'v2'], 'MAP': {'KEY1': 1, 'KEY2': 'v2'}, } }
def setUp(self): super(ProfileTest, self).setUp() self.ctx = utils.dummy_context(project='profile_test_project') self.eng = service.EngineService('host-a', 'topic-a') self.eng.init_tgm() environment.global_env().register_profile('TestProfile', fakes.TestProfile) self.spec = { 'type': 'TestProfile', 'version': '1.0', 'properties': { 'INT': 1, 'STR': 'str', 'LIST': ['v1', 'v2'], 'MAP': {'KEY1': 1, 'KEY2': 'v2'}, } }
def __new__(cls, ctx, type_name, name, **kwargs): '''Create a new profile of the appropriate class.''' if cls != Profile: ProfileClass = cls else: ProfileClass = environment.global_env().get_profile(type_name) return super(Profile, cls).__new__(ProfileClass)
def __new__(cls, type_name, name, **kwargs): '''Create a new policy of the appropriate class.''' if cls != Policy: PolicyClass = cls else: PolicyClass = environment.global_env().get_policy(type_name) return super(Policy, cls).__new__(PolicyClass)
def test_global_initialize(self, mock_mapping): mock_mapping.return_value = [['aaa', mock.Mock()]] environment._environment = None environment.initialize() expected = [mock.call('senlin.profiles'), mock.call('senlin.policies'), mock.call('senlin.triggers'), mock.call('senlin.drivers')] self.assertIsNotNone(environment._environment) self.assertEqual(expected, mock_mapping.call_args_list) self.assertIsNotNone(environment.global_env().get_profile('aaa')) self.assertIsNotNone(environment.global_env().get_policy('aaa')) self.assertIsNotNone(environment.global_env().get_trigger('aaa')) self.assertIsNotNone(environment.global_env().get_driver('aaa')) environment._environment = None
def test_init_using_specified_cloud_backend(self): plugin2 = mock.Mock() plugin2.compute = 'Compute2' plugin2.orchestration = 'Orchestration2' env = environment.global_env() env.register_driver('cloud_backend_2', plugin2) # Using specified cloud backend sd = driver_base.SenlinDriver('cloud_backend_2') self.assertEqual('Compute2', sd.compute) self.assertEqual('Orchestration2', sd.orchestration)
def test_init_using_specified_cloud_backend(self): plugin2 = mock.Mock() plugin2.compute = 'Compute2' plugin2.orchestration = 'Orchestration2' env = environment.global_env() env.register_driver('openstack_test', plugin2) sd = driver_base.SenlinDriver('openstack_test') self.assertEqual('Compute2', sd.compute) self.assertEqual('Orchestration2', sd.orchestration)
def test_global_initialize(self, mock_mapping): mock_mapping.return_value = [["aaa", mock.Mock()]] environment._environment = None environment.initialize() expected = [ mock.call("senlin.profiles"), mock.call("senlin.policies"), mock.call("senlin.triggers"), mock.call("senlin.drivers"), ] self.assertIsNotNone(environment._environment) self.assertEqual(expected, mock_mapping.call_args_list) self.assertIsNotNone(environment.global_env().get_profile("aaa")) self.assertIsNotNone(environment.global_env().get_policy("aaa")) self.assertIsNotNone(environment.global_env().get_trigger("aaa")) self.assertIsNotNone(environment.global_env().get_driver("aaa")) environment._environment = None
def test_init_using_default_cloud_backend(self): plugin1 = mock.Mock() plugin1.compute = 'Compute1' plugin1.orchestration = 'Orchestration1' env = environment.global_env() env.register_driver('cloud_backend_1', plugin1) # Using default cloud backend defined in configure file cfg.CONF.set_override('cloud_backend', 'cloud_backend_1') sd = driver_base.SenlinDriver() self.assertEqual('Compute1', sd.compute) self.assertEqual('Orchestration1', sd.orchestration)
def test_init_using_default_cloud_backend(self): plugin1 = mock.Mock() plugin1.compute = 'Compute1' plugin1.orchestration = 'Orchestration1' env = environment.global_env() env.register_driver('openstack_test', plugin1) cfg.CONF.set_override('cloud_backend', 'openstack_test') sd = driver_base.SenlinDriver() self.assertEqual('Compute1', sd.compute) self.assertEqual('Orchestration1', sd.orchestration)
def setUp(self): super(NodeTest, self).setUp() self.ctx = utils.dummy_context(project="node_test_project") self.eng = service.EngineService("host-a", "topic-a") self.eng.init_tgm() self.eng.dispatcher = mock.Mock() env = environment.global_env() env.register_profile("TestProfile", fakes.TestProfile) self.spec = {"type": "TestProfile", "version": "1.0", "properties": {"INT": 10, "STR": "string"}} self.profile = self.eng.profile_create(self.ctx, "p-test", self.spec, permission="1111")
def test_cluster_update_update_to_diff_profile_type(self, notify): # Register a different profile env = environment.global_env() env.register_profile('DiffProfileType', fakes.TestProfile) new_profile = self.eng.profile_create( self.ctx, 'p-test', 'DiffProfileType', spec={'INT': 10, 'STR': 'string'}, perm='1111') c = self.eng.cluster_create(self.ctx, 'c-1', 0, self.profile['id']) ex = self.assertRaises(rpc.ExpectedException, self.eng.cluster_update, self.ctx, c['id'], profile_id=new_profile['id']) self.assertEqual(exception.ProfileTypeNotMatch, ex.exc_info[0])
def test_init_using_default_cloud_backend(self): plugin1 = mock.Mock() plugin1.compute = 'Compute1' plugin1.orchestration = 'Orchestration1' env = environment.global_env() env.register_driver('cloud_backend_1', plugin1) # Using default cloud backend defined in configure file cfg.CONF.set_override('cloud_backend', 'cloud_backend_1', enforce_type=True) sd = driver_base.SenlinDriver() self.assertEqual('Compute1', sd.compute) self.assertEqual('Orchestration1', sd.orchestration)
def __init__(self, backend_name=None): if backend_name is None: backend_name = cfg.CONF.cloud_backend backend = environment.global_env().get_driver(backend_name) self.compute = backend.compute self.loadbalancing = backend.loadbalancing self.network = backend.network self.orchestration = backend.orchestration self.telemetry = backend.telemetry self.identity = backend.identity self.message = backend.message
def _prepare_policy(self, name, type_name=None, cooldown=None, level=None): if type_name is not None: env = environment.global_env() env.register_policy(type_name, fakes.TestPolicy) else: type_name = 'TestPolicy' spec = {'type': type_name, 'version': '1.0', 'properties': {'KEY2': 5}} policy = self.eng.policy_create(self.ctx, name, spec, cooldown=cooldown or 60, level=level or 50) return policy
def __init__(self, backend_name=None): if backend_name is None: backend_name = cfg.CONF.cloud_backend backend = environment.global_env().get_driver(backend_name) # TODO(Yanyan Hu): Use openstack compute driver(nova_v2) # as the start point of using senlin generic driver. self.compute = backend.compute self.loadbalancing = backend.loadbalancing self.network = backend.network self.orchestration = backend.orchestration self.telemetry = backend.telemetry self.identity = backend.identity
def __new__(cls, name, spec, **kwargs): """Create a new profile of the appropriate class. :param name: The name for the profile. :param spec: A dictionary containing the spec for the profile. :param kwargs: Keyword arguments for policy creation. :returns: An instance of a specific sub-class of Policy. """ type_name, version = schema.get_spec_version(spec) if cls != Profile: ProfileClass = cls else: ProfileClass = environment.global_env().get_profile(type_name) return super(Profile, cls).__new__(ProfileClass)
def __new__(cls, name, spec, **kwargs): """Create a trigger instance based on its type and version. :param name: The name for the trigger. :param spec: A dictionary containing the spec for the trigger. :param kwargs: Keyword arguments for trigger creation. :returns: An instance of a specific sub-class of BaseTrigger. """ type_name, version = schema.get_spec_version(spec) if cls != Trigger: TriggerClass = cls else: TriggerClass = environment.global_env().get_trigger(type_name) return super(Trigger, cls).__new__(TriggerClass)
def _prepare_policy(self, name, type_name=None, cooldown=None, level=None): if type_name is not None: env = environment.global_env() env.register_policy(type_name, fakes.TestPolicy) else: type_name = 'TestPolicy' spec = { 'type': type_name, 'version': '1.0', 'properties': {'KEY2': 5} } policy = self.eng.policy_create(self.ctx, name, spec, cooldown=cooldown or 60, level=level or 50) return policy
def test_node_create_profile_type_not_match(self, notify): env = environment.global_env() env.register_profile("SecondProfile", fakes.TestProfile) new_spec = {"type": "SecondProfile", "version": "1.0", "properties": {"INT": 20, "STR": "string"}} cluster_profile = self.eng.profile_create(self.ctx, "cp", new_spec) cluster = self.eng.cluster_create(self.ctx, "c-1", 0, cluster_profile["id"]) ex = self.assertRaises( rpc.ExpectedException, self.eng.node_create, self.ctx, "n-1", self.profile["id"], cluster_id=cluster["id"] ) self.assertEqual(exception.ProfileTypeNotMatch, ex.exc_info[0]) self.assertEqual( "Node and cluster have different profile type, " "operation aborted.", six.text_type(ex.exc_info[1]) )
def test_node_update_with_diff_profile_type(self, notify): env = environment.global_env() env.register_profile("NewProfileType", fakes.TestProfile) new_spec = {"type": "NewProfileType", "version": "1.0", "properties": {"INT": 20}} new_profile = self.eng.profile_create(self.ctx, "p-new", new_spec) node = self.eng.node_create(self.ctx, "node-1", self.profile["id"]) ex = self.assertRaises( rpc.ExpectedException, self.eng.node_update, self.ctx, node["id"], profile_id=new_profile["id"] ) self.assertEqual(exception.ProfileTypeNotMatch, ex.exc_info[0]) self.assertEqual( "Cannot update a node to a different profile type, " "operation aborted.", six.text_type(ex.exc_info[1]) )
def __init__(self, backend_name=None): if backend_name is None: backend_name = cfg.CONF.cloud_backend backend = environment.global_env().get_driver(backend_name) self.compute = backend.compute self.loadbalancing = backend.loadbalancing self.network = backend.network self.octavia = backend.octavia self.orchestration = backend.orchestration self.identity = backend.identity self.message = backend.message self.workflow = backend.workflow self.block_storage = backend.block_storage
def test_node_join_profile_type_not_match(self, notify): # prepare a cluster with different profile type env = environment.global_env() env.register_profile("OtherProfileType", fakes.TestProfile) other_spec = {"type": "OtherProfileType", "version": "1.0", "properties": {"INT": 20, "STR": "okay"}} other_profile = self.eng.profile_create(self.ctx, "new-profile", other_spec) c = self.eng.cluster_create(self.ctx, "c-1", 0, other_profile["id"]) cluster_id = c["id"] node = self.eng.node_create(self.ctx, "node1", self.profile["id"]) node_id = node["id"] ex = self.assertRaises(rpc.ExpectedException, self.eng.node_join, self.ctx, node_id, cluster_id) self.assertEqual(exception.ProfileTypeNotMatch, ex.exc_info[0]) self.assertEqual( "Node and cluster have different profile type, " "operation aborted.", six.text_type(ex.exc_info[1]) )
def setUp(self): super(ClusterTest, self).setUp() self.ctx = utils.dummy_context(tenant_id='cluster_test_tenant') self.eng = service.EngineService('host-a', 'topic-a') self.eng.init_tgm() self.eng.dispatcher = mock.Mock() env = environment.global_env() env.register_profile('TestProfile', fakes.TestProfile) env.register_policy('TestPolicy', fakes.TestPolicy) self.profile = self.eng.profile_create( self.ctx, 'p-test', 'TestProfile', spec={'INT': 10, 'STR': 'string'}, perm='1111') self.policy = self.eng.policy_create( self.ctx, 'policy_1', 'TestPolicy', spec={'KEY1': 'string'}, cooldown=60, level=50)
def setUp(self): super(WebhookTest, self).setUp() self.ctx = utils.dummy_context(project='webhook_test_project') self.eng = service.EngineService('host-a', 'topic-a') self.eng.init_tgm() self.eng.dispatcher = mock.Mock() env = environment.global_env() env.register_profile('TestProfile', fakes.TestProfile) spec = { 'type': 'TestProfile', 'version': '1.0', 'properties': { 'INT': 10, 'STR': 'string' } } self.profile = self.eng.profile_create(self.ctx, 'p-test', spec, permission='1111')
def setUp(self): super(ClusterPolicyTest, self).setUp() self.ctx = utils.dummy_context(project='cluster_policy_test_project') self.eng = service.EngineService('host-a', 'topic-a') self.eng.init_tgm() self.eng.dispatcher = mock.Mock() self.patchobject(dispatcher, 'notify') env = environment.global_env() env.register_profile('TestProfile', fakes.TestProfile) env.register_policy('TestPolicy', fakes.TestPolicy) profile_spec = { 'type': 'TestProfile', 'version': '1.0', 'properties': { 'INT': 10, 'STR': 'string' }, } self.profile = self.eng.profile_create(self.ctx, 'p-test', profile_spec, permission='1111') policy_spec = { 'type': 'TestPolicy', 'version': '1.0', 'properties': { 'KEY2': 5 }, } self.policy = self.eng.policy_create(self.ctx, 'policy_1', policy_spec, cooldown=6, level=5) self.cluster = self.eng.cluster_create(self.ctx, 'c-1', 0, self.profile['id'])
def test_node_update_with_diff_profile_type(self, notify): env = environment.global_env() env.register_profile('NewProfileType', fakes.TestProfile) new_spec = { 'type': 'NewProfileType', 'version': '1.0', 'properties': {'INT': 20}, } new_profile = self.eng.profile_create(self.ctx, 'p-new', new_spec) node = self.eng.node_create(self.ctx, 'node-1', self.profile['id']) ex = self.assertRaises(rpc.ExpectedException, self.eng.node_update, self.ctx, node['id'], profile_id=new_profile['id']) self.assertEqual(exception.ProfileTypeNotMatch, ex.exc_info[0]) self.assertEqual('Cannot update a node to a different profile type, ' 'operation aborted.', six.text_type(ex.exc_info[1]))
def test_node_create_profile_type_not_match(self, notify): env = environment.global_env() env.register_profile('SecondProfile', fakes.TestProfile) new_spec = { 'type': 'SecondProfile', 'version': '1.0', 'properties': {'INT': 20, 'STR': 'string'} } cluster_profile = self.eng.profile_create(self.ctx, 'cp', new_spec) cluster = self.eng.cluster_create(self.ctx, 'c-1', 0, cluster_profile['id']) ex = self.assertRaises(rpc.ExpectedException, self.eng.node_create, self.ctx, 'n-1', self.profile['id'], cluster_id=cluster['id']) self.assertEqual(exception.ProfileTypeNotMatch, ex.exc_info[0]) self.assertEqual("Node and cluster have different profile type, " "operation aborted.", six.text_type(ex.exc_info[1]))
def test_cluster_add_nodes_node_profile_type_not_match(self, notify): c = self.eng.cluster_create(self.ctx, 'c-1', 0, self.profile['id']) # Register a different profile env = environment.global_env() env.register_profile('DiffProfileType', fakes.TestProfile) new_spec = { 'type': 'DiffProfileType', 'version': '1.0', 'properties': {'INT': 10, 'STR': 'string'}, } new_profile = self.eng.profile_create( self.ctx, 'p-test', new_spec, permission='1111') nodes = self._prepare_nodes(self.ctx, count=1, profile_id=new_profile['id']) ex = self.assertRaises(rpc.ExpectedException, self.eng.cluster_add_nodes, self.ctx, c['id'], nodes) self.assertEqual(exception.ProfileTypeNotMatch, ex.exc_info[0]) msg = _("Profile type of nodes %s does not match with " "cluster") % nodes self.assertEqual(msg, six.text_type(ex.exc_info[1]))
def test_node_update_with_diff_profile_type(self, notify): env = environment.global_env() env.register_profile('NewProfileType', fakes.TestProfile) new_spec = { 'type': 'NewProfileType', 'version': '1.0', 'properties': { 'INT': 20 }, } new_profile = self.eng.profile_create(self.ctx, 'p-new', new_spec) node = self.eng.node_create(self.ctx, 'node-1', self.profile['id']) ex = self.assertRaises(rpc.ExpectedException, self.eng.node_update, self.ctx, node['id'], profile_id=new_profile['id']) self.assertEqual(exception.ProfileTypeNotMatch, ex.exc_info[0]) self.assertEqual( 'Cannot update a node to a different profile type, ' 'operation aborted.', six.text_type(ex.exc_info[1]))
def setUp(self): super(TestTriggerBase, self).setUp() self.ctx = utils.dummy_context() environment.global_env().register_trigger('FakeTriggerType', FakeTriggerImpl)
def setUp(self): super(TestPolicyBase, self).setUp() self.ctx = utils.dummy_context() environment.global_env().register_policy('senlin.policy.dummy', DummyPolicy) self.spec = parser.simple_parse(sample_policy)
def setUp(self): super(ActionPolicyCheckTest, self).setUp() self.ctx = utils.dummy_context() environment.global_env().register_policy('DummyPolicy', fakes.TestPolicy)