def setUp(self):
super(TestRPCAlarmPartitionCoordination, self).setUp()
self.notified = []
self.stubs = self.useFixture(moxstubout.MoxStubout()).stubs
self.stubs.Set(rpc, 'fanout_cast', self.faux_fanout_cast)
self.ordination = rpc_alarm.RPCAlarmPartitionCoordination()
self.alarms = [mock.MagicMock(), mock.MagicMock()]
def setUp(self):
super(TestImagePollster, self).setUp()
self.stubs = self.useFixture(moxstubout.MoxStubout()).stubs
self.context = context.get_admin_context()
self.manager = TestManager()
self.stubs.Set(glance._Base, 'get_glance_client',
self.fake_get_glance_client)
def setUp(self):
super(TestNovaClient, self).setUp()
self.nv = nova_client.Client()
self.stubs = self.useFixture(moxstubout.MoxStubout()).stubs
self.stubs.Set(self.nv.nova_client.flavors, 'get',
self.fake_flavors_get)
self.stubs.Set(self.nv.nova_client.images, 'get', self.fake_images_get)
def setUp(self):
super(TestLibvirtInspection, self).setUp()
self.instance_name = 'instance-00000001'
self.inspector = libvirt_inspector.LibvirtInspector()
self.mox = self.useFixture(moxstubout.MoxStubout()).mox
self.inspector.connection = self.mox.CreateMockAnything()
self.domain = self.mox.CreateMockAnything()
def setUp(self):
super(TestFloatingIPPollster, self).setUp()
self.stubs = self.useFixture(moxstubout.MoxStubout()).stubs
self.context = context.get_admin_context()
self.manager = manager.AgentManager()
self.pollster = floatingip.FloatingIPPollster()
self.stubs.Set(nova_client.Client, 'floating_ip_get_all',
self.faux_get_ips)
def setUp(self):
super(TestRunTasks, self).setUp()
# Set up a fake instance value to be returned by
# instance_get_all_by_host() so when the manager gets the list
# of instances to poll we can control the results.
self.instance = self._fake_instance('faux', 'active')
stillborn_instance = self._fake_instance('stillborn', 'error')
self.stubs = self.useFixture(moxstubout.MoxStubout()).stubs
self.stubs.Set(nova_client.Client, 'instance_get_all_by_host',
lambda *x: [self.instance, stillborn_instance])
def setUp(self):
super(TestPollsterBase, self).setUp()
self.mox = self.useFixture(moxstubout.MoxStubout()).mox
self.mox.StubOutWithMock(virt_inspector, 'get_hypervisor_inspector')
self.inspector = self.mox.CreateMock(virt_inspector.Inspector)
virt_inspector.get_hypervisor_inspector().AndReturn(self.inspector)
self.instance = mock.MagicMock()
self.instance.name = 'instance-00000001'
setattr(self.instance, 'OS-EXT-SRV-ATTR:instance_name',
self.instance.name)
self.instance.id = 1
self.instance.flavor = {'name': 'm1.small', 'id': 2, 'vcpus': 1,
'ram': 512, 'disk': 20, 'ephemeral': 0}
def setUp(self):
super(TestUDPCollectorService, self).setUp()
self.mox = self.useFixture(moxstubout.MoxStubout()).mox
self.srv = service.UDPCollectorService()
self.counter = sample.Sample(
name='foobar',
type='bad',
unit='F',
volume=1,
user_id='jd',
project_id='ceilometer',
resource_id='cat',
timestamp='NOW!',
resource_metadata={},
).as_dict()
def setUp(self):
super(TestCase, self).setUp()
self.tempdir = self.useFixture(fixtures.TempDir())
self.useFixture(fixtures.FakeLogger())
self.useFixture(config.Config())
moxfixture = self.useFixture(moxstubout.MoxStubout())
self.mox = moxfixture.mox
self.stubs = moxfixture.stubs
cfg.CONF([], project='ceilometer')
# Set a default location for the pipeline config file so the
# tests work even if ceilometer is not installed globally on
# the system.
cfg.CONF.set_override('pipeline_cfg_file',
self.path_get('etc/ceilometer/pipeline.yaml'))
def setUp(self):
super(TestRPCAlarmNotifier, self).setUp()
self.notified = []
self.stubs = self.useFixture(moxstubout.MoxStubout()).stubs
self.stubs.Set(rpc, 'cast', self.faux_cast)
self.notifier = rpc_alarm.RPCAlarmNotifier()
self.alarms = [
AlarmClient(None,
info={
'name': 'instance_running_hot',
'meter_name': 'cpu_util',
'comparison_operator': 'gt',
'threshold': 80.0,
'evaluation_periods': 5,
'statistic': 'avg',
'state': 'ok',
'ok_actions': ['http://host:8080/path'],
'user_id': 'foobar',
'project_id': 'snafu',
'period': 60,
'alarm_id': str(uuid.uuid4()),
'matching_metadata': {
'resource_id': 'my_instance'
}
}),
AlarmClient(None,
info={
'name': 'group_running_idle',
'meter_name': 'cpu_util',
'comparison_operator': 'le',
'threshold': 10.0,
'statistic': 'max',
'evaluation_periods': 4,
'state': 'insufficient data',
'insufficient_data_actions':
['http://other_host/path'],
'user_id': 'foobar',
'project_id': 'snafu',
'period': 300,
'alarm_id': str(uuid.uuid4()),
'matching_metadata': {
'metadata.user_metadata.AS': 'my_group'
}
}),
]
def setUp(self):
super(TestComputeDurationByResource, self).setUp()
self.stubs = self.useFixture(moxstubout.MoxStubout()).stubs
# Create events relative to the range and pretend
# that the intervening events exist.
self.early1 = datetime.datetime(2012, 8, 27, 7, 0)
self.early2 = datetime.datetime(2012, 8, 27, 17, 0)
self.start = datetime.datetime(2012, 8, 28, 0, 0)
self.middle1 = datetime.datetime(2012, 8, 28, 8, 0)
self.middle2 = datetime.datetime(2012, 8, 28, 18, 0)
self.end = datetime.datetime(2012, 8, 28, 23, 59)
self.late1 = datetime.datetime(2012, 8, 29, 9, 0)
self.late2 = datetime.datetime(2012, 8, 29, 19, 0)
def setUp(self):
super(TestPipeline, self).setUp()
self.test_counter = sample.Sample(
name='a',
type=sample.TYPE_GAUGE,
volume=1,
unit='B',
user_id="test_user",
project_id="test_proj",
resource_id="test_resource",
timestamp=timeutils.utcnow().isoformat(),
resource_metadata={})
self.stubs = self.useFixture(moxstubout.MoxStubout()).stubs
self.stubs.Set(transformer.TransformerExtensionManager, "__init__",
self.fake_tem_init)
self.stubs.Set(transformer.TransformerExtensionManager, "get_ext",
self.fake_tem_get_ext)
self.stubs.Set(publisher, 'get_publisher', self.get_publisher)
self.transformer_manager = transformer.TransformerExtensionManager()
self.pipeline_cfg = [
{
'name': "test_pipeline",
'interval': 5,
'counters': ['a'],
'transformers': [{
'name': "update",
'parameters': {}
}],
'publishers': ["test://"],
},
]
def setUp(self):
super(TestNovaNotifier, self).setUp()
nova_CONF.compute_driver = 'nova.virt.fake.FakeDriver'
nova_CONF.notification_driver = [
nova_notifier.__name__,
'nova.openstack.common.notifier.rpc_notifier',
]
nova_CONF.rpc_backend = 'nova.openstack.common.rpc.impl_fake'
nova_CONF.vnc_enabled = False
nova_CONF.spice.enabled = False
self.compute = importutils.import_object(nova_CONF.compute_manager)
self.context = context.get_admin_context()
self.stubs = self.useFixture(moxstubout.MoxStubout()).stubs
fake_network.set_stub_network_methods(self.stubs)
self.instance_data = {
"display_name": "instance-1",
"id": 1,
"image_ref": "FAKE",
"user_id": "FAKE",
"project_id": "FAKE",
"display_name": "FAKE NAME",
"hostname": "abcdef",
"reservation_id": "FAKE RID",
"instance_type_id": 1,
"architecture": "x86",
"memory_mb": "1024",
"root_gb": "20",
"ephemeral_gb": "0",
"vcpus": 1,
'node': "fakenode",
"host": "fakehost",
"availability_zone": "1e3ce043029547f1a61c1996d1a531a4",
"created_at": '2012-05-08 20:23:41',
"launched_at": '2012-05-08 20:25:45',
"terminated_at": '2012-05-09 20:23:41',
"os_type": "linux",
"kernel_id": "kernelid",
"ramdisk_id": "ramdiskid",
"vm_state": vm_states.ACTIVE,
"task_state": None,
"access_ip_v4": "192.168.5.4",
"access_ip_v6": "2001:DB8::0",
"metadata": {},
"uuid": "144e08f4-00cb-11e2-888e-5453ed1bbb5f",
"system_metadata": {},
"user_data": None,
"cleaned": 0,
"deleted": None,
"vm_mode": None,
"deleted_at": None,
"disable_terminate": False,
"root_device_name": None,
"default_swap_device": None,
"launched_on": None,
"display_description": None,
"key_data": None,
"key_name": None,
"config_drive": None,
"power_state": None,
"default_ephemeral_device": None,
"progress": 0,
"scheduled_at": None,
"updated_at": None,
"shutdown_terminate": False,
"cell_name": 'cell',
"locked": False,
"locked_by": None,
"launch_index": 0,
"auto_disk_config": False,
"ephemeral_key_uuid": None
}
self.instance = nova_instance.Instance()
self.instance = nova_instance.Instance._from_db_object(
context,
self.instance,
self.instance_data,
expected_attrs=['metadata', 'system_metadata'])
self.stubs.Set(db, 'instance_info_cache_delete', self.do_nothing)
self.stubs.Set(db, 'instance_destroy', self.do_nothing)
self.stubs.Set(db, 'instance_system_metadata_get',
self.fake_db_instance_system_metadata_get)
self.stubs.Set(db, 'block_device_mapping_get_all_by_instance',
lambda context, instance: {})
self.stubs.Set(db, 'instance_update_and_get_original',
lambda *args, **kwargs: (self.instance, self.instance))
self.stubs.Set(flavors, 'extract_flavor', self.fake_extract_flavor)
# Set up to capture the notification messages generated by the
# plugin and to invoke our notifier plugin.
self.notifications = []
ext_mgr = extension.ExtensionManager.make_test_instance(extensions=[
extension.Extension(
'test',
None,
None,
self.Pollster(),
),
], )
self.ext_mgr = ext_mgr
self.gatherer = nova_notifier.DeletedInstanceStatsGatherer(ext_mgr)
# Initialize the global _gatherer in nova_notifier to use the
# gatherer in this test instead of the gatherer in nova_notifier.
nova_notifier.initialize_gatherer(self.gatherer)
# Terminate the instance to trigger the notification.
with contextlib.nested(
# Under Grizzly, Nova has moved to no-db access on the
# compute node. The compute manager uses RPC to talk to
# the conductor. We need to disable communication between
# the nova manager and the remote system since we can't
# expect the message bus to be available, or the remote
# controller to be there if the message bus is online.
mock.patch.object(self.compute, 'conductor_api'),
# The code that looks up the instance uses a global
# reference to the API, so we also have to patch that to
# return our fake data.
mock.patch.object(nova_notifier.conductor_api,
'instance_get_by_uuid',
self.fake_instance_ref_get),
mock.patch(
'nova.openstack.common.notifier.rpc_notifier.notify',
self.notify)):
with mock.patch.object(self.compute.conductor_api,
'instance_destroy',
return_value=self.instance):
self.compute.terminate_instance(self.context,
instance=self.instance,
bdms=[],
reservations=[])
def setUp(self):
super(TestKwapi, self).setUp()
self.stubs = self.useFixture(moxstubout.MoxStubout()).stubs
self.context = context.get_admin_context()
self.manager = TestManager()
def setUp(self):
super(TestPostSamples, self).setUp()
self.published = []
self.stubs = self.useFixture(moxstubout.MoxStubout()).stubs
self.stubs.Set(rpc, 'cast', self.faux_cast)
def setUp(self):
super(TestQueryToKwArgs, self).setUp()
self.stubs = self.useFixture(moxstubout.MoxStubout()).stubs
self.stubs.Set(api, '_sanitize_query', lambda x, y, **z: x)
self.stubs.Set(api, '_verify_query_segregation', lambda x, **z: x)
def setUp(self):
super(TestDispatcherDB, self).setUp()
self.CONF = self.useFixture(config.Config()).conf
self.dispatcher = database.DatabaseDispatcher(self.CONF)
self.ctx = None
self.mox = self.useFixture(moxstubout.MoxStubout()).mox
def setUp(self):
super(TestUDPPublisher, self).setUp()
self.mox = self.useFixture(moxstubout.MoxStubout()).mox
self.CONF = self.useFixture(config.Config()).conf
def setUp(self):
super(TestSwiftPollster, self).setUp()
self.stubs = self.useFixture(moxstubout.MoxStubout()).stubs
self.pollster = self.factory()
self.manager = TestManager()
def setUp(self):
super(TestRunTasks, self).setUp()
self.stubs = self.useFixture(moxstubout.MoxStubout()).stubs
self.stubs.Set(ksclient, 'Client', lambda *args, **kwargs: None)
def setUp(self):
super(TestEnergyPollster, self).setUp()
self.stubs = self.useFixture(moxstubout.MoxStubout()).stubs
self.context = context.get_admin_context()
self.manager = TestManager()
self.stubs.Set(kwapi._Base, '_iter_probes', self.fake_iter_probes)
def setUp(self):
super(ConnectionTest, self).setUp()
self.stubs = self.useFixture(moxstubout.MoxStubout()).stubs
def setUp(self):
super(TestApiMiddleware, self).setUp()
self.stubs = self.useFixture(moxstubout.MoxStubout()).stubs
