class ReviewTestCase(TestCase):
def setUp(self):
self.factory = Factory()
def test_average_rating(self):
meal = self.factory.create(food_models.Meal)
review1_init = {'rating': 1, 'meal': meal}
review2_init = {'rating': 2, 'meal': meal}
self.factory.create(models.Review, (review1_init, review2_init))
expected_results = '1.5 Stars'
self.assertEqual(models.Review.average_rating(meal), expected_results)
def test_create_with_multi_model_and_multi_count(self):
models = ModelOne.objects.all()
self.assertEqual(len(models), 0)
models = ModelTwo.objects.all()
self.assertEqual(len(models), 0)
factory = Factory()
count1 = 2
count2 = 3
args = ((ModelOne, count1), (ModelTwo, count2))
models = factory.create(*args)
self.assertEqual(len(models), count1 + count2)
self.assertIsInstance(models[0], ModelOne)
self.assertIsInstance(models[1], ModelOne)
self.assertIsInstance(models[2], ModelTwo)
self.assertIsInstance(models[3], ModelTwo)
self.assertIsInstance(models[4], ModelTwo)
# Since ModelTwo has a FK and OneToOne to ModelOne we expect:
# 1 for the count in the factory models (count1)
# 1 for each OneToOne fields (count2)
models = ModelOne.objects.all()
self.assertEqual(len(models), count1 + count2)
models = ModelTwo.objects.all()
self.assertEqual(len(models), count2)
def test_create_with_multi_model_and_single_count_and_single_initial(self):
models = ModelOne.objects.all()
self.assertEqual(len(models), 0)
models = ModelTwo.objects.all()
self.assertEqual(len(models), 0)
factory = Factory()
initial1 = {
'decimal_field': Decimal('10.00')
}
initial2 = {
'char_field': 'test value'
}
args = ((ModelOne, initial1), (ModelTwo, initial2))
models = factory.create(*args)
self.assertIsInstance(models[0], ModelOne)
self.assertEqual(models[0].decimal_field, initial1['decimal_field'])
self.assertIsInstance(models[1], ModelTwo)
self.assertEqual(models[1].char_field, initial2['char_field'])
# Since ModelTwo has a FK and OneToOne to ModelOne we expect:
# 1 for the count in the factory models
# 1 for each OneToOne fields
models = ModelOne.objects.all()
self.assertEqual(len(models), 2)
models = ModelTwo.objects.all()
self.assertEqual(len(models), 1)
def test_create_with_multi_model_and_multi_count(self):
models = ModelOne.objects.all()
self.assertEqual(len(models), 0)
models = ModelTwo.objects.all()
self.assertEqual(len(models), 0)
factory = Factory()
count1 = 2
count2 = 3
args = ((ModelOne, count1), (ModelTwo, count2))
models = factory.create(*args)
self.assertEqual(len(models), count1 + count2)
self.assertIsInstance(models[0], ModelOne)
self.assertIsInstance(models[1], ModelOne)
self.assertIsInstance(models[2], ModelTwo)
self.assertIsInstance(models[3], ModelTwo)
self.assertIsInstance(models[4], ModelTwo)
# Since ModelTwo has a FK and OneToOne to ModelOne we expect:
# 1 for the count in the factory models (count1)
# 1 for each OneToOne fields (count2)
models = ModelOne.objects.all()
self.assertEqual(len(models), count1 + count2)
models = ModelTwo.objects.all()
self.assertEqual(len(models), count2)
def test_create_with_multi_model_and_multi_count_and_multi_initial(self):
models = ModelOne.objects.all()
self.assertEqual(len(models), 0)
models = ModelTwo.objects.all()
self.assertEqual(len(models), 0)
factory = Factory()
initial1_1 = {'decimal_field': Decimal('10.00')}
initial1_2 = {'decimal_field': Decimal('8.00')}
initial2_1 = {'char_field': 'test value 1'}
initial2_2 = {'char_field': 'test value 2'}
args = ((ModelOne, [initial1_1,
initial1_2]), (ModelTwo, [initial2_1, initial2_2]))
models = factory.create(*args)
self.assertEqual(len(models), 4)
self.assertIsInstance(models[0], ModelOne)
self.assertIsInstance(models[1], ModelOne)
self.assertEqual(models[0].decimal_field, initial1_1['decimal_field'])
self.assertEqual(models[1].decimal_field, initial1_2['decimal_field'])
self.assertIsInstance(models[2], ModelTwo)
self.assertIsInstance(models[3], ModelTwo)
self.assertEqual(models[2].char_field, initial2_1['char_field'])
self.assertEqual(models[3].char_field, initial2_2['char_field'])
# Since ModelTwo has a FK and OneToOne to ModelOne we expect:
# 1 for the count in the factory models (count1)
# 1 for each OneToOne fields (count2)
models = ModelOne.objects.all()
self.assertEqual(len(models), 4)
models = ModelTwo.objects.all()
self.assertEqual(len(models), 2)
class SuperSnazzyModelTests(TestCase):
def setUp(self):
self.factory = Factory()
def test_sum_fib_nums(self):
initial = {
'fib_index': 0,
'fib_num': '1000',
}
fib_history = self.factory.create(FibHistory, initial)
self.assertEqual(fib_history.do_something_pointless(), 0)
initial = {
'fib_index': 100,
'fib_num': 10,
}
fib_history = self.factory.create(FibHistory, initial)
self.assertEqual(fib_history.do_something_pointless(), 1000)
def test_create_trivial(self):
models = ModelOne.objects.all()
self.assertEqual(len(models), 0)
factory = Factory()
model = factory.create(ModelOne)
self.assertIsInstance(model, ModelOne)
models = ModelOne.objects.all()
self.assertEqual(len(models), 1)
def test_create_trivial(self):
models = ModelOne.objects.all()
self.assertEqual(len(models), 0)
factory = Factory()
model = factory.create(ModelOne)
self.assertIsInstance(model, ModelOne)
models = ModelOne.objects.all()
self.assertEqual(len(models), 1)
class MageTestCase(TestCase):
def setUp(self):
self.factory = Factory()
def test_brothers_in_arms(self):
# Exclude the mage itself
mage_1 = self.factory.create(
models.Mage, {'magic_type': constants.ARCANE})
expected = 0
self.assertEqual(mage_1.brothers_in_arms.count(), expected)
# Let's add another mage with another magic_type
self.factory.create(models.Mage, {'magic_type': constants.BLACK})
expected = 0
self.assertEqual(mage_1.brothers_in_arms.count(), expected)
# Let's add another mage with the same magic_type
self.factory.create(models.Mage, {'magic_type': constants.ARCANE})
expected = 1
self.assertEqual(mage_1.brothers_in_arms.count(), expected)
def test_create_with_single_count(self):
models = ModelOne.objects.all()
self.assertEqual(len(models), 0)
factory = Factory()
count = 1
args = (ModelOne, count)
model = factory.create(*args)
self.assertIsInstance(model, ModelOne)
models = ModelOne.objects.all()
self.assertEqual(len(models), count)
def test_create_with_single_count(self):
models = ModelOne.objects.all()
self.assertEqual(len(models), 0)
factory = Factory()
count = 1
args = (ModelOne, count)
model = factory.create(*args)
self.assertIsInstance(model, ModelOne)
models = ModelOne.objects.all()
self.assertEqual(len(models), count)
def test_create_with_count_and_initial(self):
models = ModelOne.objects.all()
self.assertEqual(len(models), 0)
factory = Factory()
initial = {'decimal_field': Decimal('10.00')}
args = (ModelOne, initial)
model = factory.create(*args)
self.assertIsInstance(model, ModelOne)
self.assertEqual(model.decimal_field, initial['decimal_field'])
models = ModelOne.objects.all()
self.assertEqual(len(models), 1)
def create_question(question_text='', days=None, time=None):
"""
Creates a question with the given `question_text` and published the
given number of `days` offset to now (negative for questions published
in the past, positive for questions that have yet to be published).
"""
factory = Factory()
if not time:
time = timezone.now() + datetime.timedelta(days=days)
initial = {
'question_text': question_text,
'pub_date': time,
}
return factory.create(Question, initial)
def create_question(question_text='', days=None, time=None):
"""
Creates a question with the given `question_text` and published the
given number of `days` offset to now (negative for questions published
in the past, positive for questions that have yet to be published).
"""
factory = Factory()
if not time:
time = timezone.now() + datetime.timedelta(days=days)
initial = {
'question_text': question_text,
'pub_date': time,
}
return factory.create(Question, initial)
def test_create_with_count_and_initial(self):
models = ModelOne.objects.all()
self.assertEqual(len(models), 0)
factory = Factory()
initial = {
'decimal_field': Decimal('10.00')
}
args = (ModelOne, initial)
model = factory.create(*args)
self.assertIsInstance(model, ModelOne)
self.assertEqual(model.decimal_field, initial['decimal_field'])
models = ModelOne.objects.all()
self.assertEqual(len(models), 1)
def test_create_with_multi_count(self):
models = ModelOne.objects.all()
self.assertEqual(len(models), 0)
factory = Factory()
count = 2
args = (ModelOne, count)
models = factory.create(*args)
self.assertEqual(len(models), count)
self.assertIsInstance(models[0], ModelOne)
self.assertIsInstance(models[1], ModelOne)
self.assertNotEqual(models[0], models[1])
models = ModelOne.objects.all()
self.assertEqual(len(models), count)
def test_create_with_multi_count(self):
models = ModelOne.objects.all()
self.assertEqual(len(models), 0)
factory = Factory()
count = 2
args = (ModelOne, count)
models = factory.create(*args)
self.assertEqual(len(models), count)
self.assertIsInstance(models[0], ModelOne)
self.assertIsInstance(models[1], ModelOne)
self.assertNotEqual(models[0], models[1])
models = ModelOne.objects.all()
self.assertEqual(len(models), count)
def test_create_with_multi_model_trivial(self):
models = ModelOne.objects.all()
self.assertEqual(len(models), 0)
models = ModelTwo.objects.all()
self.assertEqual(len(models), 0)
factory = Factory()
models = factory.create((ModelOne, ), (ModelTwo, ))
self.assertEqual(len(models), 2)
self.assertIsInstance(models[0], ModelOne)
self.assertIsInstance(models[1], ModelTwo)
# Since ModelTwo has a FK and OneToOne to ModelOne we expect 2
models = ModelOne.objects.all()
self.assertEqual(len(models), 2)
models = ModelTwo.objects.all()
self.assertEqual(len(models), 1)
def test_create_with_multi_model_trivial(self):
models = ModelOne.objects.all()
self.assertEqual(len(models), 0)
models = ModelTwo.objects.all()
self.assertEqual(len(models), 0)
factory = Factory()
models = factory.create((ModelOne, ), (ModelTwo, ))
self.assertEqual(len(models), 2)
self.assertIsInstance(models[0], ModelOne)
self.assertIsInstance(models[1], ModelTwo)
# Since ModelTwo has a FK and OneToOne to ModelOne we expect 2
models = ModelOne.objects.all()
self.assertEqual(len(models), 2)
models = ModelTwo.objects.all()
self.assertEqual(len(models), 1)
def test_create_with_multi_count_and_multi_initial(self):
models = ModelOne.objects.all()
self.assertEqual(len(models), 0)
factory = Factory()
initial1 = {'decimal_field': Decimal('10.00')}
initial2 = {'decimal_field': Decimal('8.00')}
args = (ModelOne, [initial1, initial2])
models = factory.create(*args)
self.assertEqual(len(models), 2)
self.assertIsInstance(models[0], ModelOne)
self.assertEqual(models[0].decimal_field, initial1['decimal_field'])
self.assertIsInstance(models[1], ModelOne)
self.assertEqual(models[1].decimal_field, initial2['decimal_field'])
models = ModelOne.objects.all()
self.assertEqual(len(models), 2)
def test_create_with_multi_model_and_multi_count_and_single_initial(self):
models = ModelOne.objects.all()
self.assertEqual(len(models), 0)
models = ModelTwo.objects.all()
self.assertEqual(len(models), 0)
factory = Factory()
count1 = 2
initial1 = {
'decimal_field': Decimal('10.00')
}
initial_list1 = list()
for _ in itertools.repeat(None, count1):
initial_list1.append(initial1)
count2 = 3
initial2 = {
'char_field': 'test value'
}
initial_list2 = list()
for _ in itertools.repeat(None, count2):
initial_list2.append(initial2)
args = ((ModelOne, initial_list1), (ModelTwo, initial_list2))
models = factory.create(*args)
self.assertEqual(len(models), count1 + count2)
self.assertIsInstance(models[0], ModelOne)
self.assertIsInstance(models[1], ModelOne)
self.assertEqual(models[0].decimal_field, initial1['decimal_field'])
self.assertEqual(models[1].decimal_field, initial1['decimal_field'])
self.assertIsInstance(models[2], ModelTwo)
self.assertIsInstance(models[3], ModelTwo)
self.assertIsInstance(models[4], ModelTwo)
self.assertEqual(models[2].char_field, initial2['char_field'])
self.assertEqual(models[3].char_field, initial2['char_field'])
self.assertEqual(models[4].char_field, initial2['char_field'])
# Since ModelTwo has a FK and OneToOne to ModelOne we expect:
# 1 for the count in the factory models (count1)
# 1 for each OneToOne fields (count2)
models = ModelOne.objects.all()
self.assertEqual(len(models), count1 + count2)
models = ModelTwo.objects.all()
self.assertEqual(len(models), count2)
def test_create_with_multi_model_and_single_count(self):
models = ModelOne.objects.all()
self.assertEqual(len(models), 0)
models = ModelTwo.objects.all()
self.assertEqual(len(models), 0)
factory = Factory()
count1 = 1
count2 = 1
args = ((ModelOne, count1), (ModelTwo, count2))
models = factory.create(*args)
self.assertEqual(len(models), 2)
self.assertIsInstance(models[0], ModelOne)
self.assertIsInstance(models[1], ModelTwo)
# Since ModelTwo has a FK and OneToOne to ModelOne we expect 2
models = ModelOne.objects.all()
self.assertEqual(len(models), 2)
models = ModelTwo.objects.all()
self.assertEqual(len(models), 1)
def test_create_with_multi_model_and_single_count(self):
models = ModelOne.objects.all()
self.assertEqual(len(models), 0)
models = ModelTwo.objects.all()
self.assertEqual(len(models), 0)
factory = Factory()
count1 = 1
count2 = 1
args = ((ModelOne, count1), (ModelTwo, count2))
models = factory.create(*args)
self.assertEqual(len(models), 2)
self.assertIsInstance(models[0], ModelOne)
self.assertIsInstance(models[1], ModelTwo)
# Since ModelTwo has a FK and OneToOne to ModelOne we expect 2
models = ModelOne.objects.all()
self.assertEqual(len(models), 2)
models = ModelTwo.objects.all()
self.assertEqual(len(models), 1)
def test_create_with_multi_count_and_single_initial(self):
models = ModelOne.objects.all()
self.assertEqual(len(models), 0)
factory = Factory()
count = 2
initial1 = {'decimal_field': Decimal('10.00')}
initial_list = list()
for _ in itertools.repeat(None, count):
initial_list.append(initial1)
args = (ModelOne, initial_list)
models = factory.create(*args)
self.assertEqual(len(models), count)
self.assertIsInstance(models[0], ModelOne)
self.assertEqual(models[0].decimal_field, initial1['decimal_field'])
self.assertIsInstance(models[1], ModelOne)
self.assertEqual(models[1].decimal_field, initial1['decimal_field'])
models = ModelOne.objects.all()
self.assertEqual(len(models), count)
def test_create_with_multi_count_and_multi_initial(self):
models = ModelOne.objects.all()
self.assertEqual(len(models), 0)
factory = Factory()
initial1 = {
'decimal_field': Decimal('10.00')
}
initial2 = {
'decimal_field': Decimal('8.00')
}
args = (ModelOne, [initial1, initial2])
models = factory.create(*args)
self.assertEqual(len(models), 2)
self.assertIsInstance(models[0], ModelOne)
self.assertEqual(models[0].decimal_field, initial1['decimal_field'])
self.assertIsInstance(models[1], ModelOne)
self.assertEqual(models[1].decimal_field, initial2['decimal_field'])
models = ModelOne.objects.all()
self.assertEqual(len(models), 2)
def test_create_with_multi_model_and_multi_count_and_single_initial(self):
models = ModelOne.objects.all()
self.assertEqual(len(models), 0)
models = ModelTwo.objects.all()
self.assertEqual(len(models), 0)
factory = Factory()
count1 = 2
initial1 = {'decimal_field': Decimal('10.00')}
initial_list1 = list()
for _ in itertools.repeat(None, count1):
initial_list1.append(initial1)
count2 = 3
initial2 = {'char_field': 'test value'}
initial_list2 = list()
for _ in itertools.repeat(None, count2):
initial_list2.append(initial2)
args = ((ModelOne, initial_list1), (ModelTwo, initial_list2))
models = factory.create(*args)
self.assertEqual(len(models), count1 + count2)
self.assertIsInstance(models[0], ModelOne)
self.assertIsInstance(models[1], ModelOne)
self.assertEqual(models[0].decimal_field, initial1['decimal_field'])
self.assertEqual(models[1].decimal_field, initial1['decimal_field'])
self.assertIsInstance(models[2], ModelTwo)
self.assertIsInstance(models[3], ModelTwo)
self.assertIsInstance(models[4], ModelTwo)
self.assertEqual(models[2].char_field, initial2['char_field'])
self.assertEqual(models[3].char_field, initial2['char_field'])
self.assertEqual(models[4].char_field, initial2['char_field'])
# Since ModelTwo has a FK and OneToOne to ModelOne we expect:
# 1 for the count in the factory models (count1)
# 1 for each OneToOne fields (count2)
models = ModelOne.objects.all()
self.assertEqual(len(models), count1 + count2)
models = ModelTwo.objects.all()
self.assertEqual(len(models), count2)
def test_create_with_multi_model_and_multi_count_and_multi_initial(self):
models = ModelOne.objects.all()
self.assertEqual(len(models), 0)
models = ModelTwo.objects.all()
self.assertEqual(len(models), 0)
factory = Factory()
initial1_1 = {
'decimal_field': Decimal('10.00')
}
initial1_2 = {
'decimal_field': Decimal('8.00')
}
initial2_1 = {
'char_field': 'test value 1'
}
initial2_2 = {
'char_field': 'test value 2'
}
args = ((ModelOne, [initial1_1, initial1_2]),
(ModelTwo, [initial2_1, initial2_2]))
models = factory.create(*args)
self.assertEqual(len(models), 4)
self.assertIsInstance(models[0], ModelOne)
self.assertIsInstance(models[1], ModelOne)
self.assertEqual(models[0].decimal_field, initial1_1['decimal_field'])
self.assertEqual(models[1].decimal_field, initial1_2['decimal_field'])
self.assertIsInstance(models[2], ModelTwo)
self.assertIsInstance(models[3], ModelTwo)
self.assertEqual(models[2].char_field, initial2_1['char_field'])
self.assertEqual(models[3].char_field, initial2_2['char_field'])
# Since ModelTwo has a FK and OneToOne to ModelOne we expect:
# 1 for the count in the factory models (count1)
# 1 for each OneToOne fields (count2)
models = ModelOne.objects.all()
self.assertEqual(len(models), 4)
models = ModelTwo.objects.all()
self.assertEqual(len(models), 2)
def create_data(request):
from fixtureless import Factory
import itertools
factory = Factory()
initial = {"reliableGPS": False, "sponsored": True, "forCharity": False}
initial_list = list()
for _ in itertools.repeat(None, 20):
initial_list.append(initial)
users = factory.create(User, 10)
social = factory.create(Social, 10)
accounts = factory.create(AccountInfo, 10)
locations = factory.create(Location, initial_list)
payments = factory.create(Payment, 15)
votes1 = factory.create(Vote, 60)
comments = factory.create(Comment, 60)
return Response(status=status.HTTP_200_OK)
def test_create_with_multi_count_and_single_initial(self):
models = ModelOne.objects.all()
self.assertEqual(len(models), 0)
factory = Factory()
count = 2
initial1 = {
'decimal_field': Decimal('10.00')
}
initial_list = list()
for _ in itertools.repeat(None, count):
initial_list.append(initial1)
args = (ModelOne, initial_list)
models = factory.create(*args)
self.assertEqual(len(models), count)
self.assertIsInstance(models[0], ModelOne)
self.assertEqual(models[0].decimal_field, initial1['decimal_field'])
self.assertIsInstance(models[1], ModelOne)
self.assertEqual(models[1].decimal_field, initial1['decimal_field'])
models = ModelOne.objects.all()
self.assertEqual(len(models), count)
def test_create_with_multi_model_and_single_count_and_single_initial(self):
models = ModelOne.objects.all()
self.assertEqual(len(models), 0)
models = ModelTwo.objects.all()
self.assertEqual(len(models), 0)
factory = Factory()
initial1 = {'decimal_field': Decimal('10.00')}
initial2 = {'char_field': 'test value'}
args = ((ModelOne, initial1), (ModelTwo, initial2))
models = factory.create(*args)
self.assertIsInstance(models[0], ModelOne)
self.assertEqual(models[0].decimal_field, initial1['decimal_field'])
self.assertIsInstance(models[1], ModelTwo)
self.assertEqual(models[1].char_field, initial2['char_field'])
# Since ModelTwo has a FK and OneToOne to ModelOne we expect:
# 1 for the count in the factory models
# 1 for each OneToOne fields
models = ModelOne.objects.all()
self.assertEqual(len(models), 2)
models = ModelTwo.objects.all()
self.assertEqual(len(models), 1)
class Command(BaseCommand):
help = 'Populate the local DB with development data.'
args = '<mage count> <unicorn count>'
option_list = BaseCommand.option_list + (
make_option(
'--use_custom',
action='store_true',
default=False,
help='Have django-fixtureless use custom values instead of '
'random data. (default=False)',
),
make_option(
'--mage_count',
type='int',
default=5,
help='The number of mages you want in your system. (default=5)',
),
make_option(
'--unicorn_count',
type='int',
default=5,
help='The number of unicorns you want in your system. (default=5)',
),
make_option(
'--clear_db',
action='store_true',
default=False,
help='Clear the database to start fresh.',
),
)
MAGE_NAMES = ['rose', 'henry', 'alex', 'erica', 'ashley', 'bob', 'ted']
UNICORN_NAMES = ['charlie', 'stephanie', 'shannon', 'pat', 'brian']
def __init__(self):
models.Mage.objects.all().delete()
models.Unicorn.objects.all().delete()
self.factory = Factory()
super().__init__()
def _generate_mages(self, mage_count):
if self.use_custom:
initial_list = list()
for _ in itertools.repeat(None, mage_count):
initial_list.append({
'name': random.choice(self.MAGE_NAMES)
})
self.factory.create(models.Mage, initial_list)
else:
self.factory.create(models.Mage, mage_count)
def _generate_unicorns(self, unicorn_count):
initial_list = list()
for _ in itertools.repeat(None, unicorn_count):
initial_dict = {
'best_friend': random.choice(models.Mage.objects.all())
}
if self.use_custom:
initial_dict['name']= random.choice(self.UNICORN_NAMES)
initial_dict['age'] = random.randint(1, 50)
initial_list.append(initial_dict)
self.factory.create(models.Unicorn, initial_list)
def handle(self, *args, **options):
self.use_custom = options['use_custom']
if options['clear_db']:
return
mage_count = options['mage_count']
unicorn_count = options['unicorn_count']
self._generate_mages(mage_count)
self._generate_unicorns(unicorn_count)
class Command(BaseCommand):
help = 'Populate the local DB with meal data.'
option_list = BaseCommand.option_list + (
make_option(
'--meal_count',
type='int',
default=5,
help='The number of meals you want in your system. (default=5)',
),
make_option(
'--item_count',
type='int',
default=25,
help='The number of food items you want in your system. '
'(default=25)',
),
make_option(
'--clear_db',
action='store_true',
default=False,
help='Clear the database to start fresh.',
),
)
MEAL_NAMES = ['Hamburger', 'Enchilada', 'Spaghetti', 'Burrito', 'Omelette']
ITEM_NAMES = [
'beef patty', 'lettuce', 'bun', 'cheese', 'pickles', 'tomato',
'mustard', 'ketchup', 'mayonnaise', 'tortilla', 'sauce', 'chicken',
'rice', 'beans', 'noodles', 'meat balls', 'egg', 'avocado', 'mushroom'
]
def __init__(self):
food_models.Meal.objects.all().delete()
food_models.Item.objects.all().delete()
self.factory = Factory()
super().__init__()
def _generate_meals(self, meal_count):
initial_list = list()
for _ in itertools.repeat(None, meal_count):
initial_list.append({
'name': random.choice(self.MEAL_NAMES),
})
meals = self.factory.create(food_models.Meal, initial_list)
for meal in meals:
item_count = random.randint(
1, food_models.Item.objects.all().count())
for _ in range(0, item_count):
item = random.choice(food_models.Item.objects.all())
meal.items.add(item)
def _generate_items(self, item_count):
for item_name in self.ITEM_NAMES:
if food_models.Item.objects.all().count() >= item_count:
break
self.factory.create(food_models.Item, {'name': item_name})
def handle(self, *args, **options):
if options['clear_db']:
return
item_count = options['item_count']
self._generate_items(item_count)
meal_count = options['meal_count']
self._generate_meals(meal_count)
from fixtureless import Factory
from accounts.models import User, UserProfile
from chores.models import Chore, SkillLevel, ChoreRestrictions
from children.models import Child, ChoreAssignment
factory = Factory()
count = 15
objs = factory.create(
(User, count),
(Chore, count),
(ChoreAssignment, count),
(Child, count),
)
from fixtureless import Factory from public.models import Location factory = Factory() count = 5 location = factory.create(Location, count)
