def test_cycle(session): from mixer.backend.sqlalchemy import Mixer mixer = Mixer(session=session, commit=True) profile1 = mixer.blend('tests.test_sqlalchemy.Profile', name='first') profile2 = mixer.blend('tests.test_sqlalchemy.Profile', name='second') users = mixer.cycle(2).blend(User, profile=(p for p in (profile1, profile2))) assert len(users) == 2 assert users[0].profile.name == 'first' assert users[1].profile.name == 'second'
def groups( flask_app: Flask, temp_db_instance_helper: INS_HELPER["Group"], sqla_mixer: SqlaMixer, ) -> Iterator[List["Group"]]: from smorest_sfs.modules.groups.models import Group for _ in temp_db_instance_helper( *sqla_mixer.cycle(3).blend(Group, name=sqla_mixer.sequence("{0}_test_name")) ): yield _
def email_templates( flask_app: Flask, temp_db_instance_helper: INS_HELPER["EmailTemplate"], sqla_mixer: SqlaMixer, ) -> Iterator[List["EmailTemplate"]]: # pylint: disable=W0613 from smorest_sfs.modules.email_templates.models import EmailTemplate for _ in temp_db_instance_helper(*sqla_mixer.cycle(3).blend( EmailTemplate, name=sqla_mixer.sequence("{0}_test_name"))): yield _
def test_select(self): from mixer.backend.sqlalchemy import Mixer mixer = Mixer(session=self.session, commit=True) users = self.session.query(User).all() role = mixer.blend(Role, user=mixer.select) self.assertTrue(role.user in users) user = users.pop() role = mixer.blend(Role, user=mixer.select(User.id == user.id)) self.assertEqual(user, role.user)
def test_select(session): from mixer.backend.sqlalchemy import Mixer mixer = Mixer(session=session, commit=True) users = session.query(User).all() role = mixer.blend(Role, user=mixer.SELECT) assert role.user in users user = users.pop() role = mixer.blend(Role, user=mixer.SELECT(User.id == user.id)) assert user == role.user
def __init__(self, methodName='runTest'): super(BaseTestCase, self).__init__(methodName) self.mixer = Mixer(session=session, commit=False) self.session = session self.mixer.register(Payment, id=get_uuid, payment_address=get_address, merchant_address=get_address, amount=get_amount) self.mixer.register(Transaction, id=get_uuid, amount=get_amount, fee=Decimal(1)) self.mixer.register(Withdrawal, id=get_uuid)
def default_data(config): import transaction current_transaction = transaction.begin() dbsession = DBSESSION() # First insert default database data database_insert_default_data(session=dbsession, commit=False) # Add an admin user for the tests admin_group_name = security.Administrators admin_group = Group.query(dbsession).filter_by(name=admin_group_name).all() admin_user = User( id=1, first_name=u"Admin", last_name=u"User", email=u"*****@*****.**", password="******", token=AUTH_TOKEN, key=AUTH_KEY, salt="a66a328e85e9d74da8dac441cb6f5578c530c70f", groups=admin_group, ) dbsession.add(admin_user) # Insert all fixtures # TODO: Implement a way to insert only a set of fixtures per test ? mixer = Mixer(session=dbsession, commit=False) data = fixtures.create_data(mixer, dbsession) current_transaction.commit() return data
def init(session: "Session_") -> Iterator[None]: from .models import Base, User, engine, Item from smorest_sfs.plugins.queries.abstract import RenderableStatementABC from sqlalchemy.dialects.sqlite import dialect registered = False if (hasattr(RenderableStatementABC, "_session") and getattr(RenderableStatementABC, "_session") is not None): pre_session = getattr(RenderableStatementABC, "_session") pre_dialect = getattr(RenderableStatementABC, "_DIALECT") registered = True RenderableStatementABC.init_statement(session, dialect) mixer = Mixer(session=session) Base.metadata.create_all(engine) mixer.cycle(5).blend( User, name=mixer.sequence("name{0}"), nickname=mixer.sequence("nickname{0}"), items=mixer.sequence( lambda x: [Item(name="name{0}".format(3 * x + i)) for i in range(3)]), ) yield if registered: RenderableStatementABC.init_statement(pre_session, pre_dialect) Base.metadata.drop_all(engine)
def setUp(self): Base.metadata.create_all(ENGINE) app.testing = True app.debug = True self.app = app.test_client() self.SESSION = sessionmaker(bind=ENGINE) self.mixer = Mixer(session=self.SESSION(), commit=True)
def __init__(self, methodName="runTest"): super(BaseTestCase, self).__init__(methodName) self.mixer = Mixer(session=session, commit=False) self.session = session self.mixer.register( Payment, id=get_uuid, payment_address=get_address, merchant_address=get_address, amount=get_amount ) self.mixer.register(Transaction, id=get_uuid, amount=get_amount, fee=Decimal(1)) self.mixer.register(Withdrawal, id=get_uuid)
def test_reload(session): from mixer.backend.sqlalchemy import Mixer mixer = Mixer(session=session, commit=True) u1 = mixer.blend(User) u1.name = 'wrong name' u2 = mixer.reload(u1) assert u2 == u1 assert u2.name != 'wrong name'
def test_guard(session): from mixer.backend.sqlalchemy import Mixer, mixer with pytest.raises(ValueError): mixer.guard(User.name == 'maxi').blend(User) mixer = Mixer(session=session, commit=True) u1 = mixer.guard(User.name == 'maxi').blend(User, name='maxi') u2 = mixer.guard(User.name == 'maxi').blend(User) assert u1 assert u1 == u2
def test_mixer(session): from mixer.backend.sqlalchemy import Mixer mixer = Mixer(session=session, commit=True) p = mixer.blend('tests.test_sqlalchemy.ProfileNonIncremental', id=5) role = mixer.blend('tests.test_sqlalchemy.Role', user__profile_id_nonincremental=p) assert role and role.user role = mixer.blend(Role, user__name='test2') assert role.user.name == 'test2' profile = mixer.blend('tests.test_sqlalchemy.Profile') user = mixer.blend(User, profile__name='test') assert user.profile.name == 'test' user = mixer.blend(User, profile=profile) assert user.profile == profile user = mixer.blend(User, score=mixer.RANDOM) assert user.score != 50 user = mixer.blend(User, username=lambda: 'callable_value') assert user.username == 'callable_value'
def test_mixer(self): from mixer.backend.sqlalchemy import Mixer mixer = Mixer(session=self.session, commit=True) role = mixer.blend('tests.test_sqlalchemy.Role') self.assertTrue(role) self.assertTrue(role.user) role = mixer.blend(Role, user__name='test2') self.assertEqual(role.user.name, 'test2') profile = mixer.blend('tests.test_sqlalchemy.Profile') user = mixer.blend(User, profile__name='test') self.assertEqual(user.profile.name, 'test') user = mixer.blend(User, profile=profile) self.assertEqual(user.profile, profile) user = mixer.blend(User, score=mixer.random) self.assertNotEqual(user.score, 50) user = mixer.blend(User, username=lambda: 'callable_value') self.assertEqual(user.username, 'callable_value')
class BaseTestCase(unittest.TestCase): def __init__(self, methodName="runTest"): super(BaseTestCase, self).__init__(methodName) self.mixer = Mixer(session=session, commit=False) self.session = session self.mixer.register( Payment, id=get_uuid, payment_address=get_address, merchant_address=get_address, amount=get_amount ) self.mixer.register(Transaction, id=get_uuid, amount=get_amount, fee=Decimal(1)) self.mixer.register(Withdrawal, id=get_uuid) def tearDown(self): Transaction.query.delete() Withdrawal.query.delete() Payment.query.delete() self.session.commit() self.session.remove()
class BaseTestCase(unittest.TestCase): def __init__(self, methodName='runTest'): super(BaseTestCase, self).__init__(methodName) self.mixer = Mixer(session=session, commit=False) self.session = session self.mixer.register(Payment, id=get_uuid, payment_address=get_address, merchant_address=get_address, amount=get_amount) self.mixer.register(Transaction, id=get_uuid, amount=get_amount, fee=Decimal(1)) self.mixer.register(Withdrawal, id=get_uuid) def tearDown(self): Transaction.query.delete() Withdrawal.query.delete() Payment.query.delete() self.session.commit() self.session.remove()
def _init_mixer(self, db): self._mixer = Mixer(session=db, commit=False, fake=self._fake)
def mixer(session): return Mixer(session=session, commit=False)
def setUp(self): super(DatabaseTest, self).setUp() self.__transaction = connection.begin_nested() self.session = Session(connection) self.mixer = Mixer(session=self.session, commit=True)
def mixer(): return Mixer(session=db_connection.get(), commit=True)
@pytest.fixture(autouse=True, scope="session") def create_models(): Base.metadata.create_all(bind=engine) def override_get_db(): try: db = TestSessionLocal() yield db finally: db.close() _mixer = Mixer(session=TestSessionLocal(), commit=True) app.dependency_overrides[get_db] = override_get_db @pytest.fixture(scope="session") def client(): return TestClient(app) @pytest.fixture(scope="session") def mixer(): return _mixer @pytest.fixture()
class Faker: """ Class for automatic filling the database with test data """ def __init__(self, models: Models, verbose=False, fake=False, db=None): self._models = models self._config = Config() self._verbose = verbose self._mixer = None self._fake = fake self._silence_system_warn = False self._max_resolve = 20 if db: self._init_mixer(db) def _init_mixer(self, db): self._mixer = Mixer(session=db, commit=False, fake=self._fake) def fake_all(self, default_num=5): """Fill the database with fake data :param default_num: number of entries per table """ schemas = list(self._models.schemas.keys()) if 'system' in schemas: self.fake_schema('system', default_num=default_num) schemas.remove('system') self._silence_system_warn = True for schema in schemas: self.fake_schema(schema, default_num=default_num) self._silence_system_warn = False def fake_schema(self, schema, entries={}, default_num=5): """Fill the database schema tables with fake data raises ResolveError if could not resolve foreign keys :param schema: schema name :param entries: {model_name: number_of_entries} model_name is generated camelCase :param default_num: number of entries, if t_name is not in entries """ if 'system' in self._models.schemas and not self._silence_system_warn: logging.warning('If the model has references to system tables, ' 'it may be required to fake schema `system` first') generated = {name: 0 for name in self._models[schema].keys()} not_resolved = {name: 0 for name in self._models[schema].keys()} if schema in self._config.Faker['ignore']: for key in self._config.Faker['ignore'][schema]: del generated[key] del not_resolved[key] total = sum([ entries.get(name, default_num) for name in self._models[schema].keys() ]) try: if self._verbose: bar = tqdm.tqdm(total=total) with DBConn.get_session(autoflush=False) as db: self._init_mixer(db) while len(generated) > 0: finished = [] for name, i in generated.items(): if i >= entries.get(name, default_num): finished.append(name) continue model = self._models[schema][name] if self._fake_model(model, db): generated[name] += 1 if self._verbose: bar.update(1) not_resolved[name] = 0 else: not_resolved[name] += 1 if not_resolved[name] > self._max_resolve: raise ResolveError( f"Can't resolve foreign keys for {name}") for name in finished: del generated[name] self._flush_faked(db) finally: if self._verbose: bar.close() def fake_one(self, model, db): """Generate fake model :param model: SQLAlchemy model :param db: session, connection or engine :returns: model instance, if fks were resolved successfully """ attributes = {} resolved = True relationships = inspect(model).relationships.values() for name, attr in dict(model.__table__.columns).items(): if attr.foreign_keys: fk = next(iter(attr.foreign_keys)) else: continue t_name = '.'.join(fk._column_tokens[:-1]) # backref_name = fk._column_tokens[1] column = fk._column_tokens[-1] entry = list( db.execute( f"SELECT {column} FROM {t_name} ORDER BY RANDOM() LIMIT 1") ) if not entry: resolved = False break else: attributes[name] = entry[0][0] rel = self._get_relationship(relationships, name) if rel: name = NamesConverter.class_name(rel.target.schema, rel.target.name) target = self._models[rel.target.schema][name] search = {} search[column] = entry[0][0] obj = db.query(target).filter_by(**search).first() attributes[rel.class_attribute.key] = obj if resolved: faked = self._mixer.blend(model, **attributes) return faked return None def _flush_faked(self, db): try: db.commit() except sa.exc.IntegrityError: db.rollback() # TODO logging def _fake_model(self, model, db): faked = self.fake_one(model, db) if faked: db.add(faked) return True return False def _get_relationship(self, relationships, column_name): for r in relationships: if any([c.name == column_name for c in r.local_columns]): return r def faked_models(self): models = [] for schema in self._models.schemas.keys(): if schema not in self._config.Faker['ignore']: models.extend(self._models[schema].values()) else: for key, model in self._models[schema].items(): if key not in self._config.Faker['ignore'][schema]: models.append(model) return models
def test_mix22(session): from mixer.backend.sqlalchemy import Mixer mixer = Mixer(session=session, commit=True) role = mixer.blend(Role, name=mixer.MIX.user.name) assert role.name == role.user.name
def mixer(): return Mixer(session=session)