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 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_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)