def test_sample_filter_timestamp(self):
ts_start = timeutils.utcnow()
ts_end = ts_start + datetime.timedelta(minutes=5)
q = [
v2_base.Query(field='timestamp', op='lt', value=str(ts_end)),
v2_base.Query(field='timestamp', op='gt', value=str(ts_start))
]
kwargs = utils.query_to_kwargs(q, storage.SampleFilter.__init__)
self.assertEqual(4, len(kwargs))
self.assertTimestampEqual(kwargs['start_timestamp'], ts_start)
self.assertTimestampEqual(kwargs['end_timestamp'], ts_end)
self.assertEqual('gt', kwargs['start_timestamp_op'])
self.assertEqual('lt', kwargs['end_timestamp_op'])
def test_sample_filter_non_equality_on_metadata(self):
queries = [
v2_base.Query(field='resource_metadata.image_id',
op='gt',
value='image',
type='string'),
v2_base.Query(field='metadata.ramdisk_id',
op='le',
value='ramdisk',
type='string')
]
with mock.patch('pecan.request') as request:
request.headers.return_value = {'X-ProjectId': 'foobar'}
self.assertRaises(wsme.exc.InvalidInput, utils.query_to_kwargs,
queries, storage.SampleFilter.__init__)
def test_sample_filter_multi(self):
q = [
v2_base.Query(field='user_id', op='eq', value='uid'),
v2_base.Query(field='project_id', op='eq', value='pid'),
v2_base.Query(field='resource_id', op='eq', value='rid'),
v2_base.Query(field='source', op='eq', value='source_name'),
v2_base.Query(field='meter', op='eq', value='meter_name')
]
kwargs = utils.query_to_kwargs(q, storage.SampleFilter.__init__)
self.assertEqual(5, len(kwargs))
self.assertEqual('uid', kwargs['user'])
self.assertEqual('pid', kwargs['project'])
self.assertEqual('rid', kwargs['resource'])
self.assertEqual('source_name', kwargs['source'])
self.assertEqual('meter_name', kwargs['meter'])
def test_get_value_as_type_with_string(self):
query = v2_base.Query(field='metadata.name',
op='eq',
value='linux',
type='string')
expected = 'linux'
self.assertEqual(expected, query._get_value_as_type())
def test_get_value_as_type_with_datetime(self):
query = v2_base.Query(field='metadata.date',
op='eq',
value='2014-01-01T05:00:00',
type='datetime')
self.assertIsInstance(query._get_value_as_type(), datetime.datetime)
self.assertIsNone(query._get_value_as_type().tzinfo)
def test_sample_filter_self_always_excluded(self):
queries = [v2_base.Query(field='user_id', op='eq', value='20')]
with mock.patch('pecan.request') as request:
request.headers.return_value = {'X-ProjectId': 'foobar'}
kwargs = utils.query_to_kwargs(queries,
storage.SampleFilter.__init__)
self.assertNotIn('self', kwargs)
def test_get_value_as_type_with_integer(self):
query = v2_base.Query(field='metadata.size',
op='eq',
value='123',
type='integer')
expected = 123
self.assertEqual(expected, query._get_value_as_type())
def test_get_value_as_type_integer_expression_without_type(self):
# bug 1221736
query = v2_base.Query(field='should_be_a_string',
op='eq',
value='WWW-Layer-4a80714f')
expected = 'WWW-Layer-4a80714f'
self.assertEqual(expected, query._get_value_as_type())
def test_get_value_as_type_with_boolean(self):
query = v2_base.Query(field='metadata.is_public',
op='eq',
value='True',
type='boolean')
expected = True
self.assertEqual(expected, query._get_value_as_type())
def test_get_value_as_type_with_float(self):
query = v2_base.Query(field='metadata.size',
op='eq',
value='123.456',
type='float')
expected = 123.456
self.assertEqual(expected, query._get_value_as_type())
def test_sample_filter_invalid_op(self):
q = [v2_base.Query(field='user_id',
op='lt',
value='20')]
self.assertRaises(
wsme.exc.InvalidInput,
utils.query_to_kwargs, q, storage.SampleFilter.__init__)
def test_sample_filter_invalid_field(self):
q = [v2_base.Query(field='invalid',
op='eq',
value='20')]
self.assertRaises(
wsme.exc.UnknownArgument,
utils.query_to_kwargs, q, storage.SampleFilter.__init__)
def test_get_value_as_type_boolean_expression_without_type(self):
# bug 1221736
query = v2_base.Query(field='should_be_a_string',
op='eq',
value='True or False')
expected = 'True or False'
self.assertEqual(expected, query._get_value_as_type())
def test_sample_filter_timestamp_invalid_op(self):
ts_start = timeutils.utcnow()
q = [v2_base.Query(field='timestamp',
op='eq',
value=str(ts_start))]
self.assertRaises(
wsme.exc.InvalidInput,
utils.query_to_kwargs, q, storage.SampleFilter.__init__)
def test_sample_filter_single(self):
q = [v2_base.Query(field='user_id',
op='eq',
value='uid')]
kwargs = utils.query_to_kwargs(q, storage.SampleFilter.__init__)
self.assertIn('user', kwargs)
self.assertEqual(1, len(kwargs))
self.assertEqual('uid', kwargs['user'])
def test_get_value_as_type_with_syntax_error(self):
# bug 1221736
value = 'WWW-Layer-4a80714f-0232-4580-aa5e-81494d1a4147-uolhh25p5xxm'
query = v2_base.Query(field='group_id',
op='eq',
value=value)
expected = value
self.assertEqual(expected, query._get_value_as_type())
def test_get_value_as_type_with_syntax_error_colons(self):
# bug 1221736
value = 'Ref::StackId'
query = v2_base.Query(field='field_name',
op='eq',
value=value)
expected = value
self.assertEqual(expected, query._get_value_as_type())
def test_timestamp_validation(self):
q = [v2_base.Query(field='timestamp', op='le', value='123')]
exc = self.assertRaises(wsme.exc.InvalidInput, utils.query_to_kwargs,
q, storage.SampleFilter.__init__)
expected_exc = wsme.exc.InvalidInput('timestamp', '123',
'invalid timestamp format')
self.assertEqual(str(expected_exc), str(exc))
def test_sample_filter_translation(self):
queries = [
v2_base.Query(field=f, op='eq', value='fake_%s' % f, type='string')
for f in ['user_id', 'project_id', 'resource_id']
]
with mock.patch('pecan.request') as request:
request.headers.return_value = {'X-ProjectId': 'foobar'}
kwargs = utils.query_to_kwargs(queries,
storage.SampleFilter.__init__)
for o in ['user', 'project', 'resource']:
self.assertEqual('fake_%s_id' % o, kwargs.get(o))
def test_sample_filter_exclude_internal(self):
queries = [
v2_base.Query(field=f, op='eq', value='fake', type='string')
for f in ['y', 'on_behalf_of', 'x']
]
with mock.patch('pecan.request') as request:
request.headers.return_value = {'X-ProjectId': 'foobar'}
self.assertRaises(wsme.exc.ClientSideError,
utils.query_to_kwargs,
queries,
storage.SampleFilter.__init__,
internal_keys=['on_behalf_of'])
def test_get_alarms_filter_valid_fields(self):
q = [v2_base.Query(field='abc', op='eq', value='abc')]
exc = self.assertRaises(wsme.exc.UnknownArgument,
utils.query_to_kwargs, q,
alarm_storage_base.Connection.get_alarms)
valid_keys = [
'alarm_id', 'enabled', 'exclude', 'meter', 'name', 'project',
'severity', 'state', 'type', 'user'
]
msg = ("unrecognized field in query: %s, "
"valid keys: %s") % (q, valid_keys)
expected_exc = wsme.exc.UnknownArgument('abc', msg)
self.assertEqual(str(expected_exc), str(exc))
def sanitize_query(query, db_func, on_behalf_of=None):
"""Check the query.
See if:
1) the request is coming from admin - then allow full visibility
2) non-admin - make sure that the query includes the requester's project.
"""
q = copy.copy(query)
auth_project = get_auth_project(on_behalf_of)
if auth_project:
_verify_query_segregation(q, auth_project)
proj_q = [i for i in q if i.field == 'project_id']
valid_keys = inspect.getargspec(db_func)[0]
if not proj_q and 'on_behalf_of' not in valid_keys:
# The user is restricted, but they didn't specify a project
# so add it for them.
q.append(
base.Query(field='project_id', op='eq', value=auth_project))
return q
def __init__(self, query=None, **kwargs):
query = [base.Query(**q) for q in query] if query else []
super(AlarmThresholdRule, self).__init__(query=query, **kwargs)
def test_get_value_as_type_with_bad_value(self):
query = v2_base.Query(field='metadata.size',
op='eq',
value='fake',
type='integer')
self.assertRaises(wsme.exc.ClientSideError, query._get_value_as_type)
def test_get_alarms_filter_valid_fields(self):
q = [v2_base.Query(field='abc', op='eq', value='abc')]
self.assertRaises(wsme.exc.UnknownArgument, utils.query_to_kwargs, q,
alarm_storage_base.Connection.get_alarms)
def test_get_value_with_bad_type(self):
query = v2_base.Query(field='metadata.size',
op='eq',
value='123.456',
type='blob')
self.assertRaises(wsme.exc.ClientSideError, query.get_value)
def __init__(self, event_type=None, query=None):
event_type = event_type or '*'
query = [base.Query(**q) for q in query or []]
super(AlarmEventRule, self).__init__(event_type=event_type,
query=query)
def get_all(self, q=None, sort=None, limit=None, marker=None):
"""Return all alarms, based on the query provided.
:param q: Filter rules for the alarms to be returned.
:param sort: A list of pairs of sort key and sort dir.
:param limit: The maximum number of items to be return.
:param marker: The pagination query marker.
"""
target = rbac.target_from_segregation_rule(pecan.request.headers,
pecan.request.enforcer)
rbac.enforce('get_alarms', pecan.request.headers,
pecan.request.enforcer, target)
q = q or []
filters = {}
# Check field
keys = set([query.field for query in q])
if not keys.issubset(ALARM_QUERY_FIELDS_ALLOWED):
raise wsme.exc.InvalidInput(
'field', keys,
'only fields %s are allowed' % ALARM_QUERY_FIELDS_ALLOWED)
# Check op
ops = set([query.op for query in q])
if any([op not in ALARM_QUERY_OPS_ALLOWED for op in ops]):
raise wsme.exc.InvalidInput(
'op', ops,
'only operations %s are allowed' % ALARM_QUERY_OPS_ALLOWED)
if 'all_projects' in keys:
if v2_utils.get_query_value(q, 'all_projects', 'boolean'):
rbac.enforce('get_alarms:all_projects', pecan.request.headers,
pecan.request.enforcer, target)
keys.remove('all_projects')
else:
project_id = pecan.request.headers.get('X-Project-Id')
is_admin = rbac.is_admin(pecan.request.headers)
if not v2_utils.is_field_exist(q, 'project_id'):
q.append(
base.Query(field='project_id', op='eq', value=project_id))
keys.add('project_id')
else:
request_project = v2_utils.get_query_value(q, 'project_id')
if not is_admin and request_project != project_id:
raise base.ProjectNotAuthorized(request_project)
for query in q:
if query.field in keys:
filters[query.field] = {query.op: query.get_value(query.type)}
if sort or limit or marker:
filters['pagination'] = v2_utils.get_pagination_options(
sort, limit, marker, models.Alarm)
LOG.debug('Getting alarms from database, filters: %s', filters)
return [
Alarm.from_db_model_scrubbed(m)
for m in pecan.request.storage.get_alarms(**filters)
]
