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