def test_model_query_common(self, _project_filter, _read_deleted_filter):
_read_deleted_filter.return_value = self.session.query
_project_filter.return_value = self.session.query
utils.model_query(self.user_context, MyModel,
args=(MyModel.id,), session=self.session)
self.session.query.assert_called_with(MyModel.id)
_read_deleted_filter.assert_called_with(
self.session.query, MyModel, self.user_context.read_deleted)
_project_filter.assert_called_with(
self.session.query, MyModel, self.user_context, False)
def test_model_query_common(self, _project_filter, _read_deleted_filter):
_read_deleted_filter.return_value = self.session.query
_project_filter.return_value = self.session.query
utils.model_query(self.user_context,
MyModel,
args=(MyModel.id, ),
session=self.session)
self.session.query.assert_called_with(MyModel.id)
_read_deleted_filter.assert_called_with(self.session.query, MyModel,
self.user_context.read_deleted)
_project_filter.assert_called_with(self.session.query, MyModel,
self.user_context, False)
def test_context_show_deleted(self, _project_filter, _read_deleted_filter):
user_context = mock.MagicMock(is_admin=False, show_deleted='yes',
user_id=42, project_id=43)
delattr(user_context, 'read_deleted')
_read_deleted_filter.return_value = self.session.query
_project_filter.return_value = self.session.query
utils.model_query(user_context, MyModel,
args=(MyModel.id,), session=self.session)
self.session.query.assert_called_with(MyModel.id)
_read_deleted_filter.assert_called_with(
self.session.query, MyModel, user_context.show_deleted)
_project_filter.assert_called_with(
self.session.query, MyModel, user_context, False)
def test_project_filter_allow_none(self):
mock_query = utils.model_query(MyModelSoftDeletedProjectId, session=self.session, project_id=(10, None))
self.assertEqual(
str(mock_query.filter.call_args[0][0]),
"soft_deleted_project_id_test_model.project_id" " IN (:project_id_1, NULL)",
)
def get_metadata(self, name):
session = db.get_session()
q = utils.model_query(
models.StateInfo,
session)
q.filter(models.StateInfo.name == name)
return q.value(models.StateInfo.s_metadata)
def test_read_deleted_yes(self):
mock_query = utils.model_query(self.user_context,
MyModelSoftDeleted,
session=self.session,
read_deleted='yes')
self.assertEqual(mock_query.filter.call_count, 0)
def get_metadata(self, name):
session = db.get_session()
return utils.model_query(
models.StateInfo,
session
).filter_by(
name=name,
).value('s_metadata')
def list_services(self):
session = db.get_session()
q = utils.model_query(
models.ServiceToCollectorMapping,
session)
res = q.distinct().values(
models.ServiceToCollectorMapping.service)
return res
def get_state(self, name):
session = db.get_session()
try:
return bool(
utils.model_query(models.ModuleStateInfo, session).filter_by(
name=name, ).value('state'))
except sqlalchemy.orm.exc.NoResultFound:
return None
def get_metadata(self, name):
session = db.get_session()
return utils.model_query(
models.StateInfo,
session
).filter_by(
name=name,
).value('s_metadata')
def delete_mapping(self, service, field, key):
session = db.get_session()
field = self.get_field(service, field)
r = utils.model_query(models.HashMapMapping, session).filter_by(
field_id=field.id,
key=key,
).delete()
if not r:
raise api.NoSuchMapping(service, field, key)
def delete_field(self, service, field):
session = db.get_session()
service_db = self.get_service(service)
r = utils.model_query(models.HashMapField, session).filter_by(
service_id=service_db.id,
name=field,
).delete()
if not r:
raise api.NoSuchField(service, field)
def test_deleted_true(self):
mock_query = utils.model_query(
MyModelSoftDeleted, session=self.session, deleted=True)
deleted_filter = mock_query.filter.call_args[0][0]
self.assertEqual(str(deleted_filter),
'soft_deleted_test_model.deleted != :deleted_1')
self.assertEqual(deleted_filter.right.value,
MyModelSoftDeleted.__mapper__.c.deleted.default.arg)
def delete_mapping(self, service):
session = db.get_session()
q = utils.model_query(
models.ServiceToCollectorMapping,
session)
q = q.filter(models.ServiceToCollectorMapping.service == service)
r = q.delete()
if not r:
raise api.NoSuchMapping(service)
def delete_threshold(self, uuid):
session = db.get_session()
q = utils.model_query(
models.HashMapThreshold,
session)
q = q.filter(models.HashMapThreshold.threshold_id == uuid)
r = q.delete()
if not r:
raise api.NoSuchThreshold(uuid)
def test_context_show_deleted(self, _project_filter, _read_deleted_filter):
user_context = mock.MagicMock(is_admin=False,
show_deleted='yes',
user_id=42,
project_id=43)
delattr(user_context, 'read_deleted')
_read_deleted_filter.return_value = self.session.query
_project_filter.return_value = self.session.query
utils.model_query(user_context,
MyModel,
args=(MyModel.id, ),
session=self.session)
self.session.query.assert_called_with(MyModel.id)
_read_deleted_filter.assert_called_with(self.session.query, MyModel,
user_context.show_deleted)
_project_filter.assert_called_with(self.session.query, MyModel,
user_context, False)
def test_project_filter_allow_none(self):
mock_query = utils.model_query(MyModelSoftDeletedProjectId,
session=self.session,
project_id=(10, None))
self.assertEqual(
str(mock_query.filter.call_args[0][0]),
'soft_deleted_project_id_test_model.project_id'
' IN (:project_id_1, NULL)')
def delete_mapping(self, uuid):
session = db.get_session()
q = utils.model_query(
models.HashMapMapping,
session)
q = q.filter(models.HashMapMapping.mapping_id == uuid)
r = q.delete()
if not r:
raise api.NoSuchMapping(uuid)
def test_deleted_true(self):
mock_query = utils.model_query(
MyModelSoftDeleted, session=self.session, deleted=True)
deleted_filter = mock_query.filter.call_args[0][0]
self.assertEqual(str(deleted_filter),
'soft_deleted_test_model.deleted != :deleted_1')
self.assertEqual(deleted_filter.right.value,
MyModelSoftDeleted.__mapper__.c.deleted.default.arg)
def test_read_deleted_allow_none(self):
mock_query = utils.model_query(
self.user_context, MyModelSoftDeletedProjectId,
session=self.session, project_only='allow_none')
self.assertEqual(
str(mock_query.filter.call_args[0][0]),
'soft_deleted_project_id_test_model.project_id = :project_id_1 OR'
' soft_deleted_project_id_test_model.project_id IS NULL'
)
def test_project_filter(self):
project_id = 10
mock_query = utils.model_query(
MyModelSoftDeletedProjectId, session=self.session, project_only=True, project_id=project_id
)
deleted_filter = mock_query.filter.call_args[0][0]
self.assertEqual(str(deleted_filter), "soft_deleted_project_id_test_model.project_id = :project_id_1")
self.assertEqual(deleted_filter.right.value, project_id)
def test_read_deleted_allow_none(self):
mock_query = utils.model_query(self.user_context,
MyModelSoftDeletedProjectId,
session=self.session,
project_only='allow_none')
self.assertEqual(
str(mock_query.filter.call_args[0][0]),
'soft_deleted_project_id_test_model.project_id = :project_id_1 OR'
' soft_deleted_project_id_test_model.project_id IS NULL')
def test_read_deleted_no(self):
mock_query = utils.model_query(
self.user_context, MyModelSoftDeleted,
session=self.session, read_deleted='no')
deleted_filter = mock_query.filter.call_args[0][0]
self.assertEqual(str(deleted_filter),
'soft_deleted_test_model.deleted = :deleted_1')
self.assertEqual(deleted_filter.right.value,
MyModelSoftDeleted.__mapper__.c.deleted.default.arg)
def delete_service(self, service):
session = db.get_session()
r = utils.model_query(
models.HashMapService,
session
).filter_by(
name=service,
).delete()
if not r:
raise api.NoSuchService(service)
def test_project_only_true(self):
mock_query = utils.model_query(
self.user_context, MyModelSoftDeletedProjectId,
session=self.session, project_only=True)
deleted_filter = mock_query.filter.call_args[0][0]
self.assertEqual(
str(deleted_filter),
'soft_deleted_project_id_test_model.project_id = :project_id_1')
self.assertEqual(deleted_filter.right.value,
self.user_context.project_id)
def get_state(self, name):
session = db.get_session()
try:
q = utils.model_query(
models.ModuleStateInfo,
session)
q = q.filter(models.ModuleStateInfo.name == name)
res = q.value(models.ModuleStateInfo.state)
return bool(res)
except sqlalchemy.orm.exc.NoResultFound:
return None
def get_priority(self, name):
session = db.get_session()
q = utils.model_query(
models.ModuleStateInfo,
session)
q = q.filter(models.ModuleStateInfo.name == name)
res = q.value(models.ModuleStateInfo.priority)
if res:
return int(res)
else:
return 1
def get_mapping(self, service):
session = db.get_session()
try:
q = utils.model_query(
models.ServiceToCollectorMapping,
session)
q.filter(
models.ServiceToCollectorMapping.service == service)
return q.one()
except sqlalchemy.orm.exc.NoResultFound:
raise api.NoSuchMapping(service)
def set_metadata(self, name, metadata):
session = db.get_session()
try:
db_state = utils.model_query(models.StateInfo, session).filter_by(
name=name, ).with_lockmode('update').one()
db_state.s_metadata = metadata
except sqlalchemy.orm.exc.NoResultFound:
db_state = models.StateInfo(name=name, s_metadata=metadata)
session.add(db_state)
finally:
session.flush()
def get_state(self, name):
session = db.get_session()
try:
return bool(utils.model_query(
models.ModuleStateInfo,
session
).filter_by(
name=name,
).value('state'))
except sqlalchemy.orm.exc.NoResultFound:
return None
def test_read_deleted_no(self):
mock_query = utils.model_query(self.user_context,
MyModelSoftDeleted,
session=self.session,
read_deleted='no')
deleted_filter = mock_query.filter.call_args[0][0]
self.assertEqual(str(deleted_filter),
'soft_deleted_test_model.deleted = :deleted_1')
self.assertEqual(deleted_filter.right.value,
MyModelSoftDeleted.__mapper__.c.deleted.default.arg)
def get_previous_period(self, resource_id):
session = db.get_session()
q = utils.model_query(
models.RatedDataFrame,
session
)
q = q.filter(
models.RatedDataFrame.resource_id == resource_id
).filter(models.RatedDataFrame.user_id != 'unknown').order_by(sqlalchemy.desc(models.RatedDataFrame.end))
r = q.limit(1).all()
if r:
return r[0].to_cloudkitty()
def test_project_only_true(self):
mock_query = utils.model_query(self.user_context,
MyModelSoftDeletedProjectId,
session=self.session,
project_only=True)
deleted_filter = mock_query.filter.call_args[0][0]
self.assertEqual(
str(deleted_filter),
'soft_deleted_project_id_test_model.project_id = :project_id_1')
self.assertEqual(deleted_filter.right.value,
self.user_context.project_id)
def delete_mapping(self, service, field, key):
session = db.get_session()
field = self.get_field(service, field)
r = utils.model_query(
models.HashMapMapping,
session
).filter_by(
field_id=field.id,
key=key,
).delete()
if not r:
raise api.NoSuchMapping(service, field, key)
def set_state(self, name, state):
session = db.get_session()
with session.begin():
try:
q = utils.model_query(models.StateInfo, session).filter_by(
name=name, ).with_lockmode('update')
db_state = q.one()
db_state.state = state
except sqlalchemy.orm.exc.NoResultFound:
db_state = models.StateInfo(name=name, state=state)
session.add(db_state)
return bool(db_state.state)
def delete_field(self, service, field):
session = db.get_session()
service_db = self.get_service(service)
r = utils.model_query(
models.HashMapField,
session
).filter_by(
service_id=service_db.id,
name=field,
).delete()
if not r:
raise api.NoSuchField(service, field)
def delete_service(self, name=None, uuid=None):
session = db.get_session()
q = utils.model_query(
models.HashMapService,
session)
if name:
q = q.filter(models.HashMapService.name == name)
elif uuid:
q = q.filter(models.HashMapService.service_id == uuid)
else:
raise ValueError('You must specify either name or uuid.')
r = q.delete()
if not r:
raise api.NoSuchService(name, uuid)
def set_metadata(self, name, metadata):
session = db.get_session()
try:
db_state = utils.model_query(
models.StateInfo,
session
).filter_by(
name=name,
).with_lockmode('update').one()
db_state.s_metadata = metadata
except sqlalchemy.orm.exc.NoResultFound:
db_state = models.StateInfo(name=name, s_metadata=metadata)
session.add(db_state)
finally:
session.flush()
def set_metadata(self, name, metadata):
session = db.get_session()
with session.begin():
try:
q = utils.model_query(
models.StateInfo,
session)
q = q.filter(models.StateInfo.name == name)
q = q.with_lockmode('update')
db_state = q.one()
db_state.s_metadata = metadata
except sqlalchemy.orm.exc.NoResultFound:
db_state = models.StateInfo(name=name,
s_metadata=metadata)
session.add(db_state)
def get_state(self, tenant_id=None):
session = db.get_session()
q = utils.model_query(
models.RatedDataFrame,
session
)
if tenant_id:
q = q.filter(
models.RatedDataFrame.tenant_id == tenant_id
)
r = q.order_by(
models.RatedDataFrame.end.desc()
).first()
if r:
return ck_utils.dt2ts(r.end)
def set_state(self, name, state):
session = db.get_session()
with session.begin():
try:
q = utils.model_query(
models.ModuleStateInfo,
session)
q = q.filter(models.ModuleStateInfo.name == name)
q = q.with_lockmode('update')
db_state = q.one()
db_state.state = state
except sqlalchemy.orm.exc.NoResultFound:
db_state = models.ModuleStateInfo(name=name, state=state)
session.add(db_state)
return bool(db_state.state)
def delete_group(self, uuid, recurse=True):
session = db.get_session()
q = utils.model_query(
models.HashMapGroup,
session)
q = q.filter(models.HashMapGroup.group_id == uuid)
with session.begin():
try:
r = q.with_lockmode('update').one()
except sqlalchemy.orm.exc.NoResultFound:
raise api.NoSuchGroup(uuid=uuid)
if recurse:
for mapping in r.mappings:
session.delete(mapping)
for threshold in r.thresholds:
session.delete(threshold)
q.delete()
def set_mapping(self, service, collector):
session = db.get_session()
with session.begin():
try:
q = utils.model_query(
models.ServiceToCollectorMapping,
session)
q = q.filter_by(
service=service)
q = q.with_lockmode('update')
db_mapping = q.one()
db_mapping.collector = collector
except sqlalchemy.orm.exc.NoResultFound:
model = models.ServiceToCollectorMapping
db_mapping = model(service=service,
collector=collector)
session.add(db_mapping)
return db_mapping
def get_time_frame(self, begin, end, **filters):
model = models.RatedDataFrame
session = db.get_session()
q = utils.model_query(
model,
session
).filter(
model.begin >= ck_utils.ts2dt(begin),
model.end <= ck_utils.ts2dt(end)
)
for filter_name, filter_value in filters.items():
if filter_value:
q = q.filter(getattr(model, filter_name) == filter_value)
if not filters.get('res_type'):
q = q.filter(model.res_type != '_NO_DATA_')
count = q.count()
if not count:
raise storage.NoTimeFrame()
r = q.all()
return [entry.to_cloudkitty() for entry in r]
def delete_service(self, service):
session = db.get_session()
r = utils.model_query(models.HashMapService,
session).filter_by(name=service, ).delete()
if not r:
raise api.NoSuchService(service)
def test_model_query_common(self):
utils.model_query(MyModel, args=(MyModel.id, ), session=self.session)
self.session.query.assert_called_with(MyModel.id)
def test_no_deleted_value(self, _read_deleted_filter):
utils.model_query(MyModelSoftDeleted, session=self.session)
self.assertEqual(_read_deleted_filter.call_count, 0)
def get_run_ids(session):
# TODO(mtreinish): Move this function into the subunit2sql db api
results = db_utils.model_query(models.Run, session).order_by(
models.Run.run_at.desc()).filter_by(fails=0).limit(10).all()
return map(lambda x: x.id, results)
