将使用 SubFactory 和 LazyAttribute 创建的对象传递给 factory_boy 中的 RelatedFactory
Passing an object created with SubFactory and LazyAttribute to a RelatedFactory in factory_boy
我在 SubFactory 调用中使用 factory.LazyAttribute 来传递在 factory_parent 中创建的对象。这很好用。
但是如果我将创建的对象传递给 RelatedFactory，LazyAttribute 将无法再看到 factory_parent 并且会失败。
这很好用：
class OKFactory(factory.DjangoModelFactory):
class = Meta:
model = Foo
exclude = ['sub_object']
sub_object = factory.SubFactory(SubObjectFactory)
object = factory.SubFactory(ObjectFactory,
sub_object=factory.LazyAttribute(lambda obj: obj.factory_parent.sub_object))
对 LazyAttribute 的相同调用在此处失败：
class ProblemFactory(OKFactory):
class = Meta:
model = Foo
exclude = ['sub_object', 'object']
sub_object = factory.SubFactory(SubObjectFactory)
object = factory.SubFactory(ObjectFactory,
sub_object=factory.LazyAttribute(lambda obj: obj.factory_parent.sub_object))
another_object = factory.RelatedFactory(AnotherObjectFactory, 'foo', object=object)
相同的 LazyAttribute 调用无法再看到 factory_parent，并且只能访问 AnotherObject 值。 LazyAttribute 抛出错误：
AttributeError: The parameter sub_object is unknown. Evaluated attributes are...[then lists all attributes of AnotherObjectFactory]
有办法解决这个问题吗？
我不能只将 sub_object=sub_object 放入 ObjectFactory 调用中，即：
sub_object = factory.SubFactory(SubObjectFactory)
object = factory.SubFactory(ObjectFactory, sub_object=sub_object)
因为如果我这样做：
object2 = factory.SubFactory(ObjectFactory, sub_object=sub_object)
创建了第二个 sub_object，而我需要两个对象都引用同一个 sub_object。我试过 SelfAttribute 没用。
我通过调用 @factory.post_generation 内的工厂解决了这个问题。严格来说，这不是所提出的特定问题的解决方案，但我会在下面详细解释为什么这最终会成为一个更好的架构。 @rhunwick 的解决方案确实确实将 SubFactory(LazyAttribute('')) 传递给 RelatedFactory，但是仍然存在限制，这意味着这不适合我的情况。
我们将 sub_object 和 object 的创建从 ProblemFactory 移动到 ObjectWithSubObjectsFactory （并删除 exclude 子句），并添加以下代码到 ProblemFactory.
结束
@factory.post_generation
def post(self, create, extracted, **kwargs):
if not create:
return # No IDs, so wouldn't work anyway
object = ObjectWithSubObjectsFactory()
sub_object_ids_by_code = dict((sbj.name, sbj.id) for sbj in object.subobject_set.all())
# self is the `Foo` Django object just created by the `ProblemFactory` that contains this code.
for another_obj in self.anotherobject_set.all():
if another_obj.name == 'age_in':
another_obj.attribute_id = sub_object_ids_by_code['Age']
another_obj.save()
elif another_obj.name == 'income_in':
another_obj.attribute_id = sub_object_ids_by_code['Income']
another_obj.save()
所以似乎 RelatedFactory 个调用在 PostGeneration 个调用之前执行。
中的命名更容易理解，所以这里是该示例问题的相同解决方案代码：
将dataset、column_1和column_2的创建移到一个新的工厂DatasetAnd2ColumnsFactory中，然后在[=的末尾添加下面的代码31=].
@factory.post_generation
def post(self, create, extracted, **kwargs):
if not create:
return
dataset = DatasetAnd2ColumnsFactory()
column_ids_by_name =
dict((column.name, column.id) for column in dataset.column_set.all())
# self is the `FunctionInstantiation` Django object just created by the `FunctionToParameterSettingsFactory` that contains this code.
for parameter_setting in self.parametersetting_set.all():
if parameter_setting.name == 'age_in':
parameter_setting.column_id = column_ids_by_name['Age']
parameter_setting.save()
elif parameter_setting.name == 'income_in':
parameter_setting.column_id = column_ids_by_name['Income']
parameter_setting.save()
然后我扩展了这种通过选项来配置工厂的方法，如下所示：
whatever = WhateverFactory(options__an_option=True, options__another_option=True)
然后此工厂代码检测选项并生成所需的测试数据（注意该方法已重命名为 options 以匹配参数名称的前缀）：
@factory.post_generation
def options(self, create, not_used, **kwargs):
# The standard code as above
if kwargs.get('an_option', None):
# code for custom option 'an_option'
if kwargs.get('another_option', None):
# code for custom option 'another_option'
然后我进一步扩展了这个。因为我想要的模型包含自连接，所以我的工厂是递归的。所以对于这样的调用：
whatever = WhateverFactory(options__an_option='xyz',
options__an_option_for_a_nested_whatever='abc')
在 @factory.post_generation 我有：
class Meta:
model = Whatever
# self is the top level object being generated
@factory.post_generation
def options(self, create, not_used, **kwargs):
# This generates the nested object
nested_object = WhateverFactory(
options__an_option=kwargs.get('an_option_for_a_nested_whatever', None))
# then join nested_object to self via the self join
self.nested_whatever_id = nested_object.id
关于我为什么选择这个选项而不是@rhunwicks 对我上面的问题的正确解决方案，你不需要阅读一些注释。有两个原因。
阻止我试验的是 RelatedFactory 和 post-generation 的顺序不可靠 - 显然不相关的因素会影响它，大概是懒惰评估的结果。我有一些工厂会无缘无故突然停止工作的错误。曾经是因为我重命名了分配给 RelatedFactory 的变量。这听起来很荒谬，但我对它进行了测试（并且 posted here）但毫无疑问 - 重命名变量可靠地切换了 RelatedFactory 和 post-gen 执行的顺序。我仍然认为这是代表我的一些疏忽，直到由于其他原因（我从未设法诊断）再次发生。
其次，我发现声明性代码令人困惑、不灵活且难以重构。在实例化期间传递不同的配置并不容易，因此同一工厂可用于测试数据的不同变体，这意味着我不得不重复代码，object 需要添加到工厂 Meta.exclude 列表中 -听起来微不足道，但当您有几页代码生成数据时，这是一个可靠的错误。作为开发人员，您必须多次通过多个工厂才能理解控制流。生成代码将分布在声明体之间，直到您用尽这些技巧，然后其余部分将进入 post 生成或变得非常复杂。对我来说一个常见的例子是相互依赖的模型三元组（例如，父子类别结构或 dataset/attributes/entities）作为另一个相互依赖对象的三元组（例如模型，参数值等）的外键，参考其他模型的参数值）。其中一些类型的结构，尤其是嵌套结构，很快就会变得难以管理。
我意识到这并不真正符合 factory_boy 的精神，但是将所有内容都放入 post 代解决了所有这些问题。我可以传入参数，因此同一个工厂可以满足我所有的复合模型测试数据需求，并且不会重复任何代码。创建的顺序很容易立即看到，明显且完全可靠，而不是依赖于混乱的继承链和覆盖链以及受某些错误的影响。交互是显而易见的，因此您无需消化整个事物来添加一些功能，并且不同的功能区域被分组在 post-generation if 子句中。无需排除工作变量，您可以在工厂代码期间引用它们。单元测试代码被简化了，因为描述功能是在参数名称而不是工厂 class 名称中进行的 - 因此您可以使用 WhateverFactory(options__create_xyz=True, options__create_abc=True.. 而不是 WhateverCreateXYZCreateABC..() 这样的调用来创建数据。这使得代码的职责划分非常清晰。
我认为您可以利用覆盖传递给 RelatedFactory 的参数的能力来实现您想要的。
例如，给定：
class MyFactory(OKFactory):
object = factory.SubFactory(MyOtherFactory)
related = factory.RelatedFactory(YetAnotherFactory) # We want to pass object in here
如果我们提前知道 object 的值是多少，我们可以使用类似的东西来让它工作：
object = MyOtherFactory()
thing = MyFactory(object=object, related__param=object)
我们可以使用相同的命名约定将对象传递给主 Factory:
中的 RelatedFactory
class MyFactory(OKFactory):
class Meta:
exclude = ['object']
object = factory.SubFactory(MyOtherFactory)
related__param = factory.SelfAttribute('object')
related__otherrelated__param = factory.LazyAttribute(lambda myobject: 'admin%d_%d' % (myobject.level, myobject.level - 1))
related = factory.RelatedFactory(YetAnotherFactory) # Will be called with {'param': object, 'otherrelated__param: 'admin1_2'}
我在 SubFactory 调用中使用 factory.LazyAttribute 来传递在 factory_parent 中创建的对象。这很好用。
但是如果我将创建的对象传递给 RelatedFactory，LazyAttribute 将无法再看到 factory_parent 并且会失败。
这很好用：
class OKFactory(factory.DjangoModelFactory):
class = Meta:
model = Foo
exclude = ['sub_object']
sub_object = factory.SubFactory(SubObjectFactory)
object = factory.SubFactory(ObjectFactory,
sub_object=factory.LazyAttribute(lambda obj: obj.factory_parent.sub_object))
对 LazyAttribute 的相同调用在此处失败：
class ProblemFactory(OKFactory):
class = Meta:
model = Foo
exclude = ['sub_object', 'object']
sub_object = factory.SubFactory(SubObjectFactory)
object = factory.SubFactory(ObjectFactory,
sub_object=factory.LazyAttribute(lambda obj: obj.factory_parent.sub_object))
another_object = factory.RelatedFactory(AnotherObjectFactory, 'foo', object=object)
相同的 LazyAttribute 调用无法再看到 factory_parent，并且只能访问 AnotherObject 值。 LazyAttribute 抛出错误：
AttributeError: The parameter sub_object is unknown. Evaluated attributes are...[then lists all attributes of AnotherObjectFactory]
有办法解决这个问题吗？
我不能只将 sub_object=sub_object 放入 ObjectFactory 调用中，即：
sub_object = factory.SubFactory(SubObjectFactory)
object = factory.SubFactory(ObjectFactory, sub_object=sub_object)
因为如果我这样做：
object2 = factory.SubFactory(ObjectFactory, sub_object=sub_object)
创建了第二个 sub_object，而我需要两个对象都引用同一个 sub_object。我试过 SelfAttribute 没用。
我通过调用 @factory.post_generation 内的工厂解决了这个问题。严格来说，这不是所提出的特定问题的解决方案，但我会在下面详细解释为什么这最终会成为一个更好的架构。 @rhunwick 的解决方案确实确实将 SubFactory(LazyAttribute('')) 传递给 RelatedFactory，但是仍然存在限制，这意味着这不适合我的情况。
我们将 sub_object 和 object 的创建从 ProblemFactory 移动到 ObjectWithSubObjectsFactory （并删除 exclude 子句），并添加以下代码到 ProblemFactory.
@factory.post_generation
def post(self, create, extracted, **kwargs):
if not create:
return # No IDs, so wouldn't work anyway
object = ObjectWithSubObjectsFactory()
sub_object_ids_by_code = dict((sbj.name, sbj.id) for sbj in object.subobject_set.all())
# self is the `Foo` Django object just created by the `ProblemFactory` that contains this code.
for another_obj in self.anotherobject_set.all():
if another_obj.name == 'age_in':
another_obj.attribute_id = sub_object_ids_by_code['Age']
another_obj.save()
elif another_obj.name == 'income_in':
another_obj.attribute_id = sub_object_ids_by_code['Income']
another_obj.save()
所以似乎 RelatedFactory 个调用在 PostGeneration 个调用之前执行。
将dataset、column_1和column_2的创建移到一个新的工厂DatasetAnd2ColumnsFactory中，然后在[=的末尾添加下面的代码31=].
@factory.post_generation
def post(self, create, extracted, **kwargs):
if not create:
return
dataset = DatasetAnd2ColumnsFactory()
column_ids_by_name =
dict((column.name, column.id) for column in dataset.column_set.all())
# self is the `FunctionInstantiation` Django object just created by the `FunctionToParameterSettingsFactory` that contains this code.
for parameter_setting in self.parametersetting_set.all():
if parameter_setting.name == 'age_in':
parameter_setting.column_id = column_ids_by_name['Age']
parameter_setting.save()
elif parameter_setting.name == 'income_in':
parameter_setting.column_id = column_ids_by_name['Income']
parameter_setting.save()
然后我扩展了这种通过选项来配置工厂的方法，如下所示：
whatever = WhateverFactory(options__an_option=True, options__another_option=True)
然后此工厂代码检测选项并生成所需的测试数据（注意该方法已重命名为 options 以匹配参数名称的前缀）：
@factory.post_generation
def options(self, create, not_used, **kwargs):
# The standard code as above
if kwargs.get('an_option', None):
# code for custom option 'an_option'
if kwargs.get('another_option', None):
# code for custom option 'another_option'
然后我进一步扩展了这个。因为我想要的模型包含自连接，所以我的工厂是递归的。所以对于这样的调用：
whatever = WhateverFactory(options__an_option='xyz',
options__an_option_for_a_nested_whatever='abc')
在 @factory.post_generation 我有：
class Meta:
model = Whatever
# self is the top level object being generated
@factory.post_generation
def options(self, create, not_used, **kwargs):
# This generates the nested object
nested_object = WhateverFactory(
options__an_option=kwargs.get('an_option_for_a_nested_whatever', None))
# then join nested_object to self via the self join
self.nested_whatever_id = nested_object.id
关于我为什么选择这个选项而不是@rhunwicks 对我上面的问题的正确解决方案，你不需要阅读一些注释。有两个原因。
阻止我试验的是 RelatedFactory 和 post-generation 的顺序不可靠 - 显然不相关的因素会影响它，大概是懒惰评估的结果。我有一些工厂会无缘无故突然停止工作的错误。曾经是因为我重命名了分配给 RelatedFactory 的变量。这听起来很荒谬，但我对它进行了测试（并且 posted here）但毫无疑问 - 重命名变量可靠地切换了 RelatedFactory 和 post-gen 执行的顺序。我仍然认为这是代表我的一些疏忽，直到由于其他原因（我从未设法诊断）再次发生。
其次，我发现声明性代码令人困惑、不灵活且难以重构。在实例化期间传递不同的配置并不容易，因此同一工厂可用于测试数据的不同变体，这意味着我不得不重复代码，object 需要添加到工厂 Meta.exclude 列表中 -听起来微不足道，但当您有几页代码生成数据时，这是一个可靠的错误。作为开发人员，您必须多次通过多个工厂才能理解控制流。生成代码将分布在声明体之间，直到您用尽这些技巧，然后其余部分将进入 post 生成或变得非常复杂。对我来说一个常见的例子是相互依赖的模型三元组（例如，父子类别结构或 dataset/attributes/entities）作为另一个相互依赖对象的三元组（例如模型，参数值等）的外键，参考其他模型的参数值）。其中一些类型的结构，尤其是嵌套结构，很快就会变得难以管理。
我意识到这并不真正符合 factory_boy 的精神，但是将所有内容都放入 post 代解决了所有这些问题。我可以传入参数，因此同一个工厂可以满足我所有的复合模型测试数据需求，并且不会重复任何代码。创建的顺序很容易立即看到，明显且完全可靠，而不是依赖于混乱的继承链和覆盖链以及受某些错误的影响。交互是显而易见的，因此您无需消化整个事物来添加一些功能，并且不同的功能区域被分组在 post-generation if 子句中。无需排除工作变量，您可以在工厂代码期间引用它们。单元测试代码被简化了，因为描述功能是在参数名称而不是工厂 class 名称中进行的 - 因此您可以使用 WhateverFactory(options__create_xyz=True, options__create_abc=True.. 而不是 WhateverCreateXYZCreateABC..() 这样的调用来创建数据。这使得代码的职责划分非常清晰。
我认为您可以利用覆盖传递给 RelatedFactory 的参数的能力来实现您想要的。
例如，给定：
class MyFactory(OKFactory):
object = factory.SubFactory(MyOtherFactory)
related = factory.RelatedFactory(YetAnotherFactory) # We want to pass object in here
如果我们提前知道 object 的值是多少，我们可以使用类似的东西来让它工作：
object = MyOtherFactory()
thing = MyFactory(object=object, related__param=object)
我们可以使用相同的命名约定将对象传递给主 Factory:
RelatedFactory
class MyFactory(OKFactory):
class Meta:
exclude = ['object']
object = factory.SubFactory(MyOtherFactory)
related__param = factory.SelfAttribute('object')
related__otherrelated__param = factory.LazyAttribute(lambda myobject: 'admin%d_%d' % (myobject.level, myobject.level - 1))
related = factory.RelatedFactory(YetAnotherFactory) # Will be called with {'param': object, 'otherrelated__param: 'admin1_2'}