def setUp(self):
super(TestBasicConsolidation, self).setUp()
# fake metrics
self.fake_metrics = faker_metrics_collector.FakerMetricsCollector()
# fake cluster
self.fake_cluster = faker_cluster_state.FakerModelCollector()
p_osc = mock.patch.object(clients, "OpenStackClients")
self.m_osc = p_osc.start()
self.addCleanup(p_osc.stop)
p_model = mock.patch.object(strategies.BasicConsolidation,
"compute_model",
new_callable=mock.PropertyMock)
self.m_model = p_model.start()
self.addCleanup(p_model.stop)
p_ceilometer = mock.patch.object(strategies.BasicConsolidation,
"ceilometer",
new_callable=mock.PropertyMock)
self.m_ceilometer = p_ceilometer.start()
self.addCleanup(p_ceilometer.stop)
p_audit_scope = mock.patch.object(strategies.BasicConsolidation,
"audit_scope",
new_callable=mock.PropertyMock)
self.m_audit_scope = p_audit_scope.start()
self.addCleanup(p_audit_scope.stop)
self.m_audit_scope.return_value = mock.Mock()
self.m_model.return_value = model_root.ModelRoot()
self.m_ceilometer.return_value = mock.Mock(
statistic_aggregation=self.fake_metrics.mock_get_statistics)
self.strategy = strategies.BasicConsolidation(config=mock.Mock())
def test_trigger_audit_state_succeeded(self, m_collector):
m_collector.return_value = faker.FakerModelCollector()
audit_handler = oneshot.OneShotAuditHandler()
audit_handler.execute(self.audit, self.context)
audit = objects.audit.Audit.get_by_uuid(self.context, self.audit.uuid)
self.assertEqual(objects.audit.State.SUCCEEDED, audit.state)
expected_calls = [
mock.call(self.context,
self.audit,
action=objects.fields.NotificationAction.STRATEGY,
phase=objects.fields.NotificationPhase.START),
mock.call(self.context,
self.audit,
action=objects.fields.NotificationAction.STRATEGY,
phase=objects.fields.NotificationPhase.END),
mock.call(self.context,
self.audit,
action=objects.fields.NotificationAction.PLANNER,
phase=objects.fields.NotificationPhase.START),
mock.call(self.context,
self.audit,
action=objects.fields.NotificationAction.PLANNER,
phase=objects.fields.NotificationPhase.END)
]
self.assertEqual(
expected_calls,
self.m_audit_notifications.send_action_notification.call_args_list)
def test_execute_sync_job_fails(self, m_start, m_list_available, m_load,
m_list, m_save):
fake_config = mock.Mock(period=.01)
fake_collector = faker_cluster_state.FakerModelCollector(
config=fake_config)
fake_collector.synchronize = mock.Mock(
side_effect=lambda: eventlet.sleep(.5))
m_list_available.return_value = {
'fake': faker_cluster_state.FakerModelCollector
}
m_load.return_value = fake_collector
scheduler = scheduling.DecisionEngineSchedulingService()
scheduler.start()
m_start.assert_called_once_with(scheduler)
jobs = scheduler.get_jobs()
self.assertEqual(2, len(jobs))
job = jobs[0]
job.func()
self.assertFalse(bool(fake_collector.cluster_data_model))
self.assertIsInstance(job.trigger, interval_trigger.IntervalTrigger)
def test_trigger_audit_without_errors(self, m_collector):
m_collector.return_value = faker.FakerModelCollector()
audit_handler = oneshot.OneShotAuditHandler()
audit_handler.execute(self.audit, self.context)
expected_calls = [
mock.call(self.context,
self.audit,
action=objects.fields.NotificationAction.STRATEGY,
phase=objects.fields.NotificationPhase.START),
mock.call(self.context,
self.audit,
action=objects.fields.NotificationAction.STRATEGY,
phase=objects.fields.NotificationPhase.END),
mock.call(self.context,
self.audit,
action=objects.fields.NotificationAction.PLANNER,
phase=objects.fields.NotificationPhase.START),
mock.call(self.context,
self.audit,
action=objects.fields.NotificationAction.PLANNER,
phase=objects.fields.NotificationPhase.END)
]
self.assertEqual(
expected_calls,
self.m_audit_notifications.send_action_notification.call_args_list)
def setUp(self):
super(TestOutletTempControl, self).setUp()
# fake metrics
self.fake_metrics = faker_metrics_collector.FakerMetricsCollector()
# fake cluster
self.fake_cluster = faker_cluster_state.FakerModelCollector()
p_model = mock.patch.object(strategies.OutletTempControl,
"compute_model",
new_callable=mock.PropertyMock)
self.m_model = p_model.start()
self.addCleanup(p_model.stop)
p_ceilometer = mock.patch.object(strategies.OutletTempControl,
"ceilometer",
new_callable=mock.PropertyMock)
self.m_ceilometer = p_ceilometer.start()
self.addCleanup(p_ceilometer.stop)
p_audit_scope = mock.patch.object(strategies.OutletTempControl,
"audit_scope",
new_callable=mock.PropertyMock)
self.m_audit_scope = p_audit_scope.start()
self.addCleanup(p_audit_scope.stop)
self.m_audit_scope.return_value = mock.Mock()
self.m_model.return_value = model_root.ModelRoot()
self.m_ceilometer.return_value = mock.Mock(
statistic_aggregation=self.fake_metrics.mock_get_statistics)
self.strategy = strategies.OutletTempControl(config=mock.Mock())
self.strategy.input_parameters = utils.Struct()
self.strategy.input_parameters.update({'threshold': 34.3})
self.strategy.threshold = 34.3
def __init__(self):
self.api_version = self.API_VERSION
self.service_name = None
# fake cluster instead on Nova CDM
self.fake_cdmc = faker_cluster_state.FakerModelCollector()
self.publisher_id = 'test_publisher_id'
self.conductor_topic = 'test_conductor_topic'
self.status_topic = 'test_status_topic'
self.notification_topics = ['nova']
self.conductor_endpoints = [] # Disable audit endpoint
self.status_endpoints = []
self.notification_endpoints = [
novanotification.ServiceUpdated(self.fake_cdmc),
novanotification.InstanceCreated(self.fake_cdmc),
novanotification.InstanceUpdated(self.fake_cdmc),
novanotification.InstanceDeletedEnd(self.fake_cdmc),
novanotification.LegacyInstanceCreatedEnd(self.fake_cdmc),
novanotification.LegacyInstanceUpdated(self.fake_cdmc),
novanotification.LegacyLiveMigratedEnd(self.fake_cdmc),
novanotification.LegacyInstanceDeletedEnd(self.fake_cdmc),
]
def test_build_model_from_xml(self):
fake_cluster = faker_cluster_state.FakerModelCollector()
expected_model = fake_cluster.generate_scenario_1()
struct_str = self.load_data('scenario_1.xml')
model = model_root.ModelRoot.from_xml(struct_str)
self.assertEqual(expected_model.to_string(), model.to_string())
def build():
metrics = fake.FakerMetricsCollector()
current_state_cluster = faker_cluster_state.FakerModelCollector()
sercon = strategies.BasicConsolidation(config=mock.Mock())
sercon._compute_model = current_state_cluster.generate_scenario_1()
sercon.ceilometer = mock.MagicMock(
get_statistics=metrics.mock_get_statistics)
return sercon.execute()
def test_get_node_free_resources(self):
fake_cluster = faker_cluster_state.FakerModelCollector()
model = fake_cluster.generate_scenario_1()
node = model.get_node_by_uuid("Node_0")
resources_free = model.get_node_free_resources(node)
self.assertEqual(20, resources_free.get('vcpu'))
self.assertEqual(128, resources_free.get('memory'))
self.assertEqual(210, resources_free.get('disk'))
def test_get_node_used_resources(self):
fake_cluster = faker_cluster_state.FakerModelCollector()
model = fake_cluster.generate_scenario_1()
node = element.ComputeNode(uuid="Node_0")
resources_used = model.get_node_used_resources(node)
self.assertEqual(20, resources_used.get('vcpu'))
self.assertEqual(4, resources_used.get('memory'))
self.assertEqual(40, resources_used.get('disk'))
def test_get_node_instances(self):
fake_cluster = faker_cluster_state.FakerModelCollector()
model = fake_cluster.generate_scenario_1()
node = element.ComputeNode(uuid="Node_0")
instance0 = model.get_instance_by_uuid("INSTANCE_0")
instance1 = model.get_instance_by_uuid("INSTANCE_1")
instances = model.get_node_instances(node)
self.assertEqual(2, len(instances))
self.assertIn(instance0, instances)
self.assertIn(instance1, instances)
def test_launch_audits_periodically(self, mock_list, mock_jobs, m_add_job,
m_collector):
audit_handler = continuous.ContinuousAuditHandler(mock.MagicMock())
mock_list.return_value = self.audits
mock_jobs.return_value = mock.MagicMock()
m_add_job.return_value = audit_handler.execute_audit(
self.audits[0], self.context)
m_collector.return_value = faker.FakerModelCollector()
audit_handler.launch_audits_periodically()
m_add_job.assert_called()
def test_model_structure(self):
fake_cluster = faker_cluster_state.FakerModelCollector()
model1 = fake_cluster.build_scenario_1()
self.assertEqual(5, len(model1.get_all_compute_nodes()))
self.assertEqual(35, len(model1.get_all_instances()))
self.assertEqual(8, len(model1.edges()))
expected_struct_str = self.load_data('scenario_1.xml')
model2 = model_root.ModelRoot.from_xml(expected_struct_str)
self.assertTrue(model_root.ModelRoot.is_isomorphic(model2, model1))
def test_do_trigger_audit(self, mock_collector):
mock_collector.return_value = faker_cluster_state.FakerModelCollector()
audit_handler = oneshot_handler.OneShotAuditHandler(mock.MagicMock())
endpoint = audit_endpoint.AuditEndpoint(audit_handler)
with mock.patch.object(oneshot_handler.OneShotAuditHandler,
'execute') as mock_call:
mock_call.return_value = 0
endpoint.do_trigger_audit(self.context, self.audit.uuid)
self.assertEqual(mock_call.call_count, 1)
def setUp(self):
super(TestDummyWithScorer, self).setUp()
# fake cluster
self.fake_cluster = faker_cluster_state.FakerModelCollector()
p_model = mock.patch.object(strategies.DummyWithScorer,
"compute_model",
new_callable=mock.PropertyMock)
self.m_model = p_model.start()
self.addCleanup(p_model.stop)
self.m_model.return_value = model_root.ModelRoot()
self.strategy = strategies.DummyWithScorer(config=mock.Mock())
def test_trigger_audit(self, mock_collector, mock_handler):
mock_collector.return_value = faker_cluster_state.FakerModelCollector()
audit_handler = oneshot_handler.OneShotAuditHandler
endpoint = audit_endpoint.AuditEndpoint(audit_handler)
with mock.patch.object(endpoint.executor, 'submit') as mock_call:
mock_execute = mock.call(endpoint.do_trigger_audit, self.context,
self.audit.uuid)
endpoint.trigger_audit(self.context, self.audit.uuid)
mock_call.assert_has_calls([mock_execute])
self.assertEqual(mock_call.call_count, 1)
def setUp(self):
super(TestStrategyContext, self).setUp()
obj_utils.create_test_goal(self.context, id=1, name="DUMMY")
audit_template = obj_utils.create_test_audit_template(
self.context, uuid=utils.generate_uuid())
self.audit = obj_utils.create_test_audit(
self.context, audit_template_id=audit_template.id)
self.fake_cluster = faker_cluster_state.FakerModelCollector()
p_model = mock.patch.object(
strategies.DummyStrategy, "compute_model",
new_callable=mock.PropertyMock)
self.m_model = p_model.start()
self.addCleanup(p_model.stop)
self.m_model.return_value = self.fake_cluster.build_scenario_1()
def test_trigger_audit_with_error(self, m_collector, m_do_execute):
m_collector.return_value = faker.FakerModelCollector()
m_do_execute.side_effect = Exception
audit_handler = oneshot.OneShotAuditHandler()
audit_handler.execute(self.audit, self.context)
expected_calls = [
mock.call(self.context, self.audit,
action=objects.fields.NotificationAction.STRATEGY,
phase=objects.fields.NotificationPhase.START),
mock.call(self.context, self.audit,
action=objects.fields.NotificationAction.STRATEGY,
priority=objects.fields.NotificationPriority.ERROR,
phase=objects.fields.NotificationPhase.ERROR)]
self.assertEqual(
expected_calls,
self.m_audit_notifications.send_action_notification.call_args_list)
def setUp(self):
super(TestUniformAirflow, self).setUp()
# fake metrics
self.fake_metrics = self.fake_datasource_cls()
# fake cluster
self.fake_cluster = faker_cluster_state.FakerModelCollector()
p_model = mock.patch.object(strategies.UniformAirflow,
"compute_model",
new_callable=mock.PropertyMock)
self.m_model = p_model.start()
self.addCleanup(p_model.stop)
p_datasource = mock.patch.object(strategies.UniformAirflow,
'datasource_backend',
new_callable=mock.PropertyMock)
self.m_datasource = p_datasource.start()
self.addCleanup(p_datasource.stop)
p_audit_scope = mock.patch.object(strategies.UniformAirflow,
"audit_scope",
new_callable=mock.PropertyMock)
self.m_audit_scope = p_audit_scope.start()
self.addCleanup(p_audit_scope.stop)
self.m_audit_scope.return_value = mock.Mock()
self.m_model.return_value = model_root.ModelRoot()
self.m_datasource.return_value = mock.Mock(
statistic_aggregation=self.fake_metrics.mock_get_statistics)
self.strategy = strategies.UniformAirflow(config=mock.Mock(
datasource=self.datasource))
self.strategy.input_parameters = utils.Struct()
self.strategy.input_parameters.update({
'threshold_airflow': 400.0,
'threshold_inlet_t': 28.0,
'threshold_power': 350.0,
'period': 300
})
self.strategy.threshold_airflow = 400
self.strategy.threshold_inlet_t = 28
self.strategy.threshold_power = 350
self._period = 300
class FakeManager(service_manager.ServiceManager):
API_VERSION = '1.0'
fake_cdmc = faker_cluster_state.FakerModelCollector()
@property
def service_name(self):
return 'watcher-fake'
@property
def api_version(self):
return self.API_VERSION
@property
def publisher_id(self):
return 'test_publisher_id'
@property
def conductor_topic(self):
return 'test_conductor_topic'
@property
def notification_topics(self):
return ['nova']
@property
def conductor_endpoints(self):
return [] # Disable audit endpoint
@property
def notification_endpoints(self):
return [
novanotification.ServiceUpdated(self.fake_cdmc),
novanotification.InstanceCreated(self.fake_cdmc),
novanotification.InstanceUpdated(self.fake_cdmc),
novanotification.InstanceDeletedEnd(self.fake_cdmc),
novanotification.LegacyInstanceCreatedEnd(self.fake_cdmc),
novanotification.LegacyInstanceUpdated(self.fake_cdmc),
novanotification.LegacyLiveMigratedEnd(self.fake_cdmc),
novanotification.LegacyInstanceDeletedEnd(self.fake_cdmc),
]
def test_trigger_audit_send_notification(self, mock_collector):
messaging = mock.MagicMock()
mock_collector.return_value = faker.FakerModelCollector()
audit_handler = oneshot.OneShotAuditHandler(messaging)
audit_handler.execute(self.audit, self.context)
call_on_going = mock.call(
events.Events.TRIGGER_AUDIT.name, {
'audit_status': audit_objects.State.ONGOING,
'audit_uuid': self.audit.uuid
})
call_succeeded = mock.call(
events.Events.TRIGGER_AUDIT.name, {
'audit_status': audit_objects.State.SUCCEEDED,
'audit_uuid': self.audit.uuid
})
calls = [call_on_going, call_succeeded]
messaging.publish_status_event.assert_has_calls(calls)
self.assertEqual(2, messaging.publish_status_event.call_count)
def test_start_de_scheduling_service(self, m_start, m_list_available,
m_load):
m_list_available.return_value = {
'fake': faker_cluster_state.FakerModelCollector
}
fake_collector = faker_cluster_state.FakerModelCollector(
config=mock.Mock(period=777))
m_load.return_value = fake_collector
scheduler = scheduling.DecisionEngineSchedulingService()
scheduler.start()
m_start.assert_called_once_with(scheduler)
jobs = scheduler.get_jobs()
self.assertEqual(2, len(jobs))
job = jobs[0]
self.assertTrue(bool(fake_collector.cluster_data_model))
self.assertIsInstance(job.trigger, interval_trigger.IntervalTrigger)
def setUp(self):
super(TestWorkloadBalance, self).setUp()
# fake metrics
self.fake_metrics = self.fake_datasource_cls()
# fake cluster
self.fake_cluster = faker_cluster_state.FakerModelCollector()
p_model = mock.patch.object(
strategies.WorkloadBalance, "compute_model",
new_callable=mock.PropertyMock)
self.m_model = p_model.start()
self.addCleanup(p_model.stop)
p_datasource = mock.patch.object(
strategies.WorkloadBalance, "datasource_backend",
new_callable=mock.PropertyMock)
self.m_datasource = p_datasource.start()
self.addCleanup(p_datasource.stop)
p_audit_scope = mock.patch.object(
strategies.WorkloadBalance, "audit_scope",
new_callable=mock.PropertyMock
)
self.m_audit_scope = p_audit_scope.start()
self.addCleanup(p_audit_scope.stop)
self.m_audit_scope.return_value = mock.Mock()
self.m_datasource.return_value = mock.Mock(
statistic_aggregation=self.fake_metrics.mock_get_statistics_wb)
self.strategy = strategies.WorkloadBalance(
config=mock.Mock(datasource=self.datasource))
self.strategy.input_parameters = utils.Struct()
self.strategy.input_parameters.update({'metrics': 'cpu_util',
'threshold': 25.0,
'period': 300,
'granularity': 300})
self.strategy.threshold = 25.0
self.strategy._period = 300
self.strategy._meter = "cpu_util"
self.strategy._granularity = 300
def test_model_structure(self):
fake_cluster = faker_cluster_state.FakerModelCollector()
model = fake_cluster.build_scenario_1()
self.assertEqual(5, len(model.get_all_compute_nodes()))
self.assertEqual(35, len(model.get_all_instances()))
self.assertEqual(8, len(model.edges()))
expected_struct_str = self.load_data('scenario_1.xml')
parser = etree.XMLParser(remove_blank_text=True)
expected_struct = etree.fromstring(expected_struct_str, parser)
model_structure = etree.fromstring(model.to_string(), parser)
normalized_expected_output = six.BytesIO()
normalized_model_output = six.BytesIO()
expected_struct.getroottree().write_c14n(normalized_expected_output)
model_structure.getroottree().write_c14n(normalized_model_output)
normalized_expected_struct = normalized_expected_output.getvalue()
normalized_model_struct = normalized_model_output.getvalue()
self.assertEqual(normalized_expected_struct, normalized_model_struct)
def setUp(self):
super(TestHostMaintenance, self).setUp()
# fake cluster
self.fake_cluster = faker_cluster_state.FakerModelCollector()
p_model = mock.patch.object(strategies.HostMaintenance,
"compute_model",
new_callable=mock.PropertyMock)
self.m_model = p_model.start()
self.addCleanup(p_model.stop)
p_audit_scope = mock.patch.object(strategies.HostMaintenance,
"audit_scope",
new_callable=mock.PropertyMock)
self.m_audit_scope = p_audit_scope.start()
self.addCleanup(p_audit_scope.stop)
self.m_audit_scope.return_value = mock.Mock()
self.m_model.return_value = model_root.ModelRoot()
self.strategy = strategies.HostMaintenance(config=mock.Mock())
def setUp(self):
super(TestBasicConsolidation, self).setUp()
# fake metrics
self.fake_metrics = self.fake_datasource_cls()
# fake cluster
self.fake_cluster = faker_cluster_state.FakerModelCollector()
p_osc = mock.patch.object(clients, "OpenStackClients")
self.m_osc = p_osc.start()
self.addCleanup(p_osc.stop)
p_model = mock.patch.object(strategies.BasicConsolidation,
"compute_model",
new_callable=mock.PropertyMock)
self.m_model = p_model.start()
self.addCleanup(p_model.stop)
p_datasource = mock.patch.object(strategies.BasicConsolidation,
'datasource_backend',
new_callable=mock.PropertyMock)
self.m_datasource = p_datasource.start()
self.addCleanup(p_datasource.stop)
p_audit_scope = mock.patch.object(strategies.BasicConsolidation,
"audit_scope",
new_callable=mock.PropertyMock)
self.m_audit_scope = p_audit_scope.start()
self.addCleanup(p_audit_scope.stop)
self.m_audit_scope.return_value = mock.Mock()
self.m_model.return_value = model_root.ModelRoot()
self.m_datasource.return_value = mock.Mock(
get_host_cpu_usage=self.fake_metrics.get_usage_node_cpu,
get_instance_cpu_usage=self.fake_metrics.
get_average_usage_instance_cpu)
self.strategy = strategies.BasicConsolidation(config=mock.Mock(
datasource=self.datasource))
def setUp(self):
super(TestWorkloadBalance, self).setUp()
# fake metrics
self.fake_metrics = ceilometer_metrics.FakeCeilometerMetrics()
# fake cluster
self.fake_cluster = faker_cluster_state.FakerModelCollector()
p_model = mock.patch.object(strategies.WorkloadBalance,
"compute_model",
new_callable=mock.PropertyMock)
self.m_model = p_model.start()
self.addCleanup(p_model.stop)
p_ceilometer = mock.patch.object(strategies.WorkloadBalance,
"ceilometer",
new_callable=mock.PropertyMock)
self.m_ceilometer = p_ceilometer.start()
self.addCleanup(p_ceilometer.stop)
p_audit_scope = mock.patch.object(strategies.WorkloadBalance,
"audit_scope",
new_callable=mock.PropertyMock)
self.m_audit_scope = p_audit_scope.start()
self.addCleanup(p_audit_scope.stop)
self.m_audit_scope.return_value = mock.Mock()
self.m_model.return_value = model_root.ModelRoot()
self.m_ceilometer.return_value = mock.Mock(
statistic_aggregation=self.fake_metrics.mock_get_statistics_wb)
self.strategy = strategies.WorkloadBalance(config=mock.Mock())
self.strategy.input_parameters = utils.Struct()
self.strategy.input_parameters.update({
'threshold': 25.0,
'period': 300
})
self.strategy.threshold = 25.0
self.strategy._period = 300
def setUp(self):
super(TestNoisyNeighbor, self).setUp()
# fake metrics
self.f_metrics = self.fake_datasource_cls()
# fake cluster
self.fake_cluster = faker_cluster_state.FakerModelCollector()
p_model = mock.patch.object(strategies.NoisyNeighbor,
"compute_model",
new_callable=mock.PropertyMock)
self.m_model = p_model.start()
self.addCleanup(p_model.stop)
p_datasource = mock.patch.object(strategies.NoisyNeighbor,
"datasource_backend",
new_callable=mock.PropertyMock)
self.m_datasource = p_datasource.start()
self.addCleanup(p_datasource.stop)
p_audit_scope = mock.patch.object(strategies.NoisyNeighbor,
"audit_scope",
new_callable=mock.PropertyMock)
self.m_audit_scope = p_audit_scope.start()
self.addCleanup(p_audit_scope.stop)
self.m_audit_scope.return_value = mock.Mock()
self.m_model.return_value = model_root.ModelRoot()
self.m_datasource.return_value = mock.Mock(
get_instance_l3_cache_usage=self.f_metrics.mock_get_statistics_nn)
self.strategy = strategies.NoisyNeighbor(config=mock.Mock())
self.strategy.input_parameters = utils.Struct()
self.strategy.input_parameters.update({'cache_threshold': 35})
self.strategy.threshold = 35
self.strategy.input_parameters.update({'period': 100})
self.strategy.threshold = 100
def setUp(self):
super(TestZoneMigration, self).setUp()
# fake compute cluster
self.fake_c_cluster = faker_cluster_state.FakerModelCollector()
# fake storage cluster
self.fake_s_cluster = faker_cluster_state.FakerStorageModelCollector()
p_c_model = mock.patch.object(
strategies.ZoneMigration, "compute_model",
new_callable=mock.PropertyMock)
self.m_c_model = p_c_model.start()
self.addCleanup(p_c_model.stop)
p_s_model = mock.patch.object(
strategies.ZoneMigration, "storage_model",
new_callable=mock.PropertyMock)
self.m_s_model = p_s_model.start()
self.addCleanup(p_s_model.stop)
p_migrate_compute_nodes = mock.patch.object(
strategies.ZoneMigration, "migrate_compute_nodes",
new_callable=mock.PropertyMock)
self.m_migrate_compute_nodes = p_migrate_compute_nodes.start()
self.addCleanup(p_migrate_compute_nodes.stop)
p_migrate_storage_pools = mock.patch.object(
strategies.ZoneMigration, "migrate_storage_pools",
new_callable=mock.PropertyMock)
self.m_migrate_storage_pools = p_migrate_storage_pools.start()
self.addCleanup(p_migrate_storage_pools.stop)
p_parallel_total = mock.patch.object(
strategies.ZoneMigration, "parallel_total",
new_callable=mock.PropertyMock)
self.m_parallel_total = p_parallel_total.start()
self.addCleanup(p_parallel_total.stop)
p_parallel_per_node = mock.patch.object(
strategies.ZoneMigration, "parallel_per_node",
new_callable=mock.PropertyMock)
self.m_parallel_per_node = p_parallel_per_node.start()
self.addCleanup(p_parallel_per_node.stop)
p_parallel_per_pool = mock.patch.object(
strategies.ZoneMigration, "parallel_per_pool",
new_callable=mock.PropertyMock)
self.m_parallel_per_pool = p_parallel_per_pool.start()
self.addCleanup(p_parallel_per_pool.stop)
p_audit_scope = mock.patch.object(
strategies.ZoneMigration, "audit_scope",
new_callable=mock.PropertyMock
)
self.m_audit_scope = p_audit_scope.start()
self.addCleanup(p_audit_scope.stop)
p_priority = mock.patch.object(
strategies.ZoneMigration, "priority",
new_callable=mock.PropertyMock
)
self.m_priority = p_priority.start()
self.addCleanup(p_priority.stop)
model = self.fake_c_cluster.generate_scenario_1()
self.m_c_model.return_value = model
model = self.fake_s_cluster.generate_scenario_1()
self.m_s_model.return_value = model
self.m_parallel_total.return_value = 6
self.m_parallel_per_node.return_value = 2
self.m_parallel_per_pool.return_value = 2
self.m_audit_scope.return_value = mock.Mock()
self.m_migrate_compute_nodes.return_value = [
{"src_node": "src1", "dst_node": "dst1"},
{"src_node": "src2", "dst_node": "dst2"}
]
self.m_migrate_storage_pools.return_value = [
{"src_pool": "src1@back1#pool1", "dst_pool": "dst1@back1#pool1",
"src_type": "type1", "dst_type": "type1"},
{"src_pool": "src2@back1#pool1", "dst_pool": "dst2@back2#pool1",
"src_type": "type2", "dst_type": "type3"}
]
self.m_audit_scope.return_value = mock.Mock()
self.strategy = strategies.ZoneMigration(
config=mock.Mock())
self.m_osc_cls = mock.Mock()
self.m_osc = mock.Mock(spec=clients.OpenStackClients)
self.m_osc_cls.return_value = self.m_osc
m_openstack_clients = mock.patch.object(
clients, "OpenStackClients", self.m_osc_cls)
m_openstack_clients.start()
self.addCleanup(m_openstack_clients.stop)
self.m_n_helper_cls = mock.Mock()
self.m_n_helper = mock.Mock(spec=nova_helper.NovaHelper)
self.m_n_helper_cls.return_value = self.m_n_helper
m_nova_helper = mock.patch.object(
nova_helper, "NovaHelper", self.m_n_helper_cls)
m_nova_helper.start()
self.addCleanup(m_nova_helper.stop)
self.m_c_helper_cls = mock.Mock()
self.m_c_helper = mock.Mock(spec=cinder_helper.CinderHelper)
self.m_c_helper_cls.return_value = self.m_c_helper
m_cinder_helper = mock.patch.object(
cinder_helper, "CinderHelper", self.m_c_helper_cls)
m_cinder_helper.start()
self.addCleanup(m_cinder_helper.stop)
def setUp(self):
super(TestComputeScope, self).setUp()
self.fake_cluster = faker_cluster_state.FakerModelCollector()
