def test_unregister(self):
autofixture.register(SimpleModel, SimpleAutoFixture)
self.assertTrue(SimpleModel in autofixture.REGISTRY)
self.assertEqual(autofixture.REGISTRY[SimpleModel], SimpleAutoFixture)
autofixture.unregister(SimpleModel)
self.assertFalse(SimpleModel in autofixture.REGISTRY)
def test_unregister(self):
autofixture.register(SimpleModel, SimpleAutoFixture)
self.assertTrue(SimpleModel in autofixture.REGISTRY)
self.assertEqual(autofixture.REGISTRY[SimpleModel], SimpleAutoFixture)
autofixture.unregister(SimpleModel)
self.assertFalse(SimpleModel in autofixture.REGISTRY)
def test_overwrite_attributes(self):
autofixture.register(SimpleModel, SimpleAutoFixture)
for obj in autofixture.create(SimpleModel,
10,
field_values={'name': 'bar'}):
self.assertEqual(obj.name, 'bar')
obj = autofixture.create_one(SimpleModel, field_values={'name': 'bar'})
self.assertEqual(obj.name, 'bar')
def test_overwrite_attributes(self):
autofixture.register(SimpleModel, SimpleAutoFixture)
for obj in autofixture.create(
SimpleModel, 10, field_values={'name': 'bar'}):
self.assertEqual(obj.name, 'bar')
obj = autofixture.create_one(
SimpleModel, field_values={'name': 'bar'})
self.assertEqual(obj.name, 'bar')
def test_values_class(self):
autofixture.register(BasicModel, BasicValueFixture)
for obj in autofixture.create(BasicModel, 10):
self.assertEqual(obj.chars, 'foo')
self.assertEqual(obj.shortchars, 'a')
self.assertEqual(obj.blankchars, 'bar')
self.assertEqual(obj.nullchars, 'spam')
self.assertTrue(1 <= obj.intfield <= 13)
def test_values_class(self):
autofixture.register(BasicModel, BasicValueFixture)
for obj in autofixture.create(BasicModel, 10):
self.assertEqual(obj.chars, 'foo')
self.assertEqual(obj.shortchars, 'a')
self.assertEqual(obj.blankchars, 'bar')
self.assertEqual(obj.nullchars, 'spam')
self.assertTrue(1 <= obj.intfield <= 13)
def test_registered_fixture_is_used_for_fk(self):
class BasicModelFixture(AutoFixture):
field_values = {'chars': 'Hello World!'}
autofixture.register(BasicModel, BasicModelFixture)
fixture = AutoFixture(RelatedModel, generate_fk=['related'])
obj = fixture.create_one()
self.assertTrue(obj)
self.assertEqual(obj.related.chars, 'Hello World!')
def test_registered_fixture_is_used_for_fk(self):
class BasicModelFixture(AutoFixture):
field_values={'chars': 'Hello World!'}
autofixture.register(BasicModel, BasicModelFixture)
fixture = AutoFixture(RelatedModel, generate_fk=['related'])
obj = fixture.create_one()
self.assertTrue(obj)
self.assertEqual(obj.related.chars, 'Hello World!')
def test_registered_fixture_is_used_for_m2m(self):
class SimpleModelFixture(AutoFixture):
field_values = {'name': 'Jon Doe'}
autofixture.register(SimpleModel, SimpleModelFixture)
fixture = AutoFixture(M2MModel, generate_m2m={'m2m': (5, 5)})
obj = fixture.create_one()
self.assertTrue(obj)
self.assertEqual(obj.m2m.count(), 5)
self.assertEqual(list(obj.m2m.values_list('name', flat=True)),
['Jon Doe'] * 5)
def test_registered_fixture_is_used_for_m2m(self):
class SimpleModelFixture(AutoFixture):
field_values={'name': 'Jon Doe'}
autofixture.register(SimpleModel, SimpleModelFixture)
fixture = AutoFixture(M2MModel, generate_m2m={'m2m': (5,5)})
obj = fixture.create_one()
self.assertTrue(obj)
self.assertEqual(obj.m2m.count(), 5)
self.assertEqual(
list(obj.m2m.values_list('name', flat=True)),
['Jon Doe'] * 5)
def generate_page(cls, child_class, parent_id, number_childs):
aux_dict = {
'content_type': ContentType.objects.get_for_model(child_class)
}
cls.field_values = dict(cls.field_values, **aux_dict)
register(child_class, GenericAutoFixture, overwrite=True)
parent_page = Page.objects.filter(pk=parent_id)[0]
parent_path = parent_page.path
child_depth = parent_page.depth + 1
num_childs = parent_page.numchild
for pos in range(0, number_childs):
new_page_path = parent_path + str(num_childs + 1).zfill(4)
fields = {'path': new_page_path, 'depth': child_depth}
cls.field_values = dict(cls.field_values, **fields)
call_command('loadtestdata',
child_class._meta.__unicode__() + ':1')
call_command('fixtree')
num_childs += 1
def generate_page(cls, child_class, parent_id, number_childs):
aux_dict = {
'content_type': ContentType.objects.get_for_model(child_class)
}
cls.field_values = dict(cls.field_values, **aux_dict)
register(child_class, GenericAutoFixture, overwrite=True)
parent_page = Page.objects.filter(pk=parent_id)[0]
parent_path = parent_page.path
child_depth = parent_page.depth + 1
num_childs = parent_page.numchild
for pos in range(0, number_childs):
new_page_path = parent_path + str(num_childs + 1).zfill(4)
fields = {
'path': new_page_path,
'depth': child_depth
}
cls.field_values = dict(cls.field_values, **fields)
call_command('loadtestdata', child_class._meta.__unicode__() + ':1')
call_command('fixtree')
num_childs += 1
from autofixture import AutoFixture, generators, register
from faker import Factory
from .models import Project
fake = Factory.create()
IMAGESIZES = ((1300, 600), )
class ProjectAutoFixture(AutoFixture):
field_values = {
'name': generators.CallableGenerator(fake.company),
'slug': generators.CallableGenerator(fake.slug),
'image': generators.ImageGenerator(sizes=IMAGESIZES),
'is_draft': generators.ChoicesGenerator(values=[True, False, False]),
}
register(Project, ProjectAutoFixture)
"Bioethanol")),
'image_url':
generators.ChoicesGenerator(
values=("http://127.0.0.1:8000/static/images/pic01.jpg",
"http://127.0.0.1:8000/static/images/pic02.jpg",
"http://127.0.0.1:8000/static/images/pic03.jpg",
"http://127.0.0.1:8000/static/images/pic04.jpg",
"http://127.0.0.1:8000/static/images/pic05.jpg")),
'price_per_unit':
generators.ChoicesGenerator(values=(50, 60, 45, 110, 51, 90, 80, 144,
97, 56)),
'seats':
generators.ChoicesGenerator(values=(1, 2, 3, 4)),
'year':
generators.ChoicesGenerator(values=("2001", "2002", "2003", "2015",
"2016", "2017", "2018")),
}
register(Car, CarAutoFixture)
class PersonAutoFixture(AutoFixture):
field_values = {
'user':
AutoFixture.create('auth.User', 1, field_values={'is_superuser':
True}),
}
register(Person, PersonAutoFixture)
from models import Book
from autofixture import generators, register, AutoFixture
class BookAutoFixture(AutoFixture):
field_values = {
'name': generators.StaticGenerator('trial static name'),
}
register(Book, BookAutoFixture)
from autofixture import AutoFixture
from autofixture import register
from .models import Module
class ModuleAutoFixture(AutoFixture):
follow_pk = True
register(Module, ModuleAutoFixture)
import autofixture
from autofixture import AutoFixture
GlazeLookupFixture = AutoFixture(GlazeLookup, --overwrite-defaults = True, )
class GlazeLookupFixture(AutoFixture):
class Values:
glaze_description = generators.StringGenerator(self, chars=None, multiline=False,
min_length=10, max_length= 30)
glaze_name = generators.ChoicesGenerator(
values="aqua,black,blue,fuchsia,gray,green,lime,maroon,navy, olive,orange,purple,red,silver,teal,white,yellow".split(',')
)
glaze_begin_date = generators.DateTimeGenerator(
min_date=datetime(2009,1,1),
max_date=datetime(2009,12,31))
glaze_end_date = generators.DateTimeGenerator(
min_date=datetime(2009,1,1),
max_date=datetime(2009,12,31))
autofixture.register(GlazeLookup, GlazeLookupFixture, overwrite=False, fail_silently=False)
from sales.models import Orders, Categories, Suppliers, Products, OrderDetail
from autofixture import generators, register, AutoFixture
class CategoriesFixture(AutoFixture):
field_values = {
'name': generators.FirstNameGenerator(),
'description': generators.LoremGenerator(),
#'picture' : generators.ImageGenerator()
}
register(Categories, CategoriesFixture)
from snip.models import Piece, Condition, PublicationLookup, publication_link_piece, ExhibitionLookup, exhibition_link_piece, Documentation, documentation_link_piece, GlazeLookup, glaze_link_piece, HeathLineLookup, heath_line_link_piece, Logo,logo_link_piece, MakerLookup, maker_link_piece, MaterialLookup, material_link_piece, MethodLookup, method_link_piece, SetCollection, setCollection_link_piece
#from snip.models import Piece, ExhibitionLookup, GlazeLookup, glaze_link_piece, HeathLineLookup, heath_line_link_piece, MakerLookup, maker_link_piece, MaterialLookup, material_link_piece, MethodLookup, method_link_piece
from autofixture import generators, register, AutoFixture
class PieceAutoFixture(AutoFixture):
field_values = {
'cataloguer': generators.ChoicesGenerator(
values="Erminia Galdamez, Angila Weekly,  Milton Burnley,  Earle Hampshire,  Lael Warford,  Leilani Dennis,  Porsha Nodine,  Tammie Wert,  Tonie Schweinsberg,  Meryl Belville,  Latricia Landrum,  Margorie Galeano,  Josiah Torgrimson,  Kurt Picklesimer, Veola Callaham, Rolf Humphery,  Shari Carpenter , Belen Hott  ".split(',')
)
}
register(Piece, PieceAutoFixture)
class GlazeLookupAutoFixture(AutoFixture):
field_values = {
'glaze_name': generators.ChoicesGenerator(
values="aqua,black,blue,fuchsia,gray,green,lime,maroon,navy, olive,orange,purple,red,silver,teal,white,yellow".split(',')
)
}
register(GlazeLookup, GlazeLookupAutoFixture)
class HeathLineLookupAutoFixture(AutoFixture):
field_values = {
'heath_line_name': generators.ChoicesGenerator(
values="Coupe, Rim, Chez Pannise, Alabama Chanin".split(',')
)
}
import datetime
from autofixture import generators, register, AutoFixture
from topics.models import Vote
class DateTimeGenerator(generators.DateTimeGenerator):
min_date = datetime.datetime(2011, 1, 1, 0, 0)
max_date = datetime.datetime(2012, 12, 1, 0, 0)
class VoteAutoFixture(AutoFixture):
field_values = {
'date': DateTimeGenerator(),
}
register(Vote, VoteAutoFixture)
'name':
generators.ChoicesGenerator(values=(
"Iphone",
"Sumsung",
"Xiaomi",
"Watches",
"Honor",
"Redmi",
)),
'description':
generators.ChoicesGenerator(values=("Some phone", "Very good",
"Best phone ever",
"Now on sale!")),
'price':
generators.ChoicesGenerator(values=('15.45', '2.00', '14.00',
'10.05')),
}
register(Product, ProductAutoFixture)
class CategoryAutoFixture(AutoFixture):
field_values = {
'name':
generators.ChoicesGenerator(values=("Phone", "Headphones", "Watches")),
}
register(Category, CategoryAutoFixture)
def test_using_registry(self):
autofixture.register(SimpleModel, SimpleAutoFixture)
self.call('autofixture_tests.SimpleModel:10')
for obj in SimpleModel.objects.all():
self.assertEqual(obj.name, 'foo')
#from somepots.models import Piece, Condition, PublicationLookup, publication_link_piece, ExhibitionLookup, exhibition_link_piece, Documentation, documentation_link_piece, GlazeLookup, glaze_link_piece, HeathLineLookup, heath_line_link_piece, Logo,logo_link_piece, MakerLookup, maker_link_piece, MaterialLookup, material_link_piece, MethodLookup, method_link_piece, SetCollection, setCollection_link_piece
from somepots.models import Piece, GlazeLookup, glaze_link_piece, HeathLineLookup, heath_line_link_piece, MakerLookup, maker_link_piece, MaterialLookup, material_link_piece, MethodLookup, method_link_piece
from autofixture import generators, register, AutoFixture
class GlazeLookupAutoFixture(AutoFixture):
field_values = {
'glaze_name': generators.ChoicesGenerator(
values="aqua,black,blue,fuchsia,gray,green,lime,maroon,navy, olive,orange,purple,red,silver,teal,white,yellow".split(',')
)
}
register(GlazeLookup, GlazeLookupAutoFixture)
class HeathLineLookupAutoFixture(AutoFixture):
field_values = {
'heath_line_name': generators.ChoicesGenerator(
values="Coupe, Rim, Chez Pannise, Alabama Chanin".split(',')
)
}
register(HeathLineLookup, HeathLineLookupAutoFixture)
class MakerLookupAutoFixture(AutoFixture):
field_values = {
'maker_name': generators.ChoicesGenerator(
values="Erminia Galdamez, Angila Weekly,  Milton Burnley,  Earle Hampshire,  Lael Warford,  Leilani Dennis,  Porsha Nodine,  Tammie Wert,  Tonie Schweinsberg,  Meryl Belville,  Latricia Landrum,  Margorie Galeano,  Josiah Torgrimson,  Kurt Picklesimer, Veola Callaham, Rolf Humphery,  Shari Carpenter , Belen Hott  ".split(',')
)
}
import string
from autofixture import generators, register, AutoFixture
from fairsharing.models import FairsharingRecord
from django_prototype.settings import DATACITE_PREFIX
def generate_doi(prefix, size=6):
suffix = ''.join(
random.choice(string.ascii_uppercase + string.ascii_lowercase +
string.digits) for _ in range(size))
return '%s/FAIRsharing.%s' % (prefix, suffix)
####################################
# The actual records themselves... #
####################################
class FairsharingRecordAutoFixture(AutoFixture):
field_values = {
'name': generators.StringGenerator(max_length=10, min_length=8),
'abbreviation': generators.StringGenerator(max_length=3, min_length=2),
'homepage': generators.URLGenerator(),
'description': generators.LoremGenerator(),
'doi': generators.StaticGenerator(generate_doi(DATACITE_PREFIX))
}
register(FairsharingRecord, FairsharingRecordAutoFixture)
from django.core.management.base import NoArgsCommand
from django.conf import settings
from selvbetjening.core.user.models import SUser
from selvbetjening.core.events.models import Event, Group, Attend, OptionGroup, Option, Selection
import autofixture
from autofixture import generators
class EventAutoFixture(autofixture.AutoFixture):
field_values = {
'title': generators.LoremSentenceGenerator(max_length=30)
}
autofixture.register(Event, EventAutoFixture)
class GroupAutoFixture(autofixture.AutoFixture):
field_values = {
'name': generators.LoremWordGenerator(max_length=10)
}
autofixture.register(Group, GroupAutoFixture)
class Command(NoArgsCommand):
def handle_noargs(self, **options):
if not settings.DEBUG:
from sales.models import Orders, Categories, Suppliers, Products, OrderDetail
from autofixture import generators, register, AutoFixture
class CategoriesFixture(AutoFixture):
field_values = {
'name' : generators.FirstNameGenerator(),
'description' : generators.LoremGenerator(),
#'picture' : generators.ImageGenerator()
}
register(Categories, CategoriesFixture)
def test_create(self):
autofixture.register(SimpleModel, SimpleAutoFixture)
for obj in autofixture.create(SimpleModel, 10):
self.assertEqual(obj.name, 'foo')
obj = autofixture.create_one(SimpleModel)
self.assertEqual(obj.name, 'foo')
from autofixture import AutoFixture, generators, register
from faker import Factory
from .models import Idea
fake = Factory.create()
class IdeaAutoFixture(AutoFixture):
IMAGESIZES = ((1300, 600),)
field_values = {
'name': generators.CallableGenerator(fake.company),
'description': generators.CallableGenerator(fake.text),
'image': generators.ImageGenerator(sizes=IMAGESIZES),
}
follow_pk = True
register(Idea, IdeaAutoFixture)
from contactos.models import Contacto
from autofixture import generators, register, AutoFixture
from random import randint
class ContactoAutoFixture(AutoFixture):
field_values = {
'nombre': generators.FirstNameGenerator(),
'apellidos': generators.LastNameGenerator(),
'direccion': generators.StringGenerator(),
'telefono': '+' + str(randint(100000000000, 1000000000000))
}
register(Contacto, ContactoAutoFixture)
from autofixture import AutoFixture, generators, register
from faker import Factory
from .models import User
fake = Factory.create()
class UserAutoFixture(AutoFixture):
field_values = {
'username': generators.CallableGenerator(fake.name),
'_avatar': None
}
register(User, UserAutoFixture)
def test_registration(self):
autofixture.register(SimpleModel, SimpleAutoFixture)
self.assertTrue(SimpleModel in autofixture.REGISTRY)
self.assertEqual(autofixture.REGISTRY[SimpleModel], SimpleAutoFixture)
'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']
def generate(self):
return random.choice(self.surname)
class UserAutoFixture(AutoFixture):
field_values = {
'email' : generators.EmailGenerator(static_domain='example.com'),
'firstname' : FirstNameGenerator(),
'lastname' : LastNameGenerator()
}
register(User, UserAutoFixture)
class TraineeAutoFixture(AutoFixture):
field_values = {
}
register(Trainee, TraineeAutoFixture)
class TrainingAssistantAutoFixture(AutoFixture):
field_values = {
}
register(TrainingAssistant, TrainingAssistantAutoFixture)
def test_create(self):
autofixture.register(SimpleModel, SimpleAutoFixture)
for obj in autofixture.create(SimpleModel, 10):
self.assertEqual(obj.name, 'foo')
obj = autofixture.create_one(SimpleModel)
self.assertEqual(obj.name, 'foo')
from list.models import Category, Item
from autofixture import generators, register, AutoFixture
import random
nouns = ("Hardware", "Software", "Test-Software", "Test-Hardware", "Apps", "BigData",)
class CategoryFixture(AutoFixture):
field_values = {
'name' : generators.random.choice(nouns),
'slug' : generators.SlugGenerator('cidei'),
}
register(Category, CategoryFixture)
def price_constraint(self, model, instance):
last_bid = Bid.get_last_bid_by_auction(instance.auction)
minimum_price = 0
if last_bid is not None:
minimum_price = last_bid.price
else:
minimum_price = instance.auction.minimum_price
if instance.price <= minimum_price:
raise autofixture.InvalidConstraint((model._meta.get_field("price"),))
def prepare_class(self):
self.add_constraint(self.bidder_constraint)
# self.add_constraint(self.price_constraint)
def pre_process_instance(self, instance):
last_bid = Bid.get_last_bid_by_auction(instance.auction)
minimum_price = 0
if last_bid is not None:
minimum_price = last_bid.price
else:
minimum_price = instance.auction.minimum_price
if instance.price <= minimum_price:
instance.price = minimum_price + 1
return instance
autofixture.register(User, UserFixture, overwrite=True, fail_silently=False)
autofixture.register(Auction, AuctionFixture, fail_silently=False)
autofixture.register(Bid, BidFixture, fail_silently=False)
LOGOSIZES = ((400, 400),)
field_values = {
'name': generators.CallableGenerator(fake.company),
'slug': generators.CallableGenerator(fake.slug),
'image': generators.ImageGenerator(sizes=IMAGESIZES),
'logo': generators.ImageGenerator(sizes=LOGOSIZES),
'place': generators.CallableGenerator(fake.city),
'facebook_handle': 'LIQDeV',
'twitter_handle': 'bunnybuddhism',
'instragram_handle': 'insta.plane',
'webpage': 'https://example.com',
}
class OrganisationTranslationsAutoFixture(AutoFixture):
field_values = {
'title': generators.CallableGenerator(fake.company),
'description_why': generators.CallableGenerator(fake.text),
'description_how': generators.CallableGenerator(fake.text),
'description': generators.CallableGenerator(fake.text),
'language_code': 'en',
}
follow_fk = True
register(Organisation, OrganisationAutoFixture)
register(OrganisationTranslation, OrganisationTranslationsAutoFixture)
from autofixture import AutoFixture, register
from .models import Module
class ModuleAutoFixture(AutoFixture):
follow_pk = True
register(Module, ModuleAutoFixture)
class ProductAutoFixture(AutoFixture):
"""Fixture for Product generation."""
field_values = {
'article':
generators.StringGenerator(
chars=string.ascii_letters + string.digits + ' -',
max_length=Product._meta.get_field('article').max_length,
),
'cost':
generators.PositiveDecimalGenerator(
max_digits=Product._meta.get_field('cost').max_digits,
decimal_places=Product._meta.get_field('cost').decimal_places,
),
'price':
generators.PositiveDecimalGenerator(
max_digits=Product._meta.get_field('price').max_digits,
decimal_places=Product._meta.get_field('price').decimal_places,
),
'count':
generators.PositiveDecimalGenerator(
max_digits=Product._meta.get_field('count').max_digits,
decimal_places=Product._meta.get_field('count').decimal_places,
),
}
register(Product, ProductAutoFixture)
from autofixture import AutoFixture, generators, register
from .models import Product
class ProductAutoFixture(AutoFixture):
"""Fixture for Product generation."""
field_values = {
'article': generators.StringGenerator(
chars=string.ascii_letters + string.digits + ' -',
max_length=Product._meta.get_field('article').max_length,
),
'cost': generators.PositiveDecimalGenerator(
max_digits=Product._meta.get_field('cost').max_digits,
decimal_places=Product._meta.get_field('cost').decimal_places,
),
'price': generators.PositiveDecimalGenerator(
max_digits=Product._meta.get_field('price').max_digits,
decimal_places=Product._meta.get_field('price').decimal_places,
),
'count': generators.PositiveDecimalGenerator(
max_digits=Product._meta.get_field('count').max_digits,
decimal_places=Product._meta.get_field('count').decimal_places,
),
}
register(Product, ProductAutoFixture)
can provide a ``username`` and a ``password`` argument. Then you can do
something like::
autofixture.create_one('auth.User', username='******', password='******'foo', password='******')
'''
self.username = kwargs.pop('username', None)
self.password = kwargs.pop('password', None)
super(UserFixture, self).__init__(*args, **kwargs)
if self.username:
self.field_values['username'] = generators.StaticGenerator(
self.username)
def unique_email(self, model, instance):
if User.objects.filter(email=instance.email):
raise autofixture.InvalidConstraint(('email',))
def prepare_class(self):
self.add_constraint(self.unique_email)
def post_process_instance(self, instance):
# make sure user's last login was not before he joined
if instance.last_login < instance.date_joined:
instance.last_login = instance.date_joined
if self.password:
instance.set_password(self.password)
return instance
autofixture.register(User, UserFixture, fail_silently=True)
about = 'About Skill'
level = random.choice(LEVELS)
#class JobSeekerProfileAutoFixture(AutoFixture):
# It generates test data for the JobSeekerProfile Model
# The field_values is a dictionary with field names of model as keys.
#
# """
# class Values:
# about = 'About Job Seeker'
# user = generators.InstanceGenerator(UserFixture)
# dob = generators.DateGenerator(max_date=(datetime.date.today() - datetime.timedelta(365 * 20)))
# mobile = '0702006545'
# experience = random.choice(EXPERIENCE)
# industry = random.choice(INDUSTRIES)
# edu = random.choice(EDU)
# gender = random.choice(GENDERS)
# location = random.choice(LOCATIONS)
# skills = random.choice(JobSkill.objects.all())
# ============================================================================
# autofixture registration
# ============================================================================
register(JobSkill, JobSkillAutoFixture)
# register(JobSeekerProfile, JobSeekerProfileAutoFixture)
# ============================================================================
# EOF
# ============================================================================
def test_registration(self):
autofixture.register(SimpleModel, SimpleAutoFixture)
self.assertTrue(SimpleModel in autofixture.REGISTRY)
self.assertEqual(autofixture.REGISTRY[SimpleModel], SimpleAutoFixture)
'launched':
generators.DateTimeGenerator(min_date=datetime(1950, 1, 1),
max_date=datetime(2015, 12, 31)),
'type':
generators.ChoicesGenerator(values=('se', '4x', 'co', 'br')),
}
class ManufacturerAutoFixture(AutoFixture):
field_values = {
'name':
generators.StringGenerator(min_length=3, max_length=12),
'created':
generators.DateTimeGenerator(min_date=datetime(1900, 1, 1),
max_date=datetime(2015, 12, 31)),
'country_code':
generators.ChoicesGenerator(values=(COUNTRIES.keys())),
}
class AdAutoFixture(AutoFixture):
field_values = {
'title': generators.LoremWordGenerator(),
'description': generators.LoremHTMLGenerator(),
}
register(Car, CarAutoFixture)
register(Manufacturer, ManufacturerAutoFixture)
register(Ad, AdAutoFixture)
import autofixture
from autofixture import AutoFixture, generators
from models import *
from datetime import datetime
print 'Setting up CMS fixtures'
CourseFixture = AutoFixture(Course,
field_values={
'name': generators.LoremWordGenerator(count=2)
,'full_name': generators.LoremSentenceGenerator()
,'description': generators.LoremHTMLGenerator()
,'schedule_no': generators.PositiveIntegerGenerator(min_value=222222)
,'start_date': generators.DateGenerator(max_date=datetime.today())
,'end_date': generators.DateGenerator(min_date=datetime.today())
,'active': generators.StaticGenerator(True)
}
)
autofixture.register(Course, CourseFixture)
courses = autofixture.create(Course, 3)
print courses
LOGOSIZES = ((400, 400), )
field_values = {
'name': generators.CallableGenerator(fake.company),
'slug': generators.CallableGenerator(fake.slug),
'image': generators.ImageGenerator(sizes=IMAGESIZES),
'logo': generators.ImageGenerator(sizes=LOGOSIZES),
'place': generators.CallableGenerator(fake.city),
'facebook_handle': 'LIQDeV',
'twitter_handle': 'bunnybuddhism',
'instragram_handle': 'insta.plane',
'webpage': 'https://example.com',
}
class OrganisationTranslationsAutoFixture(AutoFixture):
field_values = {
'title': generators.CallableGenerator(fake.company),
'description_why': generators.CallableGenerator(fake.text),
'description_how': generators.CallableGenerator(fake.text),
'description': generators.CallableGenerator(fake.text),
'language_code': 'en',
}
follow_fk = True
register(Organisation, OrganisationAutoFixture)
register(OrganisationTranslation, OrganisationTranslationsAutoFixture)
def test_using_registry(self):
autofixture.register(SimpleModel, SimpleAutoFixture)
models = ('autofixture_test.SimpleModel:10',)
self.command.handle(*models, **self.options)
for obj in SimpleModel.objects.all():
self.assertEqual(obj.name, 'foo')
""" Clase para crear informacion para el modelo Customer """
class CustomerFixture(AutoFixture):
field_values = {
'customer_name': generators.FirstNameGenerator(),
'customer_address': generators.SmallIntegerGenerator(min_value=1240, max_value=9999),
'customer_phone': generators.IntegerGenerator(min_value=124000, max_value=9999999)
}
class ProductFixture(AutoFixture):
field_values = {
'product_name': generators.StaticGenerator(products),
'product_price': generators.PositiveIntegerGenerator(),
'product_type': generators.random.choice(types),
'product_description': generators.LoremGenerator()
}
class StockFixture(AutoFixture):
field_values = {
'stock_quatity': generators.SmallIntegerGenerator(min_value=1240, max_value=9999)
}
class OrderFixture(AutoFixture):
field_values = {
'order_amount': generators.SmallIntegerGenerator(min_value=1, max_value=10)
}
""" Asociando modelo a clase para generar informacion """
register(Customer, CustomerFixture)
register(Product, ProductFixture)
register(Stock, StockFixture)
register(Order, OrderFixture)
from autofixture import generators, register, AutoFixture
from .models import SummaryNote
class SummaryNoteAutoFixtures(AutoFixture):
field_values = {
'title': generators.LoremWordGenerator(),
'content': generators.LoremHTMLGenerator(),
}
register(SummaryNote, SummaryNoteAutoFixtures)
class CarAutoFixture(AutoFixture):
field_values = {
'model_year': generators.DateGenerator(),
'registered_day': generators.DateGenerator(),
'color': generators.ChoicesGenerator(COLOR_CHOICES),
'fuel': generators.ChoicesGenerator(Car.FUEL_CHOICES),
'sub_model': generators.ChoicesGenerator(SUB_MODEL_CHOICES),
'gear': generators.ChoicesGenerator(Car.GEAR_CHOICES),
'kms': generators.PositiveIntegerGenerator(),
'region': generators.ChoicesGenerator(REGION_CHOICE),
'status': generators.ChoicesGenerator(Car.STATUS_CHOICES),
}
register(Car, CarAutoFixture)
#
# model_year = YearMonthField(max_length=20)
# registered_day = models.DateTimeField('Registered Date')
# brand = models.CharField(max_length=100)
# type = models.CharField(max_length=100)
# model = models.CharField(max_length=100)
# color = models.CharField(max_length=20)
# fuel = models.CharField(
# max_length=6,
# choices=FUEL_CHOICES,
# default=GASOLINE,
# )
# gear = models.CharField(
# max_length=4,
# choices=GEAR_CHOICES,
from autofixture import AutoFixture, generators, register
from django.contrib.contenttypes.models import ContentType
from home.models import HomePage
from .models import Comment
class CommentAutoFixture(AutoFixture):
homepage_contenttype = ContentType.objects.get(app_label='home',
model='homepage')
homepage_id = HomePage.objects.first().pk
field_values = {
'content_type': homepage_contenttype,
'object_pk': homepage_id,
'is_removed': generators.BooleanGenerator(),
'is_censored': generators.BooleanGenerator(),
}
register(Comment, CommentAutoFixture)
import autofixture
from .models import TestModel
class CustomTestModelFixture(autofixture.AutoFixture):
pass
autofixture.register(TestModel, CustomTestModelFixture)
from autofixture import register, AutoFixture
from .models import Region
class RegionAutoFixture(AutoFixture):
overwrite_defaults = True
field_values = {
'regional_groups': None,
'key_figures': None,
'population_data': None,
'media_sources': None,
}
# def post_process_instance(self, instance, commit):
# pass
register(Region, RegionAutoFixture)
class Post(models.Model):
title = models.CharField(_("title"), max_length=200)
content = models.TextField(_("content"), help_text=u"Markdown is available http://pl.wikipedia.org/wiki/Markdown")
create_time = models.DateTimeField(_("create time"), auto_now_add=True, db_index=True)
update_time = models.DateTimeField(_("update time"), auto_now=True)
author = models.ForeignKey(User, verbose_name=_("author"), related_name="posts")
tags = TagField()
class Meta:
verbose_name = _("post")
verbose_name_plural = _("posts")
get_latest_by = "create_time"
ordering = ("-create_time",)
def __unicode__(self):
return self.title
def get_absolute_url(self):
return reverse("posts.detail", args=(slugify(self.title), self.id))
def set_tags(self, tags):
Tag.objects.update_tags(self, tags)
def get_tags(self):
return Tag.objects.get_for_object(self)
autofixture.register(Post, PostFixture)
num2=generators.SmallIntegerGenerator().generate()).lower(),
'password':
'******'
}
return self.USER_MODEL.objects.create_user(**defaults)
class AuthorFixture(AutoFixture):
field_values = {
'user': UserGenerator(),
'name': generators.FirstNameGenerator(),
'age': generators.PositiveIntegerGenerator(min_value=20, max_value=80)
}
register(Author, AuthorFixture, overwrite=True)
class PublisherFixture(AutoFixture):
field_values = {
'name':
PublisherGenerator(),
'num_awards':
generators.PositiveIntegerGenerator(min_value=0, max_value=10)
}
register(Publisher, PublisherFixture, overwrite=True)
class BookFixture(AutoFixture):
def test_using_registry(self):
autofixture.register(SimpleModel, SimpleAutoFixture)
models = ('autofixture_test.SimpleModel:10', )
self.command.handle(*models, **self.options)
for obj in SimpleModel.objects.all():
self.assertEqual(obj.name, 'foo')
'''
self.username = kwargs.pop('username', None)
self.password = kwargs.pop('password', None)
super(UserFixture, self).__init__(*args, **kwargs)
if self.username:
self.field_values['username'] = generators.StaticGenerator(
self.username)
def unique_email(self, model, instance):
if User.objects.filter(email=instance.email):
raise autofixture.InvalidConstraint(('email', ))
def prepare_class(self):
self.add_constraint(self.unique_email)
def post_process_instance(self, instance, commit):
# make sure user's last login was not before he joined
changed = False
if instance.last_login < instance.date_joined:
instance.last_login = instance.date_joined
changed = True
if self.password:
instance.set_password(self.password)
changed = True
if changed and commit:
instance.save()
return instance
autofixture.register(User, UserFixture, fail_silently=True)
from autofixture import AutoFixture, generators, register
from faker import Factory
from .models import User
fake = Factory.create()
class UserAutoFixture(AutoFixture):
field_values = {
'username': generators.CallableGenerator(fake.name)
}
register(User, UserAutoFixture)
'url': '',
'website': '',
'attachment': None,
}
def post_process_instance(self, instance, commit):
choice = random.randint(1, 2)
if choice == 1:
instance.text = generators.LoremGenerator().generate()
else:
instance.url = generators.URLGenerator().generate()
instance.website = urlparse(instance.url).netloc
instance.save()
register(Lead, LeadAutoFixture)
# Since autofixture is quite slow, create a method to use to generate
# large number of leads more efficiently
def create_many_leads(num, created_by, project):
leads = []
for i in range(num):
lead = Lead()
lead.title = generators.LoremGenerator(max_length=20).generate()
lead.project = project
lead.created_by = created_by
lead.modified_by = created_by
lead.status = random.choice(['pending', 'processed'])
lead.condidentiality = random.choice([
'unprotected',
from autofixture import AutoFixture
from autofixture import constraints
from autofixture import generators
from autofixture import register
from faker import Factory
from . import content
from . import models
fake = Factory.create()
def only_two_phases_per_module(model, instance):
if instance.module.phase_set.count() >= 2:
raise constraints.InvalidConstraint(['module'])
class PhaseAutoFixture(AutoFixture):
field_values = {
'name': generators.CallableGenerator(fake.company),
'type': generators.ChoicesGenerator(choices=content.as_choices()),
}
follow_pk = True
constraints = (only_two_phases_per_module)
register(models.Phase, PhaseAutoFixture)
