def test_not_implemented_params(self, mock_mdf):
with mock.patch('ceilometer.monasca_client.Client'):
conn = impl_monasca.Connection('127.0.0.1:8080')
kwargs = dict(metaquery=True)
self.assertRaises(ceilometer.NotImplementedError,
lambda: list(conn.get_meters(**kwargs)))
def test_get_resources_simple_metaquery(self, mock_mdf):
with mock.patch("ceilometer.monasca_client.Client") as mock_client:
conn = impl_monasca.Connection("127.0.0.1:8080")
mnl_mock = mock_client().metrics_list
mnl_mock.return_value = [
{
'name': 'metric1',
'dimensions': {},
'value_meta': {
'key': 'value1'
}
},
{
'name': 'metric2',
'dimensions': {},
'value_meta': {
'key': 'value2'
}
},
]
kwargs = dict(metaquery={'metadata.key': 'value1'})
list(conn.get_resources(**kwargs))
ml_mock = mock_client().measurements_list
self.assertEqual(2, ml_mock.call_count)
self.assertEqual(
dict(dimensions={},
name='metric2',
limit=1,
start_time='1970-01-01T00:00:00Z'),
ml_mock.call_args_list[1][1])
def test_not_implemented_params(self, mock_mdf):
with mock.patch("ceilometer.monasca_client.Client"):
conn = impl_monasca.Connection("127.0.0.1:8080")
self.assertRaisesWithMessage("Query without filter "
"not implemented",
ceilometer.NotImplementedError,
lambda: list(
conn.get_meter_statistics(None)))
sf = storage.SampleFilter()
self.assertRaisesWithMessage("Query without meter "
"not implemented",
ceilometer.NotImplementedError,
lambda: list(
conn.get_meter_statistics(sf)))
sf.meter = "image"
self.assertRaisesWithMessage("Groupby message_id not implemented",
ceilometer.NotImplementedError,
lambda: list(
conn.get_meter_statistics(
sf,
groupby=['message_id'])))
sf.metaquery = "metaquery"
self.assertRaisesWithMessage("Metaquery not implemented",
ceilometer.NotImplementedError,
lambda: list(
conn.get_meter_statistics(sf)))
sf.metaquery = None
sf.start_timestamp_op = 'le'
self.assertRaisesWithMessage("Start time op le not implemented",
ceilometer.NotImplementedError,
lambda: list(
conn.get_meter_statistics(sf)))
sf.start_timestamp_op = None
sf.end_timestamp_op = 'ge'
self.assertRaisesWithMessage("End time op ge not implemented",
ceilometer.NotImplementedError,
lambda: list(
conn.get_meter_statistics(sf)))
sf.end_timestamp_op = None
sf.message_id = "message_id"
self.assertRaisesWithMessage("Message_id query not implemented",
ceilometer.NotImplementedError,
lambda: list(
conn.get_meter_statistics(sf)))
sf.message_id = None
aggregate = [self.Aggregate(func='stddev', param='test')]
self.assertRaisesWithMessage("Aggregate function(s) ['stddev']"
" not implemented",
ceilometer.NotImplementedError,
lambda: list(
conn.get_meter_statistics(
sf, aggregate=aggregate)))
def test_unique_metrics_list_call(self):
dummy_metric_names_mocked_return_value = ([{
"id": "015c995b1a770147f4ef18f5841ef566ab33521d",
"name": "network.delete"
}, {
"id": "335b5d569ad29dc61b3dc24609fad3619e947944",
"name": "subnet.update"
}])
with mock.patch('ceilometer.monasca_client.Client') as mock_client:
conn = impl_monasca.Connection('127.0.0.1:8080')
metric_names_list_mock = mock_client().metric_names_list
metric_names_list_mock.return_value = (
dummy_metric_names_mocked_return_value)
kwargs = dict(user='******',
project='project-1',
resource='resource-1',
source='openstack',
limit=2,
unique=True)
self.assertEqual(2, len(list(conn.get_meters(**kwargs))))
self.assertEqual(True, metric_names_list_mock.called)
self.assertEqual(1, metric_names_list_mock.call_count)
self.assertEqual(
dict(dimensions=dict(user_id='user-1',
project_id='project-1',
resource_id='resource-1',
source='openstack')),
metric_names_list_mock.call_args[1])
def test_get_resources_limit(self, mdf_mock):
with mock.patch("ceilometer.monasca_client.Client") as mock_client:
conn = impl_monasca.Connection("127.0.0.1:8080")
mnl_mock = mock_client().metrics_list
mnl_mock.return_value = [{'name': 'metric1',
'dimensions': {'resource_id': 'abcd'}},
{'name': 'metric2',
'dimensions': {'resource_id': 'abcd'}}
]
dummy_get_resources_mocked_return_value = (
[{u'dimensions': {u'resource_id': u'abcd'},
u'measurements': [[u'2015-04-14T17:52:31Z', 1.0, {}],
[u'2015-04-15T17:52:31Z', 2.0, {}],
[u'2015-04-16T17:52:31Z', 3.0, {}]],
u'id': u'2015-04-14T18:42:31Z',
u'columns': [u'timestamp', u'value', u'value_meta'],
u'name': u'image'}])
ml_mock = mock_client().measurements_list
ml_mock.return_value = (
TestGetSamples.dummy_metrics_mocked_return_value
)
ml_mock = mock_client().measurements_list
ml_mock.return_value = (
dummy_get_resources_mocked_return_value)
sample_filter = storage.SampleFilter(
meter='specific meter', end_timestamp='2015-04-20T00:00:00Z')
resources = list(conn.get_resources(sample_filter, limit=2))
self.assertEqual(2, len(resources))
self.assertEqual(True, ml_mock.called)
self.assertEqual(2, ml_mock.call_count)
def test_stats_list(self):
with mock.patch("ceilometer.monasca_client.Client") as mock_client:
conn = impl_monasca.Connection("127.0.0.1:8080")
sl_mock = mock_client().statistics_list
sl_mock.return_value = [{
'statistics': [['2014-10-24T12:12:12Z', 0.008],
['2014-10-24T12:52:12Z', 0.018]],
'dimensions': {
'unit': 'gb'
},
'columns': ['timestamp', 'min']
}]
sf = storage.SampleFilter()
sf.meter = "image"
aggregate = Aggregate()
aggregate.func = 'min'
sf.start_timestamp = timeutils.parse_isotime(
'2014-10-24T12:12:42').replace(tzinfo=None)
stats = list(
conn.get_meter_statistics(sf, aggregate=[aggregate],
period=30))
self.assertEqual(2, len(stats))
self.assertEqual('gb', stats[0].unit)
self.assertEqual('gb', stats[1].unit)
self.assertEqual(0.008, stats[0].min)
self.assertEqual(0.018, stats[1].min)
self.assertEqual(30, stats[0].period)
self.assertEqual('2014-10-24T12:12:42',
stats[0].period_end.isoformat())
self.assertEqual('2014-10-24T12:52:42',
stats[1].period_end.isoformat())
self.assertIsNotNone(stats[0].as_dict().get('aggregate'))
self.assertEqual({u'min': 0.008}, stats[0].as_dict()['aggregate'])
def test_get_samples_timestamp_filter_exclusive_range(self):
with mock.patch("ceilometer.monasca_client.Client") as mock_client:
conn = impl_monasca.Connection("127.0.0.1:8080")
metrics_list_mock = mock_client().metrics_list
metrics_list_mock.return_value = (
TestGetSamples.dummy_metrics_mocked_return_value)
ml_mock = mock_client().measurements_list
ml_mock.return_value = (
TestGetSamples.dummy_get_samples_mocked_return_value)
start_time = datetime.datetime(2015, 3, 20)
end_time = datetime.datetime(2015, 4, 1, 12, 00, 00)
sample_filter = storage.SampleFilter(
meter='specific meter',
start_timestamp=timeutils.isotime(start_time),
start_timestamp_op='gt',
end_timestamp=timeutils.isotime(end_time),
end_timestamp_op='lt')
list(conn.get_samples(sample_filter))
self.assertEqual(True, ml_mock.called)
self.assertEqual(1, ml_mock.call_count)
self.assertEqual(
dict(dimensions=dict(datasource='ceilometer'),
name='specific meter',
start_time='2015-03-20T00:00:00.001000Z',
end_time='2015-04-01T11:59:59.999000Z',
start_timestamp_op='ge',
end_timestamp_op='le',
group_by='*'), ml_mock.call_args_list[0][1])
def test_stats_list_called_with(self, mock_mdf):
with mock.patch("ceilometer.monasca_client.Client") as mock_client:
conn = impl_monasca.Connection("127.0.0.1:8080")
sl_mock = mock_client().statistics_list
sf = storage.SampleFilter()
sf.meter = "image"
sf.project = "project_id"
sf.user = "******"
sf.resource = "resource_id"
sf.source = "source_id"
aggregate = [self.Aggregate(func="min", param="some")]
list(conn.get_meter_statistics(sf, period=10, aggregate=aggregate))
self.assertEqual(True, sl_mock.called)
self.assertEqual(
{
'merge_metrics': True,
'dimensions': {
'source': 'source_id',
'project_id': 'project_id',
'user_id': 'user_id',
'resource_id': 'resource_id'
},
'start_time': '1970-01-01T00:00:00Z',
'period': 10,
'statistics': 'min',
'name': 'image'
}, sl_mock.call_args[1])
def test_stats_list(self, mock_mdf):
with mock.patch("ceilometer.monasca_client.Client") as mock_client:
conn = impl_monasca.Connection("127.0.0.1:8080")
sl_mock = mock_client().statistics_list
sl_mock.return_value = [{
'statistics': [['2014-10-24T12:12:12Z', 0.008],
['2014-10-24T12:52:12Z', 0.018]],
'dimensions': {
'unit': 'gb'
},
'columns': ['timestamp', 'min']
}]
sf = storage.SampleFilter()
sf.meter = "image"
stats = list(conn.get_meter_statistics(sf, period=30))
self.assertEqual(2, len(stats))
self.assertEqual('gb', stats[0].unit)
self.assertEqual('gb', stats[1].unit)
self.assertEqual(0.008, stats[0].min)
self.assertEqual(0.018, stats[1].min)
self.assertEqual(30, stats[0].period)
self.assertEqual('2014-10-24T12:12:42+00:00',
stats[0].period_end.isoformat())
self.assertEqual('2014-10-24T12:52:42+00:00',
stats[1].period_end.isoformat())
def test_get_meter_for_mapped_meters_non_uniq(self, mdf_mock):
data1 = ([{
u'dimensions': {
u'datasource': u'ceilometer'
},
u'id': u'2015-04-14T18:42:31Z',
u'name': u'meter-1'
}, {
u'dimensions': {
u'datasource': u'ceilometer'
},
u'id': u'2015-04-15T18:42:31Z',
u'name': u'meter-1'
}])
data2 = ([{
u'dimensions': {
u'datasource': u'ceilometer'
},
u'id': u'2015-04-14T18:42:31Z',
u'name': u'meter-1'
}, {
u'dimensions': {
u'datasource': u'ceilometer'
},
u'id': u'2015-04-15T18:42:31Z',
u'name': u'meter-1'
}, {
u'id': u'fef26f9d27f8027ea44b940cf3626fc398f7edfb',
u'name': u'fake_metric',
u'dimensions': {
u'resource_id': u'2fe6e3a9-9bdf-4c98-882c-a826cf0107a1',
u'cloud_name': u'helion-poc-hlm-003',
u'component': u'vm',
u'control_plane': u'control-plane-1',
u'service': u'compute',
u'device': u'tap3356676e-a5',
u'tenant_id': u'50ce24dd577c43879cede72b77224e2f',
u'hostname': u'hlm003-cp1-comp0003-mgmt',
u'cluster': u'compute',
u'zone': u'nova'
}
}, {
u'dimensions': {},
u'id': u'2015-04-16T18:42:31Z',
u'name': u'testbatch'
}])
with mock.patch("ceilometer.monasca_client.Client") as mock_client:
conn = impl_monasca.Connection("127.0.0.1:8080")
metrics_list_mock = mock_client().metrics_list
metrics_list_mock.side_effect = [data1, data2]
kwargs = dict(limit=4)
results = list(conn.get_meters(**kwargs))
# result contains 2 records from data 1 since datasource
# = ceilometer, 2 records from data 2, 1 for pipeline
# meter but no datasource set to ceilometer and one for
# mapped meter
self.assertEqual(4, len(results))
self.assertEqual(True, metrics_list_mock.called)
self.assertEqual(2, metrics_list_mock.call_count)
def test_get_samples_results(self, mdf_mock):
with mock.patch("ceilometer.monasca_client.Client") as mock_client:
conn = impl_monasca.Connection("127.0.0.1:8080")
ml_mock = mock_client().measurements_list
ml_mock.return_value = ([{
u'dimensions': {
'source': 'some source',
'project_id': 'some project ID',
'resource_id': 'some resource ID',
'type': 'some type',
'unit': 'some unit'
},
u'measurements': [[u'2015-04-01T02:03:04Z', 1.0, {}],
[u'2015-04-11T22:33:44Z', 2.0, {}]],
u'id':
u'2015-04-14T18:42:31Z',
u'columns': [u'timestamp', u'value', u'value_meta'],
u'name':
u'image'
}])
sample_filter = storage.SampleFilter(
meter='specific meter', start_timestamp='2015-03-20T00:00:00Z')
results = list(conn.get_samples(sample_filter))
self.assertEqual(True, ml_mock.called)
self.assertEqual(results[0].counter_name,
ml_mock.return_value[0].get('name'))
self.assertEqual(
results[0].counter_type,
ml_mock.return_value[0].get('dimensions').get('type'))
self.assertEqual(
results[0].counter_unit,
ml_mock.return_value[0].get('dimensions').get('unit'))
self.assertEqual(results[0].counter_volume,
ml_mock.return_value[0].get('measurements')[0][1])
self.assertEqual(results[0].message_id,
ml_mock.return_value[0].get('id'))
self.assertEqual(results[0].message_signature, '')
self.assertEqual(
results[0].project_id,
ml_mock.return_value[0].get('dimensions').get('project_id'))
self.assertEqual(
results[0].recorded_at,
dateutil.parser.parse(
ml_mock.return_value[0].get('measurements')[0][0]))
self.assertEqual(
results[0].resource_id,
ml_mock.return_value[0].get('dimensions').get('resource_id'))
self.assertEqual(results[0].resource_metadata, {})
self.assertEqual(
results[0].source,
ml_mock.return_value[0].get('dimensions').get('source'))
self.assertEqual(
results[0].timestamp,
dateutil.parser.parse(
ml_mock.return_value[0].get('measurements')[0][0]))
self.assertEqual(results[0].user_id, None)
self.assertEqual(1, ml_mock.call_count)
def test_get_samples_not_implemented_params(self):
with mock.patch("ceilometer.monasca_client.Client"):
conn = impl_monasca.Connection("127.0.0.1:8080")
sample_filter = storage.SampleFilter(meter='specific meter',
message_id='specific message')
self.assertRaises(ceilometer.NotImplementedError,
lambda: list(conn.get_samples(sample_filter)))
def test_get_resources_simple_metaquery(self, mock_utcnow):
mock_utcnow.return_value = datetime.datetime(2016, 4, 7, 18, 28)
with mock.patch("ceilometer.monasca_client.Client") as mock_client:
conn = impl_monasca.Connection("127.0.0.1:8080")
mnl_mock = mock_client().metric_names_list
mnl_mock.return_value = [{
"id": "335b5d569ad29dc61b3dc24609fad3619e947944",
"name": "storage.objects.size"
}, {
"id": "335b5d569ad29dc61b3dc24609fad3619e947944",
"name": "vm.net.in_rate"
}]
kwargs = dict(metaquery={'metadata.key': 'value1'})
ml_mock = mock_client().measurements_list
data1 = ([{
u'dimensions': {
u'resource_id': u'abcd',
u'datasource': u'ceilometer'
},
u'measurements': [[u'2015-04-14T17:52:31Z', 1.0, {}],
[u'2015-04-15T17:52:31Z', 2.0, {}],
[u'2015-04-16T17:52:31Z', 3.0, {}]],
u'id':
u'2015-04-14T18:42:31Z',
u'columns': [u'timestamp', u'value', u'value_meta'],
u'name':
u'storage.objects.size'
}])
data2 = ([{
u'dimensions': {
u'resource_id': u'abcd',
u'datasource': u'ceilometer'
},
u'measurements': [[u'2015-04-14T17:52:31Z', 1.0, {}],
[u'2015-04-15T17:52:31Z', 2.0, {}],
[u'2015-04-16T17:52:31Z', 3.0, {}]],
u'id':
u'2015-04-14T18:42:31Z',
u'columns': [u'timestamp', u'value', u'value_meta'],
u'name':
u'vm.net.in_rate'
}])
ml_mock.side_effect = [data1, data2]
list(conn.get_resources(**kwargs))
self.assertEqual(2, ml_mock.call_count)
self.assertEqual(
dict(dimensions=dict(datasource='ceilometer'),
name="storage.objects.size",
start_time='1970-01-01T00:00:00.000000Z',
group_by='*',
end_time='2016-04-07T18:28:00.000000Z'),
ml_mock.call_args_list[0][1])
def test_not_implemented_params(self, mock_mdf):
with mock.patch("ceilometer.monasca_client.Client"):
conn = impl_monasca.Connection("127.0.0.1:8080")
kwargs = dict(start_timestamp_op='le')
self.assertRaises(ceilometer.NotImplementedError,
lambda: list(conn.get_resources(**kwargs)))
kwargs = dict(end_timestamp_op='ge')
self.assertRaises(ceilometer.NotImplementedError,
lambda: list(conn.get_resources(**kwargs)))
def test_stats_list_with_groupby(self):
with mock.patch("ceilometer.monasca_client.Client") as mock_client:
conn = impl_monasca.Connection("127.0.0.1:8080")
sl_mock = mock_client().statistics_list
sl_mock.return_value = [{
'statistics': [['2014-10-24T12:12:12Z', 0.008, 1.3, 3, 0.34],
['2014-10-24T12:20:12Z', 0.078, 1.25, 2, 0.21],
['2014-10-24T12:52:12Z', 0.018, 0.9, 4, 0.14]],
'dimensions': {
'project_id': '1234',
'unit': 'gb'
},
'columns': ['timestamp', 'min', 'max', 'count', 'avg']
}, {
'statistics': [['2014-10-24T12:14:12Z', 0.45, 2.5, 2, 2.1],
['2014-10-24T12:20:12Z', 0.58, 3.2, 3, 3.4],
['2014-10-24T13:52:42Z', 1.67, 3.5, 1, 5.3]],
'dimensions': {
'project_id': '5678',
'unit': 'gb'
},
'columns': ['timestamp', 'min', 'max', 'count', 'avg']
}]
sf = storage.SampleFilter()
sf.meter = "image"
sf.start_timestamp = timeutils.parse_isotime(
'2014-10-24T12:12:42').replace(tzinfo=None)
groupby = ['project_id']
stats = list(
conn.get_meter_statistics(sf, period=30, groupby=groupby))
self.assertEqual(2, len(stats))
for stat in stats:
self.assertIsNotNone(stat.groupby)
project_id = stat.groupby.get('project_id')
self.assertIn(project_id, ['1234', '5678'])
if project_id == '1234':
self.assertEqual(0.008, stat.min)
self.assertEqual(1.3, stat.max)
self.assertEqual(0.23, stat.avg)
self.assertEqual(9, stat.count)
self.assertEqual(30, stat.period)
self.assertEqual('2014-10-24T12:12:12',
stat.period_start.isoformat())
if project_id == '5678':
self.assertEqual(0.45, stat.min)
self.assertEqual(3.5, stat.max)
self.assertEqual(3.6, stat.avg)
self.assertEqual(6, stat.count)
self.assertEqual(30, stat.period)
self.assertEqual('2014-10-24T13:52:42',
stat.period_end.isoformat())
def test_dims_filter(self, mdf_patch):
with mock.patch("ceilometer.monasca_client.Client") as mock_client:
conn = impl_monasca.Connection("127.0.0.1:8080")
mnl_mock = mock_client().metrics_list
mnl_mock.return_value = [{'name': 'some', 'dimensions': {}}]
kwargs = dict(project='proj1')
list(conn.get_resources(**kwargs))
self.assertEqual(True, mnl_mock.called)
self.assertEqual(dict(dimensions=dict(project_id='proj1')),
mnl_mock.call_args[1])
self.assertEqual(1, mnl_mock.call_count)
def test_query_samples_timestamp_gt_lt(self):
SAMPLES = [[
storage_models.Sample(
counter_name="instance",
counter_type="gauge",
counter_unit="instance",
counter_volume=1,
project_id="123",
user_id="456",
resource_id="789",
resource_metadata={},
source="openstack",
recorded_at=timeutils.utcnow(),
timestamp=timeutils.utcnow(),
message_id="0",
message_signature='',
)
]] * 2
samples = SAMPLES[:]
def _get_samples(*args, **kwargs):
return samples.pop()
with mock.patch("ceilometer.monasca_client.Client"):
conn = impl_monasca.Connection("127.0.0.1:8080")
with mock.patch.object(conn, 'get_samples') as gsm:
gsm.side_effect = _get_samples
start = datetime.datetime(2014, 10, 24, 13, 52, 42)
end = datetime.datetime(2014, 10, 24, 14, 52, 42)
ts_query = {
'or': [{
'>': {
"timestamp": start
}
}, {
'<': {
"timestamp": end
}
}]
}
query = {
'and': [{
'=': {
'counter_name': 'instance'
}
}, ts_query]
}
samples = conn.query_samples(query, None, 100)
self.assertEqual(2, len(samples))
self.assertEqual(2, gsm.call_count)
def test_get_samples_simple_metaquery(self):
with mock.patch("ceilometer.monasca_client.Client") as mock_client:
conn = impl_monasca.Connection("127.0.0.1:8080")
metrics_list_mock = mock_client().metrics_list
metrics_list_mock.return_value = (
TestGetSamples.dummy_metrics_mocked_return_value)
ml_mock = mock_client().measurements_list
ml_mock.return_value = (
TestGetSamples.dummy_get_samples_mocked_return_value)
sample_filter = storage.SampleFilter(
meter='specific meter', metaquery={'metadata.key': u'value'})
list(conn.get_samples(sample_filter))
self.assertEqual(True, ml_mock.called)
self.assertEqual(1, ml_mock.call_count)
def test_get_samples_simple_metaquery(self, mdf_mock):
with mock.patch("ceilometer.monasca_client.Client") as mock_client:
conn = impl_monasca.Connection("127.0.0.1:8080")
ml_mock = mock_client().measurements_list
ml_mock.return_value = (
TestGetSamples.dummy_get_samples_mocked_return_value)
sample_filter = storage.SampleFilter(
meter='specific meter', metaquery={'metadata.key': u'value'})
list(conn.get_samples(sample_filter))
self.assertEqual(True, ml_mock.called)
self.assertEqual(
dict(dimensions={},
start_time='1970-01-01T00:00:00Z',
merge_metrics=True,
name='specific meter'), ml_mock.call_args[1])
self.assertEqual(1, ml_mock.call_count)
def test_metrics_list_call(self):
with mock.patch('ceilometer.monasca_client.Client') as mock_client:
conn = impl_monasca.Connection('127.0.0.1:8080')
metrics_list_mock = mock_client().metrics_list
kwargs = dict(user='******',
project='project-1',
resource='resource-1',
source='openstack',
limit=100)
list(conn.get_meters(**kwargs))
self.assertEqual(True, metrics_list_mock.called)
self.assertEqual(4, metrics_list_mock.call_count)
expected = [
mock.call(
dimensions={
'source': 'openstack',
'project_id': 'project-1',
'user_id': 'user-1',
'datasource': 'ceilometer',
'resource_id': 'resource-1'
}),
mock.call(
dimensions={
'source': 'openstack',
'project_id': 'project-1',
'user_id': 'user-1',
'resource_id': 'resource-1'
}),
mock.call(
dimensions={
'source': 'openstack',
'tenant_id': 'project-1',
'user_id': 'user-1',
'resource_id': 'resource-1'
}),
mock.call(
dimensions={
'source': 'openstack',
'project_id': 'project-1',
'user_id': 'user-1',
'hostname': 'resource-1'
})
]
self.assertTrue(expected == metrics_list_mock.call_args_list)
def test_get_samples_resource_filter(self, mock_mdf):
with mock.patch("ceilometer.monasca_client.Client") as mock_client:
conn = impl_monasca.Connection("127.0.0.1:8080")
ml_mock = mock_client().measurements_list
ml_mock.return_value = (
TestGetSamples.dummy_get_samples_mocked_return_value)
sample_filter = storage.SampleFilter(meter='specific meter',
resource='specific resource')
list(conn.get_samples(sample_filter))
self.assertEqual(True, ml_mock.called)
self.assertEqual(
dict(start_time='1970-01-01T00:00:00Z',
merge_metrics=True,
name='specific meter',
dimensions=dict(resource_id=sample_filter.resource)),
ml_mock.call_args[1])
self.assertEqual(1, ml_mock.call_count)
def test_get_samples_source_filter(self, mdf_mock):
with mock.patch("ceilometer.monasca_client.Client") as mock_client:
conn = impl_monasca.Connection("127.0.0.1:8080")
metrics_list_mock = mock_client().metrics_list
metrics_list_mock.return_value = (
[{u'dimensions': dict(source='specific source'),
u'id': u'2015-04-14T18:42:31Z',
u'name': u'specific meter'}]
)
ml_mock = mock_client().measurements_list
ml_mock.return_value = (
TestGetSamples.dummy_get_samples_mocked_return_value)
sample_filter = storage.SampleFilter(meter='specific meter',
source='specific source')
list(conn.get_samples(sample_filter))
self.assertEqual(True, ml_mock.called)
self.assertEqual(1, ml_mock.call_count)
def test_get_meter_for_mapped_meters_uniq(self, mdf_mock):
dummy_metric_names_mocked_return_value = ([{
"id": "015c995b1a770147f4ef18f5841ef566ab33521d",
"name": "network.delete"
}, {
"id": "335b5d569ad29dc61b3dc24609fad3619e947944",
"name": "subnet.update"
}])
with mock.patch("ceilometer.monasca_client.Client") as mock_client:
conn = impl_monasca.Connection("127.0.0.1:8080")
metric_names_list_mock = mock_client().metric_names_list
metric_names_list_mock.return_value = (
dummy_metric_names_mocked_return_value)
kwargs = dict(limit=4, unique=True)
results = list(conn.get_meters(**kwargs))
self.assertEqual(2, len(results))
self.assertEqual(True, metric_names_list_mock.called)
self.assertEqual(1, metric_names_list_mock.call_count)
def test_query_samples_not_implemented_params(self):
with mock.patch("ceilometer.monasca_client.Client"):
conn = impl_monasca.Connection("127.0.0.1:8080")
query = {
'and': [{
'=': {
'counter_name': 'instance'
}
}, {
'or': [{
'=': {
"project_id": "123"
}
}, {
'=': {
"user_id": "456"
}
}]
}]
}
self.assertRaisesWithMessage('filter must be specified',
ceilometer.NotImplementedError,
lambda: list(conn.query_samples()))
order_by = [{"timestamp": "desc"}]
self.assertRaisesWithMessage(
'orderby is not supported', ceilometer.NotImplementedError,
lambda: list(conn.query_samples(query, order_by)))
query = {
'or': [{
'=': {
"project_id": "123"
}
}, {
'=': {
"user_id": "456"
}
}]
}
self.assert_raise_within_message(
'meter name is not found in',
impl_monasca.InvalidInputException,
lambda: list(conn.query_samples(query, None, 1)))
def test_get_samples_start_timestamp_filter(self, mdf_mock):
with mock.patch("ceilometer.monasca_client.Client") as mock_client:
conn = impl_monasca.Connection("127.0.0.1:8080")
ml_mock = mock_client().measurements_list
ml_mock.return_value = (
TestGetSamples.dummy_get_samples_mocked_return_value)
sample_filter = storage.SampleFilter(
meter='specific meter',
start_timestamp='2015-03-20T00:00:00Z',
start_timestamp_op='ge')
list(conn.get_samples(sample_filter))
self.assertEqual(True, ml_mock.called)
self.assertEqual(
dict(dimensions={},
start_time=str(sample_filter.start_timestamp),
start_timestamp_op=sample_filter.start_timestamp_op,
merge_metrics=True,
name='specific meter'), ml_mock.call_args[1])
self.assertEqual(1, ml_mock.call_count)
def test_dims_filter(self):
with mock.patch("ceilometer.monasca_client.Client") as mock_client:
conn = impl_monasca.Connection("127.0.0.1:8080")
mnl_mock = mock_client().metric_names_list
mnl_mock.return_value = [{
"id": "335b5d569ad29dc61b3dc24609fad3619e947944",
"name": "some"
}]
end_time = datetime.datetime(2015, 4, 1, 12, 00, 00)
kwargs = dict(project='proj1', end_timestamp=end_time)
list(conn.get_resources(**kwargs))
self.assertEqual(True, mnl_mock.called)
expected = [
mock.call(dimensions={'project_id': 'proj1'}),
mock.call(dimensions={'tenant_id': 'proj1'})
]
self.assertTrue(expected == mnl_mock.call_args_list)
self.assertEqual(2, mnl_mock.call_count)
def test_get_samples_start_timestamp_filter(self):
with mock.patch("ceilometer.monasca_client.Client") as mock_client:
conn = impl_monasca.Connection("127.0.0.1:8080")
metrics_list_mock = mock_client().metrics_list
metrics_list_mock.return_value = (
TestGetSamples.dummy_metrics_mocked_return_value)
ml_mock = mock_client().measurements_list
ml_mock.return_value = (
TestGetSamples.dummy_get_samples_mocked_return_value)
start_time = datetime.datetime(2015, 3, 20)
sample_filter = storage.SampleFilter(
meter='specific meter',
start_timestamp=timeutils.isotime(start_time),
start_timestamp_op='ge')
list(conn.get_samples(sample_filter))
self.assertEqual(True, ml_mock.called)
self.assertEqual(1, ml_mock.call_count)
def test_get_resources(self, mock_mdf):
with mock.patch("ceilometer.monasca_client.Client") as mock_client:
conn = impl_monasca.Connection("127.0.0.1:8080")
mnl_mock = mock_client().metrics_list
mnl_mock.return_value = [{'name': 'metric1',
'dimensions': {}},
{'name': 'metric2',
'dimensions': {}}
]
kwargs = dict(source='openstack')
ml_mock = mock_client().measurements_list
ml_mock.return_value = (
TestGetResources.dummy_get_resources_mocked_return_value)
list(conn.get_resources(**kwargs))
self.assertEqual(2, ml_mock.call_count)
self.assertEqual(dict(dimensions={},
name='metric1',
limit=1,
start_time='1970-01-01T00:00:00Z'),
ml_mock.call_args_list[0][1])
def test_get_samples_name(self):
with mock.patch("ceilometer.monasca_client.Client") as mock_client:
conn = impl_monasca.Connection("127.0.0.1:8080")
metrics_list_mock = mock_client().metrics_list
metrics_list_mock.return_value = (
TestGetSamples.dummy_metrics_mocked_return_value)
ml_mock = mock_client().measurements_list
ml_mock.return_value = (
TestGetSamples.dummy_get_samples_mocked_return_value)
sample_filter = storage.SampleFilter(
meter='specific meter', end_timestamp='2015-04-20T00:00:00Z')
list(conn.get_samples(sample_filter))
self.assertEqual(True, ml_mock.called)
self.assertEqual(
dict(dimensions=dict(datasource='ceilometer'),
start_time='1970-01-01T00:00:00.000000Z',
group_by='*',
name='specific meter',
end_time='2015-04-20T00:00:00.000000Z'),
ml_mock.call_args[1])
self.assertEqual(1, ml_mock.call_count)
def test_metrics_list_call(self, mock_mdf):
with mock.patch('ceilometer.monasca_client.Client') as mock_client:
conn = impl_monasca.Connection('127.0.0.1:8080')
metrics_list_mock = mock_client().metrics_list
kwargs = dict(user='******',
project='project-1',
resource='resource-1',
source='openstack',
limit=100)
list(conn.get_meters(**kwargs))
self.assertEqual(True, metrics_list_mock.called)
self.assertEqual(1, metrics_list_mock.call_count)
self.assertEqual(
dict(dimensions=dict(user_id='user-1',
project_id='project-1',
resource_id='resource-1',
source='openstack'),
limit=100), metrics_list_mock.call_args[1])
