def mixer(request):
if VERSION > (1, 8):
call_command('migrate', interactive=False, verbosity=0)
else:
call_command('syncdb', interactive=False, verbosity=0)
request.addfinalizer(lambda: call_command('flush', interactive=False, verbosity=0))
return Mixer()
def setUp(self):
self.tree = create_nomenclature_tree("UK")
self.model_classes = [Chapter, Section, Heading, SubHeading, Commodity]
self.mixer = Mixer()
for model_class in self.model_classes:
self.mixer.register(model_class, nomenclature_tree=self.tree)
def setUp(self):
self.mo_admin_instance = MemberOrganisationOwnerAdmin(
CompanyOrganisationOwner, AdminSite()
)
self.main_user_credentials = {
'username': '******',
'password': '******',
}
self.group = Group.objects.get(name=self.group_name)
self.request_factory = RequestFactory()
self.mixer = Mixer(locale='en')
def test_check_countries_consistency_via_command(self):
mixer = Mixer()
country_missing_roo = mixer.blend(
Country,
name="Test Country 2",
country_code="BX",
scenario="TEST_TA",
)
country_missing_roo.save()
with self.assertLogs("rules_of_origin.ingest.importer",
level="ERROR") as warning_log:
call_command("check_rules_of_origin")
# Assert 'BX - Test Country 2' is in the error message to sentry
self.assertIn("BX - Test Country 2", str(warning_log.output))
def setUp(self):
Country.objects.all().delete()
mixer = Mixer()
self.country = mixer.blend(
Country,
name="Test Country",
country_code="XT",
has_eu_trade_agreement=False,
scenario="STICKER_TRADES",
content_url="gotgotgotneed.com",
trade_agreement_title="The Very Agreeable Agreement",
trade_agreement_type="Football Sticker Swap",
roo_guidance_url="igetfabianbartezineverypackforgodssake.com",
)
self.country.save()
def handle(self, *args, **options):
batch_size = 5000
book_cap, reader_cap = 100000, 50000
mixer = Mixer(commit=False)
books = mixer.cycle(book_cap).blend(Book)
readers = mixer.cycle(reader_cap).blend(Reader)
for i in range(0, reader_cap, batch_size):
Reader.objects.bulk_create(readers[i:i + batch_size])
for i in range(0, len(books), batch_size):
Book.objects.bulk_create(books[i:i + batch_size])
for book in books:
index = random.randrange(1, reader_cap)
book.readers.add(readers[index])
def setUp(self):
mixer = Mixer()
self.country = mixer.blend(
Country,
name="Test Country",
country_code="XT",
trade_agreement_title="The White-Gold Concordat",
)
self.gsp_country = mixer.blend(
Country,
name="Test Country 2",
country_code="BX",
scenario="TEST_TA",
)
self.commodity = mixer.blend(Commodity, commodity_code="0100000000")
def test_relation(self):
mixer = Mixer()
hole = mixer.blend('django_app.hole', title='hole4')
self.assertEqual(hole.owner.pk, 1)
self.assertEqual(hole.title, 'hole4')
hat = mixer.blend('django_app.hat')
self.assertFalse(hat.owner)
self.assertEqual(hat.brend, 'wood')
self.assertTrue(hat.color in ('RD', 'GRN', 'BL'))
hat = mixer.blend('django_app.hat', owner=mixer.select)
self.assertTrue(hat.owner)
silk = mixer.blend('django_app.silk')
self.assertFalse(silk.hat.owner)
silk = mixer.blend('django_app.silk', hat__owner__title='booble')
self.assertTrue(silk.hat.owner)
self.assertEqual(silk.hat.owner.title, 'booble')
door = mixer.blend('django_app.door', hole__title='flash',
hole__size=244)
self.assertTrue(door.hole.owner)
self.assertEqual(door.hole.title, 'flash')
self.assertEqual(door.hole.size, 244)
door = mixer.blend('django_app.door')
self.assertNotEqual(door.hole.title, 'flash')
num = mixer.blend('django_app.number', doors=[door])
self.assertEqual(num.doors.get(), door)
num = mixer.blend('django_app.number')
self.assertEqual(num.doors.count(), 1)
num = mixer.blend('django_app.number', doors__size=42)
self.assertEqual(num.doors.all()[0].size, 42)
tag = mixer.blend('django_app.tag', customer=mixer.random)
self.assertTrue(tag.customer)
def test_fields(self):
from .django_app.models import Rabbit
mixer = Mixer()
rabbit = mixer.blend('django_app.rabbit')
self.assertTrue(isinstance(rabbit, Rabbit))
self.assertTrue(rabbit.id)
self.assertTrue(rabbit.pk)
self.assertEqual(rabbit.pk, 1)
self.assertEqual(len(rabbit.title), 16)
self.assertTrue(isinstance(rabbit.active, bool))
self.assertTrue(isinstance(rabbit.created_at, datetime.date))
self.assertTrue(isinstance(rabbit.updated_at, datetime.datetime))
self.assertTrue(isinstance(rabbit.opened_at, datetime.time))
self.assertTrue('@' in rabbit.email)
self.assertTrue(rabbit.speed)
self.assertTrue(rabbit.description)
self.assertEqual(rabbit.picture.read(), b'pylama\n')
rabbit = mixer.blend('rabbit')
self.assertTrue(rabbit)
def test_random_fields(self):
from .django_app.models import Rabbit
mixer = Mixer(fake=False)
rabbit = mixer.blend('django_app.rabbit')
self.assertTrue(isinstance(rabbit, Rabbit))
self.assertTrue(rabbit.id)
self.assertTrue(rabbit.pk)
self.assertEqual(rabbit.pk, 1)
self.assertEqual(len(rabbit.title), 16)
self.assertTrue(isinstance(rabbit.active, bool))
self.assertTrue(isinstance(rabbit.created_at, datetime.date))
self.assertTrue(isinstance(rabbit.updated_at, datetime.datetime))
self.assertTrue(isinstance(rabbit.opened_at, datetime.time))
self.assertTrue('@' in rabbit.email)
self.assertTrue(rabbit.description)
self.assertTrue(rabbit.some_field)
self.assertTrue(rabbit.money)
hat = mixer.blend('django_app.hat', color=mixer.random)
self.assertTrue(hat.color in ('RD', 'GRN', 'BL'))
def test_custom(mixer):
mixer.register(
Rabbit,
title=lambda: 'Mr. Rabbit',
speed=lambda: mixer.faker.small_positive_integer(99))
rabbit = mixer.blend(Rabbit, speed=mixer.RANDOM, percent=23)
assert isinstance(rabbit.speed, decimal.Decimal)
assert isinstance(rabbit.percent, float)
assert rabbit.title == 'Mr. Rabbit'
from mixer.backend.django import GenFactory
def getter(*args, **kwargs):
return "Always same"
class MyFactory(GenFactory):
generators = {models.CharField: getter}
fabric = MyFactory.get_fabric(models.CharField)
assert fabric() == "Always same"
mixer = Mixer(factory=MyFactory, fake=False)
assert mixer._Mixer__factory == MyFactory
test = mixer.blend(Rabbit)
assert test.title == "Always same"
@mixer.middleware('auth.user')
def encrypt_password(user): # noqa
user.set_password(user.password)
return user
user = mixer.blend('auth.User', password='******')
assert user.check_password('test')
user = user.__class__.objects.get(pk=user.pk)
assert user.check_password('test')
import pytest
from mixer.backend.django import Mixer
from django.test import RequestFactory
from django.urls import reverse
from django.contrib.auth import get_user_model
from django.contrib.auth.models import AnonymousUser
from accounts.views import UserProfileView, RegistrationFormView
User = get_user_model()
mixer = Mixer(commit=False, fake=True)
def test_get_registrationview():
path = reverse('accounts:register')
factory = RequestFactory()
user = AnonymousUser()
request = factory.get(path)
request.user = user
response = RegistrationFormView(request=request)
assert response.template_name == 'registration/registration_form.html'
@pytest.fixture
@pytest.mark.django_db(transaction=True)
def user():
user = mixer.blend(User)
return User.objects.create_user(email=f'{user.email}',
password='******')
@pytest.mark.django_db(transaction=True)
import random
from django.contrib.gis.geos import Point
from mixer.backend.django import Mixer
from rest_framework import status, serializers
from rest_framework.generics import RetrieveAPIView
from rest_framework.response import Response
from rest_framework.views import APIView
from faker import Faker
from good_spot.places.models import Place, PlaceType
fake = Faker()
mixer = Mixer(commit=False)
mocked_objects_count = 10
place_rating_choice = list(range(1, 5))
place_types = []
place_type_choice = ["bar", "restaurant", "night club"]
pl_i = 1
for pl_type in place_type_choice:
place_type = mixer.blend(PlaceType)
place_type.id = pl_i
place_type.name = pl_type
place_types.append(place_type)
pl_i += 1
def make_place(place_id):
place = mixer.blend(Place)
place.id = place_id
def test_random_fields():
mixer = Mixer(fake=False)
hat = mixer.blend('django_app.hat', color=mixer.RANDOM)
assert hat.color in ('RD', 'GRN', 'BL')
def setUp(self):
super().setUp()
self.src.events = []
self.safe_mixer = Mixer(commit=False)
def create_three_objects_of(model, common_data=None):
if common_data is None:
common_data = {}
mixer = Mixer()
return mixer.cycle(count=3).blend(model, **common_data)
def create_object(model, *, data=None, commit=True):
if data is None:
data = {}
mixer = Mixer(commit=commit)
return mixer.blend(model, **data)
def main(project_dir):
project_dir = project_dir or u'/'.join(os.getcwd().split(u'/')[:-3])
sys.path.append(project_dir)
sys.path.append(os.path.join(project_dir, u'apps'))
os.environ[u'DJANGO_SETTINGS_MODULE'] = u'settings'
import django
django.setup()
from mixer.backend.django import mixer, Mixer
from catalog.models import Maker, BrandMaker, Brand, \
PrintTypeMaker, PrintType, CategorySite, CategoryXML, \
Product, ProductAttachment, ProductParamsOther, \
ProductParamsPack, ProductParamsStock, \
SubProduct, SubProductParamsOther, SubProductParamsStock, \
Status, Settings, OrderReference
# Generate a random maker
maker_s = mixer.cycle(5).blend(Maker)
# Generate a random status
status_s = mixer.cycle(5).blend(Status)
# Create filters
i = 0
for k, v in {
'default': ['По умолчанию', 'title', 0, 0],
'NAZ': ['По названию (А-Я)', 'title', 0, 1],
'NZA': ['По названию (Я-А)', 'title', 1, 2]
}.items():
OrderReference(name=k,
official=v[0],
field_name=v[1],
field_order=v[2],
position=v[3]).save()
i += 1
# Generate a random brand
brand_s = mixer.cycle(5).blend(Brand)
brand_maker_s = mixer.cycle(20).blend(BrandMaker,
maker=mixer.SELECT,
brand=(bm for bm in brand_s * 4))
# Generate a random print type
print_type_s = mixer.cycle(5).blend(PrintType)
print_type_maker_s = mixer.cycle(20).blend(
PrintTypeMaker,
maker=mixer.SELECT,
print_type=(pt for pt in print_type_s * 4))
# Generate a random category site
mixer = Mixer(commit=False)
category_site_parent_s = mixer.cycle(5).blend(CategorySite)
for cat_site_parent in category_site_parent_s:
print(cat_site_parent.slug_title)
cat_site_parent_obj = CategorySite.add_root(
title=cat_site_parent.title,
slug_title=cat_site_parent.slug_title,
preview=cat_site_parent.preview,
content=cat_site_parent.content,
show=cat_site_parent.show,
image=CATEGORY_SITE_IMAGE,
position=cat_site_parent.position)
cat_site_parent_obj.save()
category_site_child_s = mixer.cycle(5).blend(CategorySite)
for cat_site_child in category_site_child_s:
cat_site_child_obj = cat_site_parent_obj.add_child(
title=cat_site_child.title,
slug_title=cat_site_child.slug_title,
preview=cat_site_child.preview,
content=cat_site_child.content,
show=cat_site_child.show,
image=CATEGORY_SITE_IMAGE,
position=cat_site_child.position)
cat_site_child_obj.save()
# Generate a random category xml
mixer = Mixer(commit=False)
for maker in Maker.objects.all():
category_xml_parent_s = mixer.cycle(5).blend(
CategoryXML,
maker=maker,
category_site=(category_site
for category_site in CategorySite.objects.filter(
depth=1)),
cat_id=(i for i in range(1, 9)))
for cat_xml_parent in category_xml_parent_s:
cat_xml_parent_obj = CategoryXML.add_root(
maker=maker,
title=cat_xml_parent.title,
cat_id=cat_xml_parent.cat_id,
category_site=cat_xml_parent.category_site,
import_fl=1)
cat_xml_parent_obj.save()
category_xml_child_s = mixer.cycle(5).blend(
CategoryXML,
maker=maker,
category_site=(
category_site
for category_site in CategorySite.objects.filter(depth=2)),
cat_id=(i for i in range(
int(cat_xml_parent.cat_id) * 10,
int(cat_xml_parent.cat_id) * 10 + 10)))
for cat_xml_child in category_xml_child_s:
cat_xml_child_obj = cat_xml_parent_obj.add_child(
maker=maker,
title=cat_xml_child.title,
cat_id=cat_xml_child.cat_id,
category_site=cat_xml_child.category_site,
import_fl=1)
cat_xml_child_obj.save()
# Generate a random product
mixer = Mixer(commit=True)
for maker in Maker.objects.all():
product_s = mixer.cycle(50).blend(
Product,
maker=maker,
brand=(brand
for brand in list(BrandMaker.objects.filter(maker=maker)) *
100),
status=Status.objects.all()[0],
small_image=PRODUCT_IMAGE,
big_image=PRODUCT_IMAGE,
super_big_image=PRODUCT_IMAGE,
code=(str(x) for x in range(1000, 10000, 2)),
category_xml=(
cat_xml
for cat_xml in list(CategoryXML.objects.filter(maker=maker)) *
100),
print_type=(print_type for print_type in
list(PrintTypeMaker.objects.filter(maker=maker)) *
100),
import_fl=1)
# Generate a random product attachment
product_attachment_s = mixer.cycle(100).blend(
ProductAttachment,
maker=maker,
product=(product for product in
list(Product.objects.filter(maker=maker).all()) * 2),
file=PRODUCT_IMAGE,
image=PRODUCT_IMAGE)
print(Product.objects.filter(maker=maker).all())
# Generate a random product params pack
product_params_pack_s = mixer.cycle(300).blend(
ProductParamsPack,
maker=maker,
abbr=(
item
for product in list(Product.objects.filter(maker=maker).all())
for item in
['amount', 'weight', 'volume', 'sizex', 'sizey', 'sizez']),
product=(
product
for product in list(Product.objects.filter(maker=maker).all())
for i in range(0, 6)),
pack_id=0)
# Generate a random product params stock
product_params_stock_s = mixer.cycle(250).blend(
ProductParamsStock,
maker=maker,
abbr=(
item
for product in list(Product.objects.filter(maker=maker).all())
for item in
['amount', 'free', 'inwayamount', 'inwayfree', 'enduserprice']
),
product=(
product
for product in list(Product.objects.filter(maker=maker).all())
for i in range(0, 5)))
# Generate a random product params other
product_params_other_s = mixer.cycle(150).blend(
ProductParamsOther,
maker=maker,
abbr=(
item
for product in list(Product.objects.filter(maker=maker).all())
for item in ['product_size', 'weight', 'matherial']),
product=(
product
for product in list(Product.objects.filter(maker=maker).all())
for i in range(0, 3)))
# Generate a random subproduct attachment
subproduct_s = mixer.cycle(100).blend(
SubProduct,
maker=maker,
code=(str(x) for x in range(1000, 10000, 2)),
product=(product for product in
list(Product.objects.filter(maker=maker).all()) * 2))
# Generate a random subproduct params stock
subproduct_params_stock_s = mixer.cycle(500).blend(
SubProductParamsStock,
maker=maker,
abbr=(
item for subproduct in list(
SubProduct.objects.filter(maker=maker).all()) for item in
['amount', 'free', 'inwayamount', 'inwayfree', 'enduserprice']
),
sub_product=(subproduct for subproduct in list(
SubProduct.objects.filter(maker=maker).all())
for i in range(0, 5)))
# Generate a random subproduct params other
subproduct_params_other_s = mixer.cycle(200).blend(
SubProductParamsOther,
maker=maker,
abbr=(item for subproduct in list(
SubProduct.objects.filter(maker=maker).all())
for item in ['size_code', 'weight']),
sub_product=(subproduct for subproduct in list(
SubProduct.objects.filter(maker=maker).all())
for i in range(0, 2)))
# Generate a random settings
settings = mixer.blend(Settings)
def make_membership(cls, *args, **kwargs):
params = cls.default_membership.copy()
params.update(kwargs)
instance = Mixer().blend('events.Membership', **params)
return instance
def make_movement(cls, *args, **kwargs):
params = cls.default_movement.copy()
params.update(kwargs)
instance = Mixer().blend('wallet.Movement', **params)
return instance
import random
import sys
from django.contrib.auth import get_user_model
from django.core.management import BaseCommand, call_command
from main.models import Customer, Manager
from mixer.backend.django import Mixer
User = get_user_model()
mixer = Mixer()
class Command(BaseCommand):
def handle(self, *args, **options):
self.create_user()
manager = None
for i in range(400000):
if i == 0 or i % 3:
manager = mixer.blend(Manager)
mixer.blend(
Customer,
phone_number=random.choice([mixer.faker.phone_number(), None]),
manager=manager,
)
if i % 10000 == 0:
self.stdout.write(f"Added {i} customers")
def create_user(self):
credentials = {
"username": "******",
person.treatment person.first_name person.last_name person.cpf person.birthday person.email person.phone person.blocked mixer.blend(Person).birthday #----------------------------------------- from mixer.backend.django import mixer from myproject.core.models import Person mixer = Mixer(locale='pt_br') person = mixer.blend(Person) person.first_name person.last_name person.faker.name() # person.faker.gender() # person.faker.treatment() person.faker.first_name() person.faker.last_name() person.faker.cpf() person.faker.date_time() person.faker.iso8601() person.faker.email() person.faker.phone_number() # person.faker.blocked()
def mixer(request):
call_command('migrate', interactive=False, verbosity=0)
request.addfinalizer(
lambda: call_command('flush', interactive=False, verbosity=0))
return Mixer()
def make_event(cls, *args, **kwargs):
params = cls.default_event.copy()
params.update(kwargs)
instance = Mixer().blend('events.Event', **params)
return instance
