def test_foreign_key(self):
"""Should be able to use one key for all the foreigns"""
populator = DjangoFaker.get_populator()
populator.add_entity(Key, 1)
populator.add_entity(Foreign, 5)
populator.execute()
self.assertEqual(5, len(Key.objects.all()[0].foreigns.all()))
def test_many_to_many_existing(self):
"""Should be able to use existing db values if none added to populator"""
populator = DjangoFaker.get_populator()
to_many = ToMany(thing='stuff')
to_many.save()
populator.add_entity(Many, 1)
populator.execute()
self.assertEqual(1, len(Many.objects.all()))
def test_many_to_many_fail(self):
"""Non-null many-to-many fields will raise exceptions if there aren't available objects"""
try:
populator = DjangoFaker.get_populator()
populator.add_entity(Many, 1)
populator.execute()
self.fail("All Many's require at least one ToMany to exist")
except InvalidConstraint:
pass
def test_many_to_many(self):
"""Each many-to-many field assigns 1 or more object if they exist.
many-to-many fields won't error out if there are no available objects"""
populator = DjangoFaker.get_populator()
populator.add_entity(ToMany, 5)
populator.add_entity(Many, 5)
populator.execute()
for many in Many.objects.all():
self.assertTrue(len(many.to_many.all()) > 0)
def test_one_to_one(self):
"""Should preserve the one-to-one constraint (each one should have a different to one)"""
populator = DjangoFaker.get_populator()
populator.add_entity(ToOne, 5)
populator.add_entity(One, 5)
populator.execute()
to_ones = ToOne.objects.all()
for one in One.objects.all():
to_ones = to_ones.exclude(one=one)
self.assertEqual(0, len(to_ones))
def test_one_to_one_existing(self):
"""Should be able to use a mix of existing db and new entities"""
populator = DjangoFaker.get_populator()
to_one = ToOne(thing='stuff')
to_one.save()
populator.add_entity(ToOne, 1)
populator.add_entity(One, 2)
populator.execute()
to_ones = ToOne.objects.all()
for one in One.objects.all():
to_ones = to_ones.exclude(one=one)
self.assertEqual(0, len(to_ones))
def test_one_to_one_fail(self):
"""Should throw an exception if """
try:
populator = DjangoFaker.get_populator()
populator.add_entity(ToOne, 4)
populator.add_entity(One, 5)
populator.execute()
self.fail(
"each One should need an unused ToOne which should be impossible here"
)
except InvalidConstraint:
pass
def test_complex(self):
"""Should be able to populate a complex set of models"""
populator = DjangoFaker.get_populator()
populator.add_entity(Assessment, 5)
populator.add_entity(Question, 5)
populator.add_entity(AnswerSubmission, 5)
populator.add_entity(Company, 5)
populator.add_entity(Answer, 5)
results = populator.execute()
self.assertEqual(len(results[Assessment]), 5)
self.assertEqual(len(results[Question]), 5)
self.assertEqual(len(results[AnswerSubmission]), 5)
self.assertEqual(len(results[Company]), 5)
self.assertEqual(len(results[Answer]), 5)
def test_all_names(self):
""""""
populator = DjangoFaker.get_populator()
populator.add_entity(NamedFields, 1)
populator.execute()
named = NamedFields.objects.all()[0]
self.assertRegexpMatches(named.is_boolean, '(True)|(False)')
self.assertRegexpMatches(named.created_at,
'\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}')
self.assertRegexpMatches(named.first_name, '[A-Z][a-z]+?')
self.assertRegexpMatches(named.last_name, '[A-Z][a-z]+?')
self.assertRegexpMatches(named.name, '\w')
self.assertRegexpMatches(named.login, '\w')
self.assertRegexpMatches(named.email, '.+@.*\..*')
self.assertRegexpMatches(named.phone_number, '[\d\-x]+')
self.assertRegexpMatches(named.city, '([A-Z][a-z]+? ?)+')
self.assertRegexpMatches(named.zipcode, '\d+')
self.assertRegexpMatches(named.state, '[A-Z\']{2}')
self.assertRegexpMatches(named.country, '([A-Z][a-z]+? ?)+')
self.assertRegexpMatches(named.title, '[\w ]+.')
def setUp(self):
# populator gets shared, need to reset it
populator = DjangoFaker.get_populator()
populator.clear()
def setUp(self):
populator = DjangoFaker.get_populator()
populator.clear()