def implicit_declaration(model, name, definitions, mommy):
"""
Creates an implicit declaration for the field.
Receives the same arguments as :func:`requires_declaration`, but returns
a declaration instance.
"""
field = model._meta.get_field(name)
try:
faker = getattr(fake, name)
return declarations.LazyFunction(faker)
except AttributeError:
generator = (lambda: mommy.generate_value(field, commit=False))
return declarations.LazyFunction(generator)
def test_inherited_declaration_collecting(self):
lazy = declarations.LazyFunction(int)
lazy2 = declarations.LazyAttribute(lambda _o: 2)
postgen = declarations.PostGenerationDeclaration()
postgen2 = declarations.PostGenerationDeclaration()
class AbstractFactory(base.Factory):
x = 1
y = lazy
z = postgen
class OtherFactory(AbstractFactory):
a = lazy2
b = postgen2
# Declarations aren't removed
self.assertEqual(lazy2, OtherFactory.a)
self.assertEqual(postgen2, OtherFactory.b)
self.assertEqual(1, OtherFactory.x)
self.assertEqual(lazy, OtherFactory.y)
self.assertEqual(postgen, OtherFactory.z)
# And are available in class Meta
self.assertEqual({'x': 1, 'y': lazy, 'a': lazy2}, OtherFactory._meta.declarations)
self.assertEqual({'z': postgen, 'b': postgen2}, OtherFactory._meta.postgen_declarations)
def test_inherited_declaration_shadowing(self):
lazy = declarations.LazyFunction(int)
lazy2 = declarations.LazyAttribute(lambda _o: 2)
postgen = declarations.PostGenerationDeclaration()
postgen2 = declarations.PostGenerationDeclaration()
class AbstractFactory(base.Factory):
x = 1
y = lazy
z = postgen
class OtherFactory(AbstractFactory):
y = lazy2
z = postgen2
# Declarations aren't removed
self.assertEqual(1, OtherFactory.x)
self.assertEqual(lazy2, OtherFactory.y)
self.assertEqual(postgen2, OtherFactory.z)
# And are available in class Meta
self.assertEqual(
{
'x': 1,
'y': lazy2
},
OtherFactory._meta.pre_declarations.as_dict(),
)
self.assertEqual(
{'z': postgen2},
OtherFactory._meta.post_declarations.as_dict(),
)
def test_declaration_collecting(self):
lazy = declarations.LazyFunction(int)
lazy2 = declarations.LazyAttribute(lambda _o: 1)
postgen = declarations.PostGenerationDeclaration()
class AbstractFactory(base.Factory):
x = 1
y = lazy
y2 = lazy2
z = postgen
# Declarations aren't removed
self.assertEqual(1, AbstractFactory.x)
self.assertEqual(lazy, AbstractFactory.y)
self.assertEqual(lazy2, AbstractFactory.y2)
self.assertEqual(postgen, AbstractFactory.z)
# And are available in class Meta
self.assertEqual(
{
'x': 1,
'y': lazy,
'y2': lazy2
},
AbstractFactory._meta.pre_declarations.as_dict(),
)
self.assertEqual(
{'z': postgen},
AbstractFactory._meta.post_declarations.as_dict(),
)
def test_lazy_function(self):
lf = declarations.LazyFunction(int)
FakeFactory = self.make_fake_factory({'one': 1, 'two': lf})
ab = containers.AttributeBuilder(FakeFactory)
self.assertEqual({'one': 1, 'two': 0}, ab.build(create=False))
ab = containers.AttributeBuilder(FakeFactory, {'one': 4})
self.assertEqual({'one': 4, 'two': 0}, ab.build(create=False))
ab = containers.AttributeBuilder(FakeFactory, {'one': 4, 'three': lf})
self.assertEqual({'one': 4, 'two': 0, 'three': 0}, ab.build(create=False))
