class UserAutoFixture(AutoFixture):
field_values = {
'full_name': FullNameGenerator(),
'username': UserNameGenerator(),
'email': generators.EmailGenerator(),
'password': generators.StaticGenerator('password'),
'is_superuser': False,
'is_staff': WeightedRandomBoolGenerator(percent_chance=3),
'is_active': True,
}
follow_fk = False
follow_m2m = False
def handle(self, *args, **options):
# 1. Users
AutoFixture(
User,
field_values={
# Generates random birth dates between 7-77 yo
'birth_date':
generators.DateGenerator(
min_date=dt.date.today() - dt.timedelta(365 * 77),
max_date=dt.date.today() - dt.timedelta(365 * 7)),
# We are a young company so just set join_date to 1-2 years
'date_joined':
generators.DateGenerator(
min_date=dt.date.today() - dt.timedelta(365 * 2),
max_date=dt.date.today() - dt.timedelta(365 * 1)),
'email':
generators.EmailGenerator(),
'first_name':
generators.FirstNameGenerator(),
'img':
generators.ImageGenerator(height=200, width=200,
path='users/'),
'last_name':
generators.LastNameGenerator(),
'oauth_id':
generators.PositiveIntegerGenerator()
}).create(10)
# 2. Items
AutoFixture(Item,
field_values={
'name':
ItemNameGenerator(),
'img':
generators.ImageGenerator(height=200,
width=200,
path='items/')
}).create(80)
def get_generator(self, field):
'''
Return a value generator based on the field instance that is passed to
this method. This function may return ``None`` which means that the
specified field will be ignored (e.g. if no matching generator was
found).
'''
if isinstance(field, fields.AutoField):
return None
if self.is_inheritance_parent(field):
return None
if (
field.default is not fields.NOT_PROVIDED and
not self.overwrite_defaults and
field.name not in self.field_values):
return None
kwargs = {}
if field.name in self.field_values:
value = self.field_values[field.name]
if isinstance(value, generators.Generator):
return value
elif isinstance(value, AutoFixture):
return generators.InstanceGenerator(autofixture=value)
elif callable(value):
return generators.CallableGenerator(value=value)
return generators.StaticGenerator(value=value)
if field.null:
kwargs['empty_p'] = self.none_p
if field.choices:
return generators.ChoicesGenerator(choices=field.choices, **kwargs)
if isinstance(field, related.ForeignKey):
# if generate_fk is set, follow_fk is ignored.
is_self_fk = (get_remote_field_to(field)().__class__ == self.model)
if field.name in self.generate_fk and not is_self_fk:
return generators.InstanceGenerator(
autofixture.get(
get_remote_field_to(field),
follow_fk=self.follow_fk.get_deep_links(field.name),
generate_fk=self.generate_fk.get_deep_links(field.name)),
limit_choices_to=get_remote_field(field).limit_choices_to)
if field.name in self.follow_fk:
selected = generators.InstanceSelector(
get_remote_field_to(field),
limit_choices_to=get_remote_field(field).limit_choices_to)
if selected.get_value() is not None:
return selected
if field.blank or field.null:
return generators.NoneGenerator()
if is_self_fk and not field.null:
raise CreateInstanceError(
u'Cannot resolve self referencing field "%s" to "%s" without null=True' % (
field.name,
'%s.%s' % (
get_remote_field_to(field)._meta.app_label,
get_remote_field_to(field)._meta.object_name,
)
))
raise CreateInstanceError(
u'Cannot resolve ForeignKey "%s" to "%s". Provide either '
u'"follow_fk" or "generate_fk" parameters.' % (
field.name,
'%s.%s' % (
get_remote_field_to(field)._meta.app_label,
get_remote_field_to(field)._meta.object_name,
)
))
if isinstance(field, related.ManyToManyField):
if field.name in self.generate_m2m:
min_count, max_count = self.generate_m2m[field.name]
return generators.MultipleInstanceGenerator(
autofixture.get(get_remote_field_to(field)),
limit_choices_to=get_remote_field(field).limit_choices_to,
min_count=min_count,
max_count=max_count,
**kwargs)
if field.name in self.follow_m2m:
min_count, max_count = self.follow_m2m[field.name]
return generators.InstanceSelector(
get_remote_field_to(field),
limit_choices_to=get_remote_field(field).limit_choices_to,
min_count=min_count,
max_count=max_count,
**kwargs)
if field.blank or field.null:
return generators.StaticGenerator([])
raise CreateInstanceError(
u'Cannot assign instances of "%s" to ManyToManyField "%s". '
u'Provide either "follow_m2m" or "generate_m2m" argument.' % (
'%s.%s' % (
get_remote_field_to(field)._meta.app_label,
get_remote_field_to(field)._meta.object_name,
),
field.name,
))
if isinstance(field, fields.FilePathField):
return generators.FilePathGenerator(
path=field.path, match=field.match, recursive=field.recursive,
max_length=field.max_length, **kwargs)
if isinstance(field, fields.CharField):
if isinstance(field, fields.SlugField):
generator = generators.SlugGenerator
elif isinstance(field, fields.EmailField):
return generators.EmailGenerator(
max_length=min(field.max_length, 30))
elif isinstance(field, fields.URLField):
return generators.URLGenerator(
max_length=min(field.max_length, 25))
elif field.max_length > 15:
return generators.LoremSentenceGenerator(
common=False,
max_length=field.max_length)
else:
generator = generators.StringGenerator
return generator(max_length=field.max_length)
if isinstance(field, fields.DecimalField):
return generators.DecimalGenerator(
decimal_places=field.decimal_places,
max_digits=field.max_digits)
if hasattr(fields, 'BigIntegerField'):
if isinstance(field, fields.BigIntegerField):
return generators.IntegerGenerator(
min_value=-field.MAX_BIGINT - 1,
max_value=field.MAX_BIGINT,
**kwargs)
if isinstance(field, ImageField):
return generators.ImageGenerator(storage=field.storage, **kwargs)
for field_class, generator in self.field_to_generator.items():
if isinstance(field, field_class):
return generator(**kwargs)
return None
def test_email_with_static_domain(self):
generate = generators.EmailGenerator(static_domain='djangoproject.com')
email = generate()
self.assertTrue(email.endswith('djangoproject.com'))
email = generate()
self.assertTrue(email.endswith('djangoproject.com'))
def test_email(self):
generate = generators.EmailGenerator()
form = EmailForm({'email': generate()})
self.assertTrue(form.is_valid())
def handle(self, *args, **options):
fixture = AutoFixture(User,
field_values={
'username':
generators.StringGenerator(max_length=10),
'first_name':
generators.FirstNameGenerator(),
'last_name':
generators.LastNameGenerator(),
'email':
generators.EmailGenerator(),
'password':
UNUSABLE_PASSWORD
})
entries = fixture.create(50)
for us in User.objects.all():
if us.username != 'alberto':
us.set_password('pass')
us.save()
fixture = AutoFixture(
auction,
field_values={
'min_price':
generators.PositiveSmallIntegerGenerator(max_value=1000),
'lock':
False
})
entries = fixture.create(50)
fixture = AutoFixture(bid,
field_values={
'amount':
generators.IntegerGenerator(min_value=0),
'status':
'W'
})
entries = fixture.create(20)
auct = auction.objects.all()
for auc in auct:
if (auc.deadline > timezone.make_aware(
datetime.now(), timezone.get_default_timezone())):
auc.lifecycle = 'A'
auc.save()
if (auc.deadline < timezone.make_aware(
datetime.now(), timezone.get_default_timezone())
and auc.lifecycle == 'A'):
auc.lifecycle = 'D'
auc.save()
bids = bid.objects.all()
for b in bids:
for a in bids:
if (b.auct == a.auct and a != b):
if (b.status == 'W' and a.status == 'W'):
if (b.amount > a.amount):
a.status = 'L'
a.save()
else:
b.status = 'L'
b.save()
if (b.amount < b.auct.min_price):
b.amount = b.auct.min_price + 1
b.save()
if (b.user == b.auct.seller):
b.delete()
'Abbie', 'Anna', 'Alice', 'Beth', 'Carrie', 'Christina', 'Danielle',
'Emma', 'Emily', 'Esther', 'Felicia', 'Grace', 'Gloria', 'Helen', 'Irene',
'Joanne', 'Joyce', 'Jessica', 'Kathy', 'Katie', 'Kelly', 'Linda', 'Lydia',
'Mandy', 'Mary', 'Olivia', 'Priscilla', 'Rebecca', 'Rachel', 'Susan',
'Sarah', 'Stacey', 'Vivian'
]
SURNAMES = [
'Smith', 'Walker', 'Conroy', 'Stevens', 'Jones', 'Armstrong', 'Johnson',
'White', 'Stone', 'Strong', 'Olson', 'Lee', 'Forrest', 'Baker', 'Portman',
'Davis', 'Clark', 'Brown', 'Roberts', 'Ellis', 'Jackson', 'Marshall',
'Wang', 'Chen', 'Chou', 'Tang', 'Huang', 'Liu', 'Shih', 'Su', 'Song',
'Yang', 'Chan', 'Tsai', 'Wong', 'Hsu', 'Cheng', 'Chang', 'Wu', 'Lin', 'Yu',
'Yao', 'Kang', 'Park', 'Kim', 'Choi', 'Ahn', 'Mujuni'
]
PASSWORD = '******'
EMAIL_GENERATOR = generators.EmailGenerator()
RECRUITERS = [('Smith', 'Abraham'), ('Walker', 'Adam'), ('Conroy', 'Anthony'),
('Stevens', 'Brian')]
COMPANIES = [
'Giggler', 'Microhard', 'Headpage', 'Chatsnap', 'Bookface', 'Boxdrop'
]
def generate_title():
return ' '.join((random.choice(SKILLS), random.choice(TITLES)))
def save_model(model):
try:
with transaction.atomic():
model.save()
