1# Copyright: See the LICENSE file.
2
3"""Tests using factory."""
4
5
6import collections
7import datetime
8import os
9import sys
10import unittest
11
12import factory
13from factory import errors
14
15from . import utils
16
17
18class TestObject:
19    def __init__(self, one=None, two=None, three=None, four=None, five=None):
20        self.one = one
21        self.two = two
22        self.three = three
23        self.four = four
24        self.five = five
25
26    def as_dict(self):
27        return dict(
28            one=self.one,
29            two=self.two,
30            three=self.three,
31            four=self.four,
32            five=self.five,
33        )
34
35
36class Dummy:
37    def __init__(self, **kwargs):
38        self._fields = set(kwargs)
39        for k, v in kwargs.items():
40            setattr(self, k, v)
41
42    @property
43    def as_dict(self):
44        return {field: getattr(self, field) for field in self._fields}
45
46    def __repr__(self):
47        return '%s(%s)' % (
48            self.__class__.__name__,
49            ', '.join('%s=%r' % pair for pair in sorted(self.as_dict.items()))
50        )
51
52
53class FakeModel:
54    @classmethod
55    def create(cls, **kwargs):
56        instance = cls(**kwargs)
57        instance.id = 1
58        return instance
59
60    class FakeModelManager:
61        def get_or_create(self, **kwargs):
62            defaults = kwargs.pop('defaults', {})
63            kwargs.update(defaults)
64            instance = FakeModel.create(**kwargs)
65            instance.id = 2
66            instance._defaults = defaults
67            return instance, True
68
69        def create(self, **kwargs):
70            instance = FakeModel.create(**kwargs)
71            instance.id = 2
72            instance._defaults = None
73            return instance
74
75        def values_list(self, *args, **kwargs):
76            return self
77
78        def order_by(self, *args, **kwargs):
79            return [1]
80
81        def using(self, db):
82            return self
83
84    objects = FakeModelManager()
85
86    def __init__(self, **kwargs):
87        for name, value in kwargs.items():
88            setattr(self, name, value)
89            self.id = None
90
91
92class FakeModelFactory(factory.Factory):
93    class Meta:
94        abstract = True
95
96    @classmethod
97    def _create(cls, model_class, *args, **kwargs):
98        return model_class.create(**kwargs)
99
100
101class TestModel(FakeModel):
102    pass
103
104
105class SimpleBuildTestCase(unittest.TestCase):
106    """Tests the minimalist 'factory.build/create' functions."""
107
108    def test_build(self):
109        obj = factory.build(TestObject, two=2)
110        self.assertEqual(obj.one, None)
111        self.assertEqual(obj.two, 2)
112        self.assertEqual(obj.three, None)
113        self.assertEqual(obj.four, None)
114
115    def test_complex(self):
116        obj = factory.build(TestObject, two=2, three=factory.LazyAttribute(lambda o: o.two + 1))
117        self.assertEqual(obj.one, None)
118        self.assertEqual(obj.two, 2)
119        self.assertEqual(obj.three, 3)
120        self.assertEqual(obj.four, None)
121
122    def test_build_batch(self):
123        objs = factory.build_batch(
124            TestObject,
125            4,
126            two=2,
127            three=factory.LazyAttribute(lambda o: o.two + 1),
128        )
129
130        self.assertEqual(4, len(objs))
131        self.assertEqual(4, len(set(objs)))
132
133        for obj in objs:
134            self.assertEqual(obj.one, None)
135            self.assertEqual(obj.two, 2)
136            self.assertEqual(obj.three, 3)
137            self.assertEqual(obj.four, None)
138
139    def test_create(self):
140        obj = factory.create(FakeModel, foo='bar')
141        self.assertEqual(obj.id, None)
142        self.assertEqual(obj.foo, 'bar')
143
144    def test_create_custom_base(self):
145        obj = factory.create(FakeModel, foo='bar', FACTORY_CLASS=factory.django.DjangoModelFactory)
146        self.assertEqual(obj.id, 2)
147        self.assertEqual(obj.foo, 'bar')
148
149    def test_create_batch(self):
150        objs = factory.create_batch(FakeModel, 4, foo='bar')
151
152        self.assertEqual(4, len(objs))
153        self.assertEqual(4, len(set(objs)))
154
155        for obj in objs:
156            self.assertEqual(obj.id, None)
157            self.assertEqual(obj.foo, 'bar')
158
159    def test_create_batch_custom_base(self):
160        objs = factory.create_batch(
161            FakeModel,
162            4,
163            foo='bar',
164            FACTORY_CLASS=factory.django.DjangoModelFactory,
165        )
166
167        self.assertEqual(4, len(objs))
168        self.assertEqual(4, len(set(objs)))
169
170        for obj in objs:
171            self.assertEqual(obj.id, 2)
172            self.assertEqual(obj.foo, 'bar')
173
174    def test_stub(self):
175        obj = factory.stub(TestObject, three=3)
176        self.assertEqual(obj.three, 3)
177        self.assertFalse(hasattr(obj, 'two'))
178
179    def test_stub_batch(self):
180        objs = factory.stub_batch(FakeModel, 4, foo='bar')
181
182        self.assertEqual(4, len(objs))
183        self.assertEqual(4, len(set(objs)))
184
185        for obj in objs:
186            self.assertFalse(hasattr(obj, 'id'))
187            self.assertEqual(obj.foo, 'bar')
188
189    def test_generate_build(self):
190        obj = factory.generate(FakeModel, factory.BUILD_STRATEGY, foo='bar')
191        self.assertEqual(obj.id, None)
192        self.assertEqual(obj.foo, 'bar')
193
194    def test_generate_create(self):
195        obj = factory.generate(FakeModel, factory.CREATE_STRATEGY, foo='bar')
196        self.assertEqual(obj.id, None)
197        self.assertEqual(obj.foo, 'bar')
198
199    def test_generate_create_custom_base(self):
200        obj = factory.generate(
201            FakeModel,
202            factory.CREATE_STRATEGY,
203            foo='bar',
204            FACTORY_CLASS=factory.django.DjangoModelFactory,
205        )
206        self.assertEqual(obj.id, 2)
207        self.assertEqual(obj.foo, 'bar')
208
209    def test_generate_stub(self):
210        obj = factory.generate(FakeModel, factory.STUB_STRATEGY, foo='bar')
211        self.assertFalse(hasattr(obj, 'id'))
212        self.assertEqual(obj.foo, 'bar')
213
214    def test_generate_batch_build(self):
215        objs = factory.generate_batch(FakeModel, factory.BUILD_STRATEGY, 20, foo='bar')
216
217        self.assertEqual(20, len(objs))
218        self.assertEqual(20, len(set(objs)))
219
220        for obj in objs:
221            self.assertEqual(obj.id, None)
222            self.assertEqual(obj.foo, 'bar')
223
224    def test_generate_batch_create(self):
225        objs = factory.generate_batch(FakeModel, factory.CREATE_STRATEGY, 20, foo='bar')
226
227        self.assertEqual(20, len(objs))
228        self.assertEqual(20, len(set(objs)))
229
230        for obj in objs:
231            self.assertEqual(obj.id, None)
232            self.assertEqual(obj.foo, 'bar')
233
234    def test_generate_batch_create_custom_base(self):
235        objs = factory.generate_batch(
236            FakeModel,
237            factory.CREATE_STRATEGY,
238            20,
239            foo='bar',
240            FACTORY_CLASS=factory.django.DjangoModelFactory,
241        )
242
243        self.assertEqual(20, len(objs))
244        self.assertEqual(20, len(set(objs)))
245
246        for obj in objs:
247            self.assertEqual(obj.id, 2)
248            self.assertEqual(obj.foo, 'bar')
249
250    def test_generate_batch_stub(self):
251        objs = factory.generate_batch(FakeModel, factory.STUB_STRATEGY, 20, foo='bar')
252
253        self.assertEqual(20, len(objs))
254        self.assertEqual(20, len(set(objs)))
255
256        for obj in objs:
257            self.assertFalse(hasattr(obj, 'id'))
258            self.assertEqual(obj.foo, 'bar')
259
260    def test_simple_generate_build(self):
261        obj = factory.simple_generate(FakeModel, False, foo='bar')
262        self.assertEqual(obj.id, None)
263        self.assertEqual(obj.foo, 'bar')
264
265    def test_simple_generate_create(self):
266        obj = factory.simple_generate(FakeModel, True, foo='bar')
267        self.assertEqual(obj.id, None)
268        self.assertEqual(obj.foo, 'bar')
269
270    def test_simple_generate_create_custom_base(self):
271        obj = factory.simple_generate(FakeModel, True, foo='bar', FACTORY_CLASS=factory.django.DjangoModelFactory)
272        self.assertEqual(obj.id, 2)
273        self.assertEqual(obj.foo, 'bar')
274
275    def test_simple_generate_batch_build(self):
276        objs = factory.simple_generate_batch(FakeModel, False, 20, foo='bar')
277
278        self.assertEqual(20, len(objs))
279        self.assertEqual(20, len(set(objs)))
280
281        for obj in objs:
282            self.assertEqual(obj.id, None)
283            self.assertEqual(obj.foo, 'bar')
284
285    def test_simple_generate_batch_create(self):
286        objs = factory.simple_generate_batch(FakeModel, True, 20, foo='bar')
287
288        self.assertEqual(20, len(objs))
289        self.assertEqual(20, len(set(objs)))
290
291        for obj in objs:
292            self.assertEqual(obj.id, None)
293            self.assertEqual(obj.foo, 'bar')
294
295    def test_simple_generate_batch_create_custom_base(self):
296        objs = factory.simple_generate_batch(
297            FakeModel,
298            True,
299            20,
300            foo='bar',
301            FACTORY_CLASS=factory.django.DjangoModelFactory,
302        )
303
304        self.assertEqual(20, len(objs))
305        self.assertEqual(20, len(set(objs)))
306
307        for obj in objs:
308            self.assertEqual(obj.id, 2)
309            self.assertEqual(obj.foo, 'bar')
310
311    def test_make_factory(self):
312        fact = factory.make_factory(TestObject, two=2, three=factory.LazyAttribute(lambda o: o.two + 1))
313
314        obj = fact.build()
315        self.assertEqual(obj.one, None)
316        self.assertEqual(obj.two, 2)
317        self.assertEqual(obj.three, 3)
318        self.assertEqual(obj.four, None)
319
320        obj = fact.build(two=4)
321        self.assertEqual(obj.one, None)
322        self.assertEqual(obj.two, 4)
323        self.assertEqual(obj.three, 5)
324        self.assertEqual(obj.four, None)
325
326    def test_build_to_dict(self):
327        # We have a generic factory
328        class TestObjectFactory(factory.Factory):
329            class Meta:
330                model = TestObject
331
332            one = 'one'
333            two = factory.LazyAttribute(lambda o: o.one * 2)
334
335        # Now, get a dict out of it
336        obj = factory.build(dict, FACTORY_CLASS=TestObjectFactory)
337        self.assertEqual({'one': 'one', 'two': 'oneone'}, obj)
338
339
340class UsingFactoryTestCase(unittest.TestCase):
341    def test_attribute(self):
342        class TestObjectFactory(factory.Factory):
343            class Meta:
344                model = TestObject
345
346            one = 'one'
347
348        test_object = TestObjectFactory.build()
349        self.assertEqual(test_object.one, 'one')
350
351    def test_inheriting_model_class(self):
352        class TestObjectFactory(factory.Factory, TestObject):
353            class Meta:
354                model = TestObject
355
356            one = 'one'
357
358        test_object = TestObjectFactory.build()
359        self.assertEqual(test_object.one, 'one')
360
361    def test_abstract(self):
362        class SomeAbstractFactory(factory.Factory):
363            class Meta:
364                abstract = True
365
366            one = 'one'
367
368        class InheritedFactory(SomeAbstractFactory):
369            class Meta:
370                model = TestObject
371
372        test_object = InheritedFactory.build()
373        self.assertEqual(test_object.one, 'one')
374
375    def test_sequence(self):
376        class TestObjectFactory(factory.Factory):
377            class Meta:
378                model = TestObject
379
380            one = factory.Sequence(lambda n: 'one%d' % n)
381            two = factory.Sequence(lambda n: 'two%d' % n)
382
383        test_object0 = TestObjectFactory.build()
384        self.assertEqual(test_object0.one, 'one0')
385        self.assertEqual(test_object0.two, 'two0')
386
387        test_object1 = TestObjectFactory.build()
388        self.assertEqual(test_object1.one, 'one1')
389        self.assertEqual(test_object1.two, 'two1')
390
391    def test_sequence_custom_begin(self):
392        class TestObjectFactory(factory.Factory):
393            class Meta:
394                model = TestObject
395
396            @classmethod
397            def _setup_next_sequence(cls):
398                return 42
399
400            one = factory.Sequence(lambda n: 'one%d' % n)
401            two = factory.Sequence(lambda n: 'two%d' % n)
402
403        test_object0 = TestObjectFactory.build()
404        self.assertEqual('one42', test_object0.one)
405        self.assertEqual('two42', test_object0.two)
406
407        test_object1 = TestObjectFactory.build()
408        self.assertEqual('one43', test_object1.one)
409        self.assertEqual('two43', test_object1.two)
410
411    def test_sequence_override(self):
412        class TestObjectFactory(factory.Factory):
413            class Meta:
414                model = TestObject
415
416            one = factory.Sequence(lambda n: 'one%d' % n)
417
418        o1 = TestObjectFactory()
419        o2 = TestObjectFactory()
420        o3 = TestObjectFactory(__sequence=42)
421        o4 = TestObjectFactory()
422
423        self.assertEqual('one0', o1.one)
424        self.assertEqual('one1', o2.one)
425        self.assertEqual('one42', o3.one)
426        self.assertEqual('one2', o4.one)
427
428    def test_custom_create(self):
429        class TestModelFactory(factory.Factory):
430            class Meta:
431                model = TestModel
432
433            two = 2
434
435            @classmethod
436            def _create(cls, model_class, *args, **kwargs):
437                obj = model_class.create(**kwargs)
438                obj.properly_created = True
439                return obj
440
441        obj = TestModelFactory.create(one=1)
442        self.assertEqual(1, obj.one)
443        self.assertEqual(2, obj.two)
444        self.assertEqual(1, obj.id)
445        self.assertTrue(obj.properly_created)
446
447    def test_non_django_create(self):
448        class NonDjango:
449            def __init__(self, x, y=2):
450                self.x = x
451                self.y = y
452
453        class NonDjangoFactory(factory.Factory):
454            class Meta:
455                model = NonDjango
456
457            x = 3
458
459        obj = NonDjangoFactory.create()
460        self.assertEqual(3, obj.x)
461        self.assertEqual(2, obj.y)
462
463    def test_sequence_batch(self):
464        class TestObjectFactory(factory.Factory):
465            class Meta:
466                model = TestObject
467
468            one = factory.Sequence(lambda n: 'one%d' % n)
469            two = factory.Sequence(lambda n: 'two%d' % n)
470
471        objs = TestObjectFactory.build_batch(20)
472
473        self.assertEqual(20, len(objs))
474        self.assertEqual(20, len(set(objs)))
475        for i, obj in enumerate(objs):
476            self.assertEqual('one%d' % i, obj.one)
477            self.assertEqual('two%d' % i, obj.two)
478
479    def test_lazy_attribute(self):
480        class TestObjectFactory(factory.Factory):
481            class Meta:
482                model = TestObject
483
484            one = factory.LazyAttribute(lambda a: 'abc')
485            two = factory.LazyAttribute(lambda a: a.one + ' xyz')
486
487        test_object = TestObjectFactory.build()
488        self.assertEqual(test_object.one, 'abc')
489        self.assertEqual(test_object.two, 'abc xyz')
490
491    def test_lazy_attribute_sequence(self):
492        class TestObjectFactory(factory.Factory):
493            class Meta:
494                model = TestObject
495
496            one = factory.LazyAttributeSequence(lambda a, n: 'abc%d' % n)
497            two = factory.LazyAttributeSequence(lambda a, n: a.one + ' xyz%d' % n)
498
499        test_object0 = TestObjectFactory.build()
500        self.assertEqual(test_object0.one, 'abc0')
501        self.assertEqual(test_object0.two, 'abc0 xyz0')
502
503        test_object1 = TestObjectFactory.build()
504        self.assertEqual(test_object1.one, 'abc1')
505        self.assertEqual(test_object1.two, 'abc1 xyz1')
506
507    def test_lazy_attribute_decorator(self):
508        class TestObjectFactory(factory.Factory):
509            class Meta:
510                model = TestObject
511
512            @factory.lazy_attribute
513            def one(a):
514                return 'one'
515
516        test_object = TestObjectFactory.build()
517        self.assertEqual(test_object.one, 'one')
518
519    def test_self_attribute(self):
520        class TmpObj:
521            n = 3
522
523        class TestObjectFactory(factory.Factory):
524            class Meta:
525                model = TestObject
526
527            one = 'xx'
528            two = factory.SelfAttribute('one')
529            three = TmpObj()
530            four = factory.SelfAttribute('three.n')
531            five = factory.SelfAttribute('three.nnn', 5)
532
533        test_object = TestObjectFactory.build(one=1)
534        self.assertEqual(1, test_object.two)
535        self.assertEqual(3, test_object.three.n)
536        self.assertEqual(3, test_object.four)
537        self.assertEqual(5, test_object.five)
538
539    def test_self_attribute_parent(self):
540        class TestModel2(FakeModel):
541            pass
542
543        class TestModelFactory(FakeModelFactory):
544            class Meta:
545                model = TestModel
546            one = 3
547            three = factory.SelfAttribute('..bar')
548
549        class TestModel2Factory(FakeModelFactory):
550            class Meta:
551                model = TestModel2
552            bar = 4
553            two = factory.SubFactory(TestModelFactory, one=1)
554
555        test_model = TestModel2Factory()
556        self.assertEqual(4, test_model.two.three)
557
558    def test_sequence_decorator(self):
559        class TestObjectFactory(factory.Factory):
560            class Meta:
561                model = TestObject
562
563            @factory.sequence
564            def one(n):
565                return 'one%d' % n
566
567        test_object = TestObjectFactory.build()
568        self.assertEqual(test_object.one, 'one0')
569
570    def test_lazy_attribute_sequence_decorator(self):
571        class TestObjectFactory(factory.Factory):
572            class Meta:
573                model = TestObject
574
575            @factory.lazy_attribute_sequence
576            def one(a, n):
577                return 'one%d' % n
578
579            @factory.lazy_attribute_sequence
580            def two(a, n):
581                return a.one + ' two%d' % n
582
583        test_object = TestObjectFactory.build()
584        self.assertEqual(test_object.one, 'one0')
585        self.assertEqual(test_object.two, 'one0 two0')
586
587    def test_build_with_parameters(self):
588        class TestObjectFactory(factory.Factory):
589            class Meta:
590                model = TestObject
591
592            one = factory.Sequence(lambda n: 'one%d' % n)
593            two = factory.Sequence(lambda n: 'two%d' % n)
594
595        test_object0 = TestObjectFactory.build(three='three')
596        self.assertEqual(test_object0.one, 'one0')
597        self.assertEqual(test_object0.two, 'two0')
598        self.assertEqual(test_object0.three, 'three')
599
600        test_object1 = TestObjectFactory.build(one='other')
601        self.assertEqual(test_object1.one, 'other')
602        self.assertEqual(test_object1.two, 'two1')
603
604    def test_create(self):
605        class TestModelFactory(FakeModelFactory):
606            class Meta:
607                model = TestModel
608
609            one = 'one'
610
611        test_model = TestModelFactory.create()
612        self.assertEqual(test_model.one, 'one')
613        self.assertTrue(test_model.id)
614
615    def test_create_batch(self):
616        class TestModelFactory(FakeModelFactory):
617            class Meta:
618                model = TestModel
619
620            one = 'one'
621
622        objs = TestModelFactory.create_batch(20, two=factory.Sequence(int))
623
624        self.assertEqual(20, len(objs))
625        self.assertEqual(20, len(set(objs)))
626
627        for i, obj in enumerate(objs):
628            self.assertEqual('one', obj.one)
629            self.assertEqual(i, obj.two)
630            self.assertTrue(obj.id)
631
632    def test_generate_build(self):
633        class TestModelFactory(FakeModelFactory):
634            class Meta:
635                model = TestModel
636
637            one = 'one'
638
639        test_model = TestModelFactory.generate(factory.BUILD_STRATEGY)
640        self.assertEqual(test_model.one, 'one')
641        self.assertFalse(test_model.id)
642
643    def test_generate_create(self):
644        class TestModelFactory(FakeModelFactory):
645            class Meta:
646                model = TestModel
647
648            one = 'one'
649
650        test_model = TestModelFactory.generate(factory.CREATE_STRATEGY)
651        self.assertEqual(test_model.one, 'one')
652        self.assertTrue(test_model.id)
653
654    def test_generate_stub(self):
655        class TestModelFactory(FakeModelFactory):
656            class Meta:
657                model = TestModel
658
659            one = 'one'
660
661        test_model = TestModelFactory.generate(factory.STUB_STRATEGY)
662        self.assertEqual(test_model.one, 'one')
663        self.assertFalse(hasattr(test_model, 'id'))
664
665    def test_generate_batch_build(self):
666        class TestModelFactory(FakeModelFactory):
667            class Meta:
668                model = TestModel
669
670            one = 'one'
671
672        objs = TestModelFactory.generate_batch(factory.BUILD_STRATEGY, 20, two='two')
673
674        self.assertEqual(20, len(objs))
675        self.assertEqual(20, len(set(objs)))
676
677        for i, obj in enumerate(objs):
678            self.assertEqual('one', obj.one)
679            self.assertEqual('two', obj.two)
680            self.assertFalse(obj.id)
681
682    def test_generate_batch_create(self):
683        class TestModelFactory(FakeModelFactory):
684            class Meta:
685                model = TestModel
686
687            one = 'one'
688
689        objs = TestModelFactory.generate_batch(factory.CREATE_STRATEGY, 20, two='two')
690
691        self.assertEqual(20, len(objs))
692        self.assertEqual(20, len(set(objs)))
693
694        for i, obj in enumerate(objs):
695            self.assertEqual('one', obj.one)
696            self.assertEqual('two', obj.two)
697            self.assertTrue(obj.id)
698
699    def test_generate_batch_stub(self):
700        class TestModelFactory(FakeModelFactory):
701            class Meta:
702                model = TestModel
703
704            one = 'one'
705
706        objs = TestModelFactory.generate_batch(factory.STUB_STRATEGY, 20, two='two')
707
708        self.assertEqual(20, len(objs))
709        self.assertEqual(20, len(set(objs)))
710
711        for i, obj in enumerate(objs):
712            self.assertEqual('one', obj.one)
713            self.assertEqual('two', obj.two)
714            self.assertFalse(hasattr(obj, 'id'))
715
716    def test_simple_generate_build(self):
717        class TestModelFactory(FakeModelFactory):
718            class Meta:
719                model = TestModel
720
721            one = 'one'
722
723        test_model = TestModelFactory.simple_generate(False)
724        self.assertEqual(test_model.one, 'one')
725        self.assertFalse(test_model.id)
726
727    def test_simple_generate_create(self):
728        class TestModelFactory(FakeModelFactory):
729            class Meta:
730                model = TestModel
731
732            one = 'one'
733
734        test_model = TestModelFactory.simple_generate(True)
735        self.assertEqual(test_model.one, 'one')
736        self.assertTrue(test_model.id)
737
738    def test_simple_generate_batch_build(self):
739        class TestModelFactory(FakeModelFactory):
740            class Meta:
741                model = TestModel
742
743            one = 'one'
744
745        objs = TestModelFactory.simple_generate_batch(False, 20, two='two')
746
747        self.assertEqual(20, len(objs))
748        self.assertEqual(20, len(set(objs)))
749
750        for i, obj in enumerate(objs):
751            self.assertEqual('one', obj.one)
752            self.assertEqual('two', obj.two)
753            self.assertFalse(obj.id)
754
755    def test_simple_generate_batch_create(self):
756        class TestModelFactory(FakeModelFactory):
757            class Meta:
758                model = TestModel
759
760            one = 'one'
761
762        objs = TestModelFactory.simple_generate_batch(True, 20, two='two')
763
764        self.assertEqual(20, len(objs))
765        self.assertEqual(20, len(set(objs)))
766
767        for i, obj in enumerate(objs):
768            self.assertEqual('one', obj.one)
769            self.assertEqual('two', obj.two)
770            self.assertTrue(obj.id)
771
772    def test_stub_batch(self):
773        class TestObjectFactory(factory.Factory):
774            class Meta:
775                model = TestObject
776
777            one = 'one'
778            two = factory.LazyAttribute(lambda a: a.one + ' two')
779            three = factory.Sequence(lambda n: int(n))
780
781        objs = TestObjectFactory.stub_batch(
782            20,
783            one=factory.Sequence(lambda n: str(n)),
784        )
785
786        self.assertEqual(20, len(objs))
787        self.assertEqual(20, len(set(objs)))
788
789        for i, obj in enumerate(objs):
790            self.assertEqual(str(i), obj.one)
791            self.assertEqual('%d two' % i, obj.two)
792            self.assertEqual(i, obj.three)
793
794    def test_inheritance(self):
795        class TestObjectFactory(factory.Factory):
796            class Meta:
797                model = TestObject
798
799            one = 'one'
800            two = factory.LazyAttribute(lambda a: a.one + ' two')
801
802        class TestObjectFactory2(TestObjectFactory):
803            class Meta:
804                model = TestObject
805
806            three = 'three'
807            four = factory.LazyAttribute(lambda a: a.three + ' four')
808
809        test_object = TestObjectFactory2.build()
810        self.assertEqual(test_object.one, 'one')
811        self.assertEqual(test_object.two, 'one two')
812        self.assertEqual(test_object.three, 'three')
813        self.assertEqual(test_object.four, 'three four')
814
815        test_object_alt = TestObjectFactory.build()
816        self.assertEqual(None, test_object_alt.three)
817
818    def test_override_inherited(self):
819        """Overriding inherited declarations"""
820        class TestObjectFactory(factory.Factory):
821            class Meta:
822                model = TestObject
823
824            one = 'one'
825
826        class TestObjectFactory2(TestObjectFactory):
827            one = 'two'
828
829        test_object = TestObjectFactory2.build()
830        self.assertEqual('two', test_object.one)
831
832    def test_override_inherited_deep(self):
833        """Overriding inherited declarations"""
834        class TestObjectFactory(factory.Factory):
835            class Meta:
836                model = TestObject
837
838            one = 'one'
839
840        class TestObjectFactory2(TestObjectFactory):
841            one = 'two'
842
843        class TestObjectFactory3(TestObjectFactory2):
844            pass
845
846        test_object = TestObjectFactory3.build()
847        self.assertEqual('two', test_object.one)
848
849    def test_inheritance_and_sequences(self):
850        """Sequence counters should be kept within an inheritance chain."""
851        class TestObjectFactory(factory.Factory):
852            class Meta:
853                model = TestObject
854
855            one = factory.Sequence(lambda n: n)
856
857        class TestObjectFactory2(TestObjectFactory):
858            class Meta:
859                model = TestObject
860
861        to1a = TestObjectFactory()
862        self.assertEqual(0, to1a.one)
863        to2a = TestObjectFactory2()
864        self.assertEqual(1, to2a.one)
865        to1b = TestObjectFactory()
866        self.assertEqual(2, to1b.one)
867        to2b = TestObjectFactory2()
868        self.assertEqual(3, to2b.one)
869
870    def test_inheritance_sequence_inheriting_objects(self):
871        """Sequence counters are kept with inheritance, incl. misc objects."""
872        class TestObject2(TestObject):
873            pass
874
875        class TestObjectFactory(factory.Factory):
876            class Meta:
877                model = TestObject
878
879            one = factory.Sequence(lambda n: n)
880
881        class TestObjectFactory2(TestObjectFactory):
882            class Meta:
883                model = TestObject2
884
885        to1a = TestObjectFactory()
886        self.assertEqual(0, to1a.one)
887        to2a = TestObjectFactory2()
888        self.assertEqual(1, to2a.one)
889        to1b = TestObjectFactory()
890        self.assertEqual(2, to1b.one)
891        to2b = TestObjectFactory2()
892        self.assertEqual(3, to2b.one)
893
894    def test_inheritance_sequence_unrelated_objects(self):
895        """Sequence counters are kept with inheritance, unrelated objects.
896
897        See issue https://github.com/FactoryBoy/factory_boy/issues/93
898
899        Problem: sequence counter is somewhat shared between factories
900        until the "slave" factory has been called.
901        """
902
903        class TestObject2:
904            def __init__(self, one):
905                self.one = one
906
907        class TestObjectFactory(factory.Factory):
908            class Meta:
909                model = TestObject
910
911            one = factory.Sequence(lambda n: n)
912
913        class TestObjectFactory2(TestObjectFactory):
914            class Meta:
915                model = TestObject2
916
917        to1a = TestObjectFactory()
918        self.assertEqual(0, to1a.one)
919        to2a = TestObjectFactory2()
920        self.assertEqual(0, to2a.one)
921        to1b = TestObjectFactory()
922        self.assertEqual(1, to1b.one)
923        to2b = TestObjectFactory2()
924        self.assertEqual(1, to2b.one)
925
926    def test_inheritance_with_inherited_class(self):
927        class TestObjectFactory(factory.Factory):
928            class Meta:
929                model = TestObject
930
931            one = 'one'
932            two = factory.LazyAttribute(lambda a: a.one + ' two')
933
934        class TestFactory(TestObjectFactory):
935            three = 'three'
936            four = factory.LazyAttribute(lambda a: a.three + ' four')
937
938        test_object = TestFactory.build()
939        self.assertEqual(test_object.one, 'one')
940        self.assertEqual(test_object.two, 'one two')
941        self.assertEqual(test_object.three, 'three')
942        self.assertEqual(test_object.four, 'three four')
943
944    def test_dual_inheritance(self):
945        class TestObjectFactory(factory.Factory):
946            class Meta:
947                model = TestObject
948
949            one = 'one'
950
951        class TestOtherFactory(factory.Factory):
952            class Meta:
953                model = TestObject
954            two = 'two'
955            four = 'four'
956
957        class TestFactory(TestObjectFactory, TestOtherFactory):
958            three = 'three'
959
960        obj = TestFactory.build(two=2)
961        self.assertEqual('one', obj.one)
962        self.assertEqual(2, obj.two)
963        self.assertEqual('three', obj.three)
964        self.assertEqual('four', obj.four)
965
966    def test_class_method_accessible(self):
967        class TestObjectFactory(factory.Factory):
968            class Meta:
969                model = TestObject
970
971            @classmethod
972            def alt_create(cls, **kwargs):
973                return kwargs
974
975        self.assertEqual(TestObjectFactory.alt_create(foo=1), {"foo": 1})
976
977    def test_static_method_accessible(self):
978        class TestObjectFactory(factory.Factory):
979            class Meta:
980                model = TestObject
981
982            @staticmethod
983            def alt_create(**kwargs):
984                return kwargs
985
986        self.assertEqual(TestObjectFactory.alt_create(foo=1), {"foo": 1})
987
988    def test_inline_args(self):
989        class TestObject:
990            def __init__(self, *args, **kwargs):
991                self.args = args
992                self.kwargs = kwargs
993
994        class TestObjectFactory(factory.Factory):
995            class Meta:
996                model = TestObject
997                inline_args = ('x', 'y')
998
999            x = 1
1000            y = 2
1001            z = 3
1002            t = 4
1003
1004        obj = TestObjectFactory.build(x=42, z=5)
1005        self.assertEqual((42, 2), obj.args)
1006        self.assertEqual({'z': 5, 't': 4}, obj.kwargs)
1007
1008    def test_exclude(self):
1009        class TestObject:
1010            def __init__(self, *args, **kwargs):
1011                self.args = args
1012                self.kwargs = kwargs
1013
1014        class TestObjectFactory(factory.Factory):
1015            class Meta:
1016                model = TestObject
1017                exclude = ('x', 'z')
1018
1019            x = 1
1020            y = 2
1021            z = 3
1022            t = 4
1023
1024        obj = TestObjectFactory.build(x=42, z=5)
1025        self.assertEqual((), obj.args)
1026        self.assertEqual({'y': 2, 't': 4}, obj.kwargs)
1027
1028    def test_exclude_and_inline_args(self):
1029        class TestObject:
1030            def __init__(self, *args, **kwargs):
1031                self.args = args
1032                self.kwargs = kwargs
1033
1034        class TestObjectFactory(factory.Factory):
1035            class Meta:
1036                model = TestObject
1037                exclude = ('x', 'z')
1038                inline_args = ('y',)
1039
1040            x = 1
1041            y = 2
1042            z = 3
1043            t = 4
1044
1045        obj = TestObjectFactory.build(x=42, z=5)
1046        self.assertEqual((2,), obj.args)
1047        self.assertEqual({'t': 4}, obj.kwargs)
1048
1049
1050class NonKwargParametersTestCase(unittest.TestCase):
1051    def test_build(self):
1052        class TestObject:
1053            def __init__(self, *args, **kwargs):
1054                self.args = args
1055                self.kwargs = kwargs
1056
1057        class TestObjectFactory(factory.Factory):
1058            class Meta:
1059                model = TestObject
1060                inline_args = ('one', 'two',)
1061
1062            one = 1
1063            two = 2
1064            three = 3
1065
1066        obj = TestObjectFactory.build()
1067        self.assertEqual((1, 2), obj.args)
1068        self.assertEqual({'three': 3}, obj.kwargs)
1069
1070    def test_create(self):
1071        class TestObject:
1072            def __init__(self, *args, **kwargs):
1073                self.args = None
1074                self.kwargs = None
1075
1076            @classmethod
1077            def create(cls, *args, **kwargs):
1078                inst = cls()
1079                inst.args = args
1080                inst.kwargs = kwargs
1081                return inst
1082
1083        class TestObjectFactory(factory.Factory):
1084            class Meta:
1085                model = TestObject
1086                inline_args = ('one', 'two')
1087
1088            one = 1
1089            two = 2
1090            three = 3
1091
1092            @classmethod
1093            def _create(cls, model_class, *args, **kwargs):
1094                return model_class.create(*args, **kwargs)
1095
1096        obj = TestObjectFactory.create()
1097        self.assertEqual((1, 2), obj.args)
1098        self.assertEqual({'three': 3}, obj.kwargs)
1099
1100
1101class KwargAdjustTestCase(unittest.TestCase):
1102    """Tests for the _adjust_kwargs method."""
1103
1104    def test_build(self):
1105        class TestObject:
1106            def __init__(self, *args, **kwargs):
1107                self.args = args
1108                self.kwargs = kwargs
1109
1110        class TestObjectFactory(factory.Factory):
1111            class Meta:
1112                model = TestObject
1113
1114            @classmethod
1115            def _adjust_kwargs(cls, **kwargs):
1116                kwargs['foo'] = len(kwargs)
1117                return kwargs
1118
1119        obj = TestObjectFactory.build(x=1, y=2, z=3)
1120        self.assertEqual({'x': 1, 'y': 2, 'z': 3, 'foo': 3}, obj.kwargs)
1121        self.assertEqual((), obj.args)
1122
1123    def test_rename(self):
1124        class TestObject:
1125            def __init__(self, attributes=None):
1126                self.attributes = attributes
1127
1128        class TestObjectFactory(factory.Factory):
1129            class Meta:
1130                model = TestObject
1131                rename = {'attributes_': 'attributes'}
1132
1133            attributes_ = 42
1134
1135        obj = TestObjectFactory.build()
1136        self.assertEqual(42, obj.attributes)
1137
1138    def test_rename_non_existent_kwarg(self):
1139        # see https://github.com/FactoryBoy/factory_boy/issues/504
1140        class TestObject:
1141            def __init__(self, attributes=None):
1142                self.attributes = attributes
1143
1144        class TestObjectFactory(factory.Factory):
1145            class Meta:
1146                model = TestObject
1147                rename = {'form_attributes': 'attributes'}
1148
1149        try:
1150            TestObjectFactory()
1151        except KeyError:
1152            self.fail('should not raise KeyError for missing renamed attributes')
1153
1154
1155class MaybeTestCase(unittest.TestCase):
1156    def test_simple_maybe(self):
1157        class DummyFactory(factory.Factory):
1158            class Meta:
1159                model = Dummy
1160
1161            # Undeclared: key = None
1162            both = factory.Maybe('key', 1, 2)
1163            yes = factory.Maybe('key', 1)
1164            no = factory.Maybe('key', no_declaration=2)
1165            none = factory.Maybe('key')
1166
1167        obj_default = DummyFactory.build()
1168        obj_true = DummyFactory.build(key=True)
1169        obj_false = DummyFactory.build(key=False)
1170
1171        self.assertEqual(dict(both=2, no=2), obj_default.as_dict)
1172        self.assertEqual(dict(key=True, both=1, yes=1), obj_true.as_dict)
1173        self.assertEqual(dict(key=False, both=2, no=2), obj_false.as_dict)
1174
1175    def test_declarations(self):
1176        class DummyFactory(factory.Factory):
1177            class Meta:
1178                model = Dummy
1179
1180            a = 0
1181            b = 1
1182
1183            # biggest = 'b' if .b > .a else 'a'
1184            biggest = factory.Maybe(factory.LazyAttribute(lambda o: o.a < o.b), 'b', 'a')
1185            # max_value = .b if .b > .a else .a = max(.a, .b)
1186            max_value = factory.Maybe(
1187                factory.LazyAttribute(lambda o: o.a < o.b),
1188                factory.SelfAttribute('b'),
1189                factory.SelfAttribute('a'),
1190            )
1191
1192        obj_ordered = DummyFactory.build(a=1, b=2)
1193        obj_equal = DummyFactory.build(a=3, b=3)
1194        obj_reverse = DummyFactory.build(a=5, b=4)
1195
1196        self.assertEqual(dict(a=1, b=2, biggest='b', max_value=2, ), obj_ordered.as_dict)
1197        self.assertEqual(dict(a=3, b=3, biggest='a', max_value=3, ), obj_equal.as_dict)
1198        self.assertEqual(dict(a=5, b=4, biggest='a', max_value=5, ), obj_reverse.as_dict)
1199
1200    def test_post_generation(self):
1201
1202        # Helpers
1203        @factory.post_generation
1204        def square(obj, *args, **kwargs):
1205            obj.value *= obj.value
1206
1207        @factory.post_generation
1208        def quintuple(obj, *args, **kwargs):
1209            obj.value *= 5
1210
1211        @factory.post_generation
1212        def double(obj, *args, **kwargs):
1213            obj.value *= 2
1214
1215        @factory.post_generation
1216        def decrement(obj, *args, **kwargs):
1217            obj.value -= 1
1218
1219        class DummyFactory(factory.Factory):
1220            class Meta:
1221                model = Dummy
1222
1223            value = 0
1224            square_it = factory.Maybe('square', square)
1225            quintuple_it = factory.Maybe('quintuple', quintuple)
1226            adjust_nums = factory.Maybe(
1227                factory.LazyAttribute(lambda o: o.value % 2 == 0),
1228                double,
1229                decrement,
1230            )
1231
1232        obj_untouched = DummyFactory.build(value=4)
1233        obj_squared = DummyFactory.build(value=5, square=True)
1234        obj_combined = DummyFactory.build(value=6, square=True, quintuple=True)
1235
1236        self.assertEqual(4 * 2, obj_untouched.value)
1237        self.assertEqual(5 ** 2 - 1, obj_squared.value)
1238        self.assertEqual(6 ** 2 * 5 * 2, obj_combined.value)
1239
1240
1241class TraitTestCase(unittest.TestCase):
1242    def test_traits(self):
1243        class TestObjectFactory(factory.Factory):
1244            class Meta:
1245                model = TestObject
1246
1247            class Params:
1248                even = factory.Trait(two=True, four=True)
1249                odd = factory.Trait(one=True, three=True, five=True)
1250
1251        obj1 = TestObjectFactory()
1252        self.assertEqual(
1253            obj1.as_dict(),
1254            dict(one=None, two=None, three=None, four=None, five=None),
1255        )
1256
1257        obj2 = TestObjectFactory(even=True)
1258        self.assertEqual(
1259            obj2.as_dict(),
1260            dict(one=None, two=True, three=None, four=True, five=None),
1261        )
1262
1263        obj3 = TestObjectFactory(odd=True)
1264        self.assertEqual(
1265            obj3.as_dict(),
1266            dict(one=True, two=None, three=True, four=None, five=True),
1267        )
1268
1269        obj4 = TestObjectFactory(even=True, odd=True)
1270        self.assertEqual(
1271            obj4.as_dict(),
1272            dict(one=True, two=True, three=True, four=True, five=True),
1273        )
1274
1275        obj5 = TestObjectFactory(odd=True, two=True)
1276        self.assertEqual(
1277            obj5.as_dict(),
1278            dict(one=True, two=True, three=True, four=None, five=True),
1279        )
1280
1281    def test_post_generation_traits(self):
1282        @factory.post_generation
1283        def compute(obj, _create, _value, power=2, **kwargs):
1284            obj.value = obj.value ** power
1285
1286        class DummyFactory(factory.Factory):
1287            class Meta:
1288                model = Dummy
1289
1290            value = 3
1291
1292            class Params:
1293                exponentiate = factory.Trait(apply_exponent=compute)
1294
1295        base = DummyFactory.build()
1296        self.assertEqual(dict(value=3), base.as_dict)
1297
1298        exp = DummyFactory.build(exponentiate=True)
1299        self.assertEqual(dict(value=9), exp.as_dict)
1300
1301        higher = DummyFactory.build(exponentiate=True, apply_exponent__power=4)
1302        self.assertEqual(dict(value=81), higher.as_dict)
1303
1304    def test_traits_inheritance(self):
1305        """A trait can be set in an inherited class."""
1306        class TestObjectFactory(factory.Factory):
1307            class Meta:
1308                model = TestObject
1309
1310            class Params:
1311                even = factory.Trait(two=True, four=True)
1312                odd = factory.Trait(one=True, three=True, five=True)
1313
1314        class EvenObjectFactory(TestObjectFactory):
1315            even = True
1316
1317        # Simple call
1318        obj1 = EvenObjectFactory()
1319        self.assertEqual(
1320            obj1.as_dict(),
1321            dict(one=None, two=True, three=None, four=True, five=None),
1322        )
1323
1324        # Force-disable it
1325        obj2 = EvenObjectFactory(even=False)
1326        self.assertEqual(
1327            obj2.as_dict(),
1328            dict(one=None, two=None, three=None, four=None, five=None),
1329        )
1330
1331    def test_traits_override_params(self):
1332        """Override a Params value in a trait"""
1333        class TestObjectFactory(factory.Factory):
1334            class Meta:
1335                model = TestObject
1336
1337            one = factory.LazyAttribute(lambda o: o.zero + 1)
1338
1339            class Params:
1340                zero = 0
1341                plus_one = factory.Trait(zero=1)
1342
1343        obj = TestObjectFactory(plus_one=True)
1344        self.assertEqual(obj.one, 2)
1345
1346    def test_traits_override(self):
1347        """Override a trait in a subclass."""
1348        class TestObjectFactory(factory.Factory):
1349            class Meta:
1350                model = TestObject
1351
1352            class Params:
1353                even = factory.Trait(two=True, four=True)
1354                odd = factory.Trait(one=True, three=True, five=True)
1355
1356        class WeirdMathFactory(TestObjectFactory):
1357            class Params:
1358                # Here, one is even.
1359                even = factory.Trait(two=True, four=True, one=True)
1360
1361        obj = WeirdMathFactory(even=True)
1362        self.assertEqual(
1363            obj.as_dict(),
1364            dict(one=True, two=True, three=None, four=True, five=None),
1365        )
1366
1367    def test_traits_chaining(self):
1368        """Use a trait to enable other traits."""
1369        class TestObjectFactory(factory.Factory):
1370            class Meta:
1371                model = TestObject
1372
1373            class Params:
1374                even = factory.Trait(two=True, four=True)
1375                odd = factory.Trait(one=True, three=True, five=True)
1376                full = factory.Trait(even=True, odd=True)
1377                override = factory.Trait(even=True, two=False)
1378
1379        # Setting "full" should enable all fields.
1380        obj = TestObjectFactory(full=True)
1381        self.assertEqual(
1382            obj.as_dict(),
1383            dict(one=True, two=True, three=True, four=True, five=True),
1384        )
1385
1386        # Does it break usual patterns?
1387        obj1 = TestObjectFactory()
1388        self.assertEqual(
1389            obj1.as_dict(),
1390            dict(one=None, two=None, three=None, four=None, five=None),
1391        )
1392
1393        obj2 = TestObjectFactory(even=True)
1394        self.assertEqual(
1395            obj2.as_dict(),
1396            dict(one=None, two=True, three=None, four=True, five=None),
1397        )
1398
1399        obj3 = TestObjectFactory(odd=True)
1400        self.assertEqual(
1401            obj3.as_dict(),
1402            dict(one=True, two=None, three=True, four=None, five=True),
1403        )
1404
1405        # Setting override should override two and set it to False
1406        obj = TestObjectFactory(override=True)
1407        self.assertEqual(
1408            obj.as_dict(),
1409            dict(one=None, two=False, three=None, four=True, five=None),
1410        )
1411
1412    def test_prevent_cyclic_traits(self):
1413
1414        with self.assertRaises(errors.CyclicDefinitionError):
1415            class TestObjectFactory(factory.Factory):
1416                class Meta:
1417                    model = TestObject
1418
1419                class Params:
1420                    a = factory.Trait(b=True, one=True)
1421                    b = factory.Trait(a=True, two=True)
1422
1423    def test_deep_traits(self):
1424        class TestObjectFactory(factory.Factory):
1425            class Meta:
1426                model = TestObject
1427
1428        class WrapperFactory(factory.Factory):
1429            class Meta:
1430                model = TestObject
1431
1432            class Params:
1433                deep_one = factory.Trait(
1434                    one=1,
1435                    two__one=2,
1436                )
1437
1438            two = factory.SubFactory(TestObjectFactory)
1439
1440        wrapper = WrapperFactory(deep_one=True)
1441        self.assertEqual(1, wrapper.one)
1442        self.assertEqual(2, wrapper.two.one)
1443
1444    def test_traits_and_postgeneration(self):
1445        """A trait parameter should be resolved before post_generation hooks.
1446
1447        See https://github.com/FactoryBoy/factory_boy/issues/466.
1448        """
1449        PRICES = {}
1450
1451        Pizza = collections.namedtuple('Pizza', ['style', 'toppings'])
1452
1453        class PizzaFactory(factory.Factory):
1454            class Meta:
1455                model = Pizza
1456
1457            class Params:
1458                fancy = factory.Trait(
1459                    toppings=['eggs', 'ham', 'extra_cheese'],
1460                    pricing__extra=10,
1461                )
1462
1463            pricing__extra = 0
1464            toppings = ['tomato', 'cheese']
1465            style = 'margharita'
1466
1467            @factory.post_generation
1468            def pricing(self, create, extracted, base_price=5, extra=0, **kwargs):
1469                PRICES[base_price + extra] = self
1470
1471        p = PizzaFactory.build()
1472        self.assertEqual({5: p}, PRICES)
1473
1474
1475class SubFactoryTestCase(unittest.TestCase):
1476    def test_sub_factory(self):
1477        class TestModel2(FakeModel):
1478            pass
1479
1480        class TestModelFactory(FakeModelFactory):
1481            class Meta:
1482                model = TestModel
1483            one = 3
1484
1485        class TestModel2Factory(FakeModelFactory):
1486            class Meta:
1487                model = TestModel2
1488            two = factory.SubFactory(TestModelFactory, one=1)
1489
1490        test_model = TestModel2Factory(two__one=4)
1491        self.assertEqual(4, test_model.two.one)
1492        self.assertEqual(1, test_model.id)
1493        self.assertEqual(1, test_model.two.id)
1494
1495    def test_sub_factory_with_lazy_fields(self):
1496        class TestModel2(FakeModel):
1497            pass
1498
1499        class TestModelFactory(FakeModelFactory):
1500            class Meta:
1501                model = TestModel
1502
1503        class TestModel2Factory(FakeModelFactory):
1504            class Meta:
1505                model = TestModel2
1506            two = factory.SubFactory(
1507                TestModelFactory,
1508                one=factory.Sequence(lambda n: 'x%dx' % n),
1509                two=factory.LazyAttribute(lambda o: f'{o.one}{o.one}'),
1510            )
1511
1512        test_model = TestModel2Factory(one=42)
1513        self.assertEqual('x0x', test_model.two.one)
1514        self.assertEqual('x0xx0x', test_model.two.two)
1515
1516    def test_sub_factory_with_lazy_fields_access_factory_parent(self):
1517        class TestModel2(FakeModel):
1518            pass
1519
1520        class TestModelFactory(FakeModelFactory):
1521            class Meta:
1522                model = TestModel
1523            one = 3
1524
1525        class TestModel2Factory(FakeModelFactory):
1526            class Meta:
1527                model = TestModel2
1528            one = 'parent'
1529            child = factory.SubFactory(
1530                TestModelFactory,
1531                one=factory.LazyAttribute(lambda o: '%s child' % o.factory_parent.one),
1532            )
1533
1534        test_model = TestModel2Factory()
1535        self.assertEqual('parent child', test_model.child.one)
1536
1537    def test_sub_factory_and_sequence(self):
1538        class TestObject:
1539            def __init__(self, **kwargs):
1540                for k, v in kwargs.items():
1541                    setattr(self, k, v)
1542
1543        class TestObjectFactory(factory.Factory):
1544            class Meta:
1545                model = TestObject
1546
1547            one = factory.Sequence(lambda n: int(n))
1548
1549        class WrappingTestObjectFactory(factory.Factory):
1550            class Meta:
1551                model = TestObject
1552
1553            wrapped = factory.SubFactory(TestObjectFactory)
1554
1555        wrapping = WrappingTestObjectFactory.build()
1556        self.assertEqual(0, wrapping.wrapped.one)
1557        wrapping = WrappingTestObjectFactory.build()
1558        self.assertEqual(1, wrapping.wrapped.one)
1559
1560    def test_sub_factory_overriding(self):
1561        class TestObject:
1562            def __init__(self, **kwargs):
1563                for k, v in kwargs.items():
1564                    setattr(self, k, v)
1565
1566        class TestObjectFactory(factory.Factory):
1567            class Meta:
1568                model = TestObject
1569
1570        class OtherTestObject:
1571            def __init__(self, **kwargs):
1572                for k, v in kwargs.items():
1573                    setattr(self, k, v)
1574
1575        class WrappingTestObjectFactory(factory.Factory):
1576            class Meta:
1577                model = OtherTestObject
1578
1579            wrapped = factory.SubFactory(TestObjectFactory, two=2, four=4)
1580            wrapped__two = 4
1581            wrapped__three = 3
1582
1583        wrapping = WrappingTestObjectFactory.build()
1584        self.assertEqual(wrapping.wrapped.two, 4)
1585        self.assertEqual(wrapping.wrapped.three, 3)
1586        self.assertEqual(wrapping.wrapped.four, 4)
1587
1588    def test_sub_factory_deep_overrides(self):
1589        Author = collections.namedtuple('Author', ['name', 'country'])
1590        Book = collections.namedtuple('Book', ['title', 'author'])
1591        Chapter = collections.namedtuple('Chapter', ['book', 'number'])
1592
1593        class AuthorFactory(factory.Factory):
1594            class Meta:
1595                model = Author
1596            name = "John"
1597            country = 'XX'
1598
1599        class BookFactory(factory.Factory):
1600            class Meta:
1601                model = Book
1602            title = "The mighty adventures of nobody."
1603            author = factory.SubFactory(AuthorFactory)
1604
1605        class ChapterFactory(factory.Factory):
1606            class Meta:
1607                model = Chapter
1608            book = factory.SubFactory(BookFactory)
1609            number = factory.Sequence(lambda n: n)
1610            book__author__country = factory.LazyAttribute(lambda o: 'FR')
1611
1612        chapter = ChapterFactory()
1613        self.assertEqual('FR', chapter.book.author.country)
1614
1615    def test_nested_sub_factory(self):
1616        """Test nested sub-factories."""
1617
1618        class TestObject:
1619            def __init__(self, **kwargs):
1620                for k, v in kwargs.items():
1621                    setattr(self, k, v)
1622
1623        class TestObjectFactory(factory.Factory):
1624            class Meta:
1625                model = TestObject
1626
1627        class WrappingTestObjectFactory(factory.Factory):
1628            class Meta:
1629                model = TestObject
1630
1631            wrapped = factory.SubFactory(TestObjectFactory)
1632            wrapped_bis = factory.SubFactory(TestObjectFactory, one=1)
1633
1634        class OuterWrappingTestObjectFactory(factory.Factory):
1635            class Meta:
1636                model = TestObject
1637
1638            wrap = factory.SubFactory(WrappingTestObjectFactory, wrapped__two=2)
1639
1640        outer = OuterWrappingTestObjectFactory.build()
1641        self.assertEqual(outer.wrap.wrapped.two, 2)
1642        self.assertEqual(outer.wrap.wrapped_bis.one, 1)
1643
1644    def test_nested_sub_factory_with_overridden_sub_factories(self):
1645        """Test nested sub-factories, with attributes overridden with subfactories."""
1646
1647        class TestObject:
1648            def __init__(self, **kwargs):
1649                for k, v in kwargs.items():
1650                    setattr(self, k, v)
1651
1652        class TestObjectFactory(factory.Factory):
1653            class Meta:
1654                model = TestObject
1655            two = 'two'
1656
1657        class WrappingTestObjectFactory(factory.Factory):
1658            class Meta:
1659                model = TestObject
1660
1661            wrapped = factory.SubFactory(TestObjectFactory)
1662            friend = factory.LazyAttribute(lambda o: o.wrapped.two.four + 1)
1663
1664        class OuterWrappingTestObjectFactory(factory.Factory):
1665            class Meta:
1666                model = TestObject
1667
1668            wrap = factory.SubFactory(
1669                WrappingTestObjectFactory,
1670                wrapped__two=factory.SubFactory(TestObjectFactory, four=4),
1671            )
1672
1673        outer = OuterWrappingTestObjectFactory.build()
1674        self.assertEqual(outer.wrap.wrapped.two.four, 4)
1675        self.assertEqual(outer.wrap.friend, 5)
1676
1677    def test_nested_subfactory_with_override(self):
1678        """Tests replacing a SubFactory field with an actual value."""
1679
1680        # The test class
1681        class TestObject:
1682            def __init__(self, two='one', wrapped=None):
1683                self.two = two
1684                self.wrapped = wrapped
1685
1686        # Innermost factory
1687        class TestObjectFactory(factory.Factory):
1688            class Meta:
1689                model = TestObject
1690            two = 'two'
1691
1692        # Intermediary factory
1693        class WrappingTestObjectFactory(factory.Factory):
1694            class Meta:
1695                model = TestObject
1696
1697            wrapped = factory.SubFactory(TestObjectFactory)
1698            wrapped__two = 'three'
1699
1700        obj = TestObject(two='four')
1701        outer = WrappingTestObjectFactory(wrapped=obj)
1702        self.assertEqual(obj, outer.wrapped)
1703        self.assertEqual('four', outer.wrapped.two)
1704
1705    def test_deep_nested_subfactory(self):
1706        counter = iter(range(100))
1707
1708        class Node:
1709            def __init__(self, label, child=None):
1710                self.id = next(counter)
1711                self.label = label
1712                self.child = child
1713
1714        class LeafFactory(factory.Factory):
1715            class Meta:
1716                model = Node
1717            label = 'leaf'
1718
1719        class BranchFactory(factory.Factory):
1720            class Meta:
1721                model = Node
1722            label = 'branch'
1723            child = factory.SubFactory(LeafFactory)
1724
1725        class TreeFactory(factory.Factory):
1726            class Meta:
1727                model = Node
1728            label = 'tree'
1729            child = factory.SubFactory(BranchFactory)
1730            child__child__label = 'magic-leaf'
1731
1732        leaf = LeafFactory()
1733        # Magic corruption did happen here once:
1734        # forcing child__child=X while another part already set another value
1735        # on child__child__label meant that the value passed for child__child
1736        # was merged into the factory's inner declaration dict.
1737        mtree_1 = TreeFactory(child__child=leaf)
1738        mtree_2 = TreeFactory()
1739
1740        self.assertEqual(0, mtree_1.child.child.id)
1741        self.assertEqual('leaf', mtree_1.child.child.label)
1742        self.assertEqual(1, mtree_1.child.id)
1743        self.assertEqual('branch', mtree_1.child.label)
1744        self.assertEqual(2, mtree_1.id)
1745        self.assertEqual('tree', mtree_1.label)
1746        self.assertEqual(3, mtree_2.child.child.id)
1747        self.assertEqual('magic-leaf', mtree_2.child.child.label)
1748        self.assertEqual(4, mtree_2.child.id)
1749        self.assertEqual('branch', mtree_2.child.label)
1750        self.assertEqual(5, mtree_2.id)
1751        self.assertEqual('tree', mtree_2.label)
1752
1753    def test_sub_factory_and_inheritance(self):
1754        """Test inheriting from a factory with subfactories, overriding."""
1755        class TestObject:
1756            def __init__(self, **kwargs):
1757                for k, v in kwargs.items():
1758                    setattr(self, k, v)
1759
1760        class TestObjectFactory(factory.Factory):
1761            class Meta:
1762                model = TestObject
1763            two = 'two'
1764
1765        class WrappingTestObjectFactory(factory.Factory):
1766            class Meta:
1767                model = TestObject
1768
1769            wrapped = factory.SubFactory(TestObjectFactory)
1770            friend = factory.LazyAttribute(lambda o: o.wrapped.two + 1)
1771
1772        class ExtendedWrappingTestObjectFactory(WrappingTestObjectFactory):
1773            wrapped__two = 4
1774
1775        wrapping = ExtendedWrappingTestObjectFactory.build()
1776        self.assertEqual(wrapping.wrapped.two, 4)
1777        self.assertEqual(wrapping.friend, 5)
1778
1779    def test_diamond_sub_factory(self):
1780        """Tests the case where an object has two fields with a common field."""
1781        class InnerMost:
1782            def __init__(self, a, b):
1783                self.a = a
1784                self.b = b
1785
1786        class SideA:
1787            def __init__(self, inner_from_a):
1788                self.inner_from_a = inner_from_a
1789
1790        class SideB:
1791            def __init__(self, inner_from_b):
1792                self.inner_from_b = inner_from_b
1793
1794        class OuterMost:
1795            def __init__(self, foo, side_a, side_b):
1796                self.foo = foo
1797                self.side_a = side_a
1798                self.side_b = side_b
1799
1800        class InnerMostFactory(factory.Factory):
1801            class Meta:
1802                model = InnerMost
1803            a = 15
1804            b = 20
1805
1806        class SideAFactory(factory.Factory):
1807            class Meta:
1808                model = SideA
1809            inner_from_a = factory.SubFactory(InnerMostFactory, a=20)
1810
1811        class SideBFactory(factory.Factory):
1812            class Meta:
1813                model = SideB
1814            inner_from_b = factory.SubFactory(InnerMostFactory, b=15)
1815
1816        class OuterMostFactory(factory.Factory):
1817            class Meta:
1818                model = OuterMost
1819
1820            foo = 30
1821            side_a = factory.SubFactory(
1822                SideAFactory,
1823                inner_from_a__a=factory.ContainerAttribute(
1824                    lambda obj, containers: containers[1].foo * 2,
1825                )
1826            )
1827            side_b = factory.SubFactory(
1828                SideBFactory,
1829                inner_from_b=factory.ContainerAttribute(
1830                    lambda obj, containers: containers[0].side_a.inner_from_a,
1831                )
1832            )
1833
1834        outer = OuterMostFactory.build()
1835        self.assertEqual(outer.foo, 30)
1836        self.assertEqual(outer.side_a.inner_from_a, outer.side_b.inner_from_b)
1837        self.assertEqual(outer.side_a.inner_from_a.a, outer.foo * 2)
1838        self.assertEqual(outer.side_a.inner_from_a.b, 20)
1839
1840        outer = OuterMostFactory.build(side_a__inner_from_a__b=4)
1841        self.assertEqual(outer.foo, 30)
1842        self.assertEqual(outer.side_a.inner_from_a, outer.side_b.inner_from_b)
1843        self.assertEqual(outer.side_a.inner_from_a.a, outer.foo * 2)
1844        self.assertEqual(outer.side_a.inner_from_a.b, 4)
1845
1846    def test_nonstrict_container_attribute(self):
1847        class TestModel2(FakeModel):
1848            pass
1849
1850        class TestModelFactory(FakeModelFactory):
1851            class Meta:
1852                model = TestModel
1853            one = 3
1854            two = factory.ContainerAttribute(lambda obj, containers: len(containers or []), strict=False)
1855
1856        class TestModel2Factory(FakeModelFactory):
1857            class Meta:
1858                model = TestModel2
1859            one = 1
1860            two = factory.SubFactory(TestModelFactory, one=1)
1861
1862        obj = TestModel2Factory.build()
1863        self.assertEqual(1, obj.one)
1864        self.assertEqual(1, obj.two.one)
1865        self.assertEqual(1, obj.two.two)
1866
1867        obj = TestModelFactory()
1868        self.assertEqual(3, obj.one)
1869        self.assertEqual(0, obj.two)
1870
1871    def test_strict_container_attribute(self):
1872        class TestModel2(FakeModel):
1873            pass
1874
1875        class TestModelFactory(FakeModelFactory):
1876            class Meta:
1877                model = TestModel
1878            sample_int = 3
1879            container_len = factory.ContainerAttribute(lambda obj, containers: len(containers or []), strict=True)
1880
1881        class TestModel2Factory(FakeModelFactory):
1882            class Meta:
1883                model = TestModel2
1884            sample_int = 1
1885            descendant = factory.SubFactory(TestModelFactory, sample_int=1)
1886
1887        obj = TestModel2Factory.build()
1888        self.assertEqual(1, obj.sample_int)
1889        self.assertEqual(1, obj.descendant.sample_int)
1890        self.assertEqual(1, obj.descendant.container_len)
1891
1892        with self.assertRaises(TypeError):
1893            TestModelFactory.build()
1894
1895    def test_function_container_attribute(self):
1896        class TestModel2(FakeModel):
1897            pass
1898
1899        class TestModelFactory(FakeModelFactory):
1900            class Meta:
1901                model = TestModel
1902            sample_int = 3
1903
1904            @factory.container_attribute
1905            def container_len(self, containers):
1906                if containers:
1907                    return len(containers)
1908                return 42
1909
1910        class TestModel2Factory(FakeModelFactory):
1911            class Meta:
1912                model = TestModel2
1913            sample_int = 1
1914            descendant = factory.SubFactory(TestModelFactory, sample_int=1)
1915
1916        obj = TestModel2Factory.build()
1917        self.assertEqual(1, obj.sample_int)
1918        self.assertEqual(1, obj.descendant.sample_int)
1919        self.assertEqual(1, obj.descendant.container_len)
1920
1921        obj = TestModelFactory()
1922        self.assertEqual(3, obj.sample_int)
1923        self.assertEqual(42, obj.container_len)
1924
1925
1926class IteratorTestCase(unittest.TestCase):
1927
1928    def test_iterator(self):
1929        class TestObjectFactory(factory.Factory):
1930            class Meta:
1931                model = TestObject
1932
1933            one = factory.Iterator(range(10, 30))
1934
1935        objs = TestObjectFactory.build_batch(20)
1936
1937        for i, obj in enumerate(objs):
1938            self.assertEqual(i + 10, obj.one)
1939
1940    @utils.disable_warnings
1941    def test_iterator_list_comprehension_protected(self):
1942        class TestObjectFactory(factory.Factory):
1943            class Meta:
1944                model = TestObject
1945
1946            one = factory.Iterator([_j * 3 for _j in range(5)])
1947
1948        # Scope bleeding : _j will end up in TestObjectFactory's scope.
1949        # But factory_boy ignores it, as a protected variable.
1950        objs = TestObjectFactory.build_batch(20)
1951
1952        for i, obj in enumerate(objs):
1953            self.assertEqual(3 * (i % 5), obj.one)
1954
1955    def test_iterator_decorator(self):
1956        class TestObjectFactory(factory.Factory):
1957            class Meta:
1958                model = TestObject
1959
1960            @factory.iterator
1961            def one():
1962                yield from range(10, 50)
1963
1964        objs = TestObjectFactory.build_batch(20)
1965
1966        for i, obj in enumerate(objs):
1967            self.assertEqual(i + 10, obj.one)
1968
1969    def test_iterator_late_loading(self):
1970        """Ensure that Iterator doesn't unroll on class creation.
1971
1972        This allows, for Django objects, to call:
1973        foo = factory.Iterator(models.MyThingy.objects.all())
1974        """
1975        class DBRequest:
1976            def __init__(self):
1977                self.ready = False
1978
1979            def __iter__(self):
1980                if not self.ready:
1981                    raise ValueError("Not ready!!")
1982                return iter([1, 2, 3])
1983
1984        # calling __iter__() should crash
1985        req1 = DBRequest()
1986        with self.assertRaises(ValueError):
1987            iter(req1)
1988
1989        req2 = DBRequest()
1990
1991        class TestObjectFactory(factory.Factory):
1992            class Meta:
1993                model = TestObject
1994
1995            one = factory.Iterator(req2)
1996
1997        req2.ready = True
1998        obj = TestObjectFactory()
1999        self.assertEqual(1, obj.one)
2000
2001    def test_iterator_time_manipulation(self):
2002        class TestObjectFactory(factory.Factory):
2003            class Meta:
2004                model = TestObject
2005
2006            @factory.iterator
2007            def one():
2008                now = datetime.datetime.now()
2009                yield now + datetime.timedelta(hours=1)
2010                yield now + datetime.timedelta(hours=2)
2011
2012        obj1, obj2, obj3 = TestObjectFactory.create_batch(3)
2013        # Timers should be t+1H, t+2H, t+1H, t+2H, etc.
2014        self.assertEqual(datetime.timedelta(hours=1), obj2.one - obj1.one)
2015        self.assertEqual(obj1.one, obj3.one)
2016
2017
2018class BetterFakeModelManager:
2019    def __init__(self, keys, instance):
2020        self.keys = keys
2021        self.instance = instance
2022
2023    def get_or_create(self, **kwargs):
2024        defaults = kwargs.pop('defaults', {})
2025        if kwargs == self.keys:
2026            return self.instance, False
2027        kwargs.update(defaults)
2028        instance = FakeModel.create(**kwargs)
2029        instance.id = 2
2030        return instance, True
2031
2032    def using(self, db):
2033        return self
2034
2035
2036class BetterFakeModel:
2037    @classmethod
2038    def create(cls, **kwargs):
2039        instance = cls(**kwargs)
2040        instance.id = 1
2041        return instance
2042
2043    def __init__(self, **kwargs):
2044        for name, value in kwargs.items():
2045            setattr(self, name, value)
2046            self.id = None
2047
2048
2049class DjangoModelFactoryTestCase(unittest.TestCase):
2050    def test_simple(self):
2051        class FakeModelFactory(factory.django.DjangoModelFactory):
2052            class Meta:
2053                model = FakeModel
2054
2055        obj = FakeModelFactory(one=1)
2056        self.assertEqual(1, obj.one)
2057        self.assertEqual(2, obj.id)
2058
2059    def test_existing_instance(self):
2060        prev = BetterFakeModel.create(x=1, y=2, z=3)
2061        prev.id = 42
2062
2063        class MyFakeModel(BetterFakeModel):
2064            objects = BetterFakeModelManager({'x': 1}, prev)
2065
2066        class MyFakeModelFactory(factory.django.DjangoModelFactory):
2067            class Meta:
2068                model = MyFakeModel
2069                django_get_or_create = ('x',)
2070            x = 1
2071            y = 4
2072            z = 6
2073
2074        obj = MyFakeModelFactory()
2075        self.assertEqual(prev, obj)
2076        self.assertEqual(1, obj.x)
2077        self.assertEqual(2, obj.y)
2078        self.assertEqual(3, obj.z)
2079        self.assertEqual(42, obj.id)
2080
2081    def test_existing_instance_complex_key(self):
2082        prev = BetterFakeModel.create(x=1, y=2, z=3)
2083        prev.id = 42
2084
2085        class MyFakeModel(BetterFakeModel):
2086            objects = BetterFakeModelManager({'x': 1, 'y': 2, 'z': 3}, prev)
2087
2088        class MyFakeModelFactory(factory.django.DjangoModelFactory):
2089            class Meta:
2090                model = MyFakeModel
2091                django_get_or_create = ('x', 'y', 'z')
2092            x = 1
2093            y = 4
2094            z = 6
2095
2096        obj = MyFakeModelFactory(y=2, z=3)
2097        self.assertEqual(prev, obj)
2098        self.assertEqual(1, obj.x)
2099        self.assertEqual(2, obj.y)
2100        self.assertEqual(3, obj.z)
2101        self.assertEqual(42, obj.id)
2102
2103    def test_new_instance(self):
2104        prev = BetterFakeModel.create(x=1, y=2, z=3)
2105        prev.id = 42
2106
2107        class MyFakeModel(BetterFakeModel):
2108            objects = BetterFakeModelManager({'x': 1}, prev)
2109
2110        class MyFakeModelFactory(factory.django.DjangoModelFactory):
2111            class Meta:
2112                model = MyFakeModel
2113                django_get_or_create = ('x',)
2114            x = 1
2115            y = 4
2116            z = 6
2117
2118        obj = MyFakeModelFactory(x=2)
2119        self.assertNotEqual(prev, obj)
2120        self.assertEqual(2, obj.x)
2121        self.assertEqual(4, obj.y)
2122        self.assertEqual(6, obj.z)
2123        self.assertEqual(2, obj.id)
2124
2125    def test_new_instance_complex_key(self):
2126        prev = BetterFakeModel.create(x=1, y=2, z=3)
2127        prev.id = 42
2128
2129        class MyFakeModel(BetterFakeModel):
2130            objects = BetterFakeModelManager({'x': 1, 'y': 2, 'z': 3}, prev)
2131
2132        class MyFakeModelFactory(factory.django.DjangoModelFactory):
2133            class Meta:
2134                model = MyFakeModel
2135                django_get_or_create = ('x', 'y', 'z')
2136            x = 1
2137            y = 4
2138            z = 6
2139
2140        obj = MyFakeModelFactory(y=2, z=4)
2141        self.assertNotEqual(prev, obj)
2142        self.assertEqual(1, obj.x)
2143        self.assertEqual(2, obj.y)
2144        self.assertEqual(4, obj.z)
2145        self.assertEqual(2, obj.id)
2146
2147    def test_sequence(self):
2148        class TestModelFactory(factory.django.DjangoModelFactory):
2149            class Meta:
2150                model = TestModel
2151
2152            a = factory.Sequence(lambda n: 'foo_%s' % n)
2153
2154        o1 = TestModelFactory()
2155        o2 = TestModelFactory()
2156
2157        self.assertEqual('foo_0', o1.a)
2158        self.assertEqual('foo_1', o2.a)
2159
2160        o3 = TestModelFactory.build()
2161        o4 = TestModelFactory.build()
2162
2163        self.assertEqual('foo_2', o3.a)
2164        self.assertEqual('foo_3', o4.a)
2165
2166    def test_no_get_or_create(self):
2167        class TestModelFactory(factory.django.DjangoModelFactory):
2168            class Meta:
2169                model = TestModel
2170
2171            a = factory.Sequence(lambda n: 'foo_%s' % n)
2172
2173        o = TestModelFactory()
2174        self.assertEqual(None, o._defaults)
2175        self.assertEqual('foo_0', o.a)
2176        self.assertEqual(2, o.id)
2177
2178    def test_get_or_create(self):
2179        class TestModelFactory(factory.django.DjangoModelFactory):
2180            class Meta:
2181                model = TestModel
2182                django_get_or_create = ('a', 'b')
2183
2184            a = factory.Sequence(lambda n: 'foo_%s' % n)
2185            b = 2
2186            c = 3
2187            d = 4
2188
2189        o = TestModelFactory()
2190        self.assertEqual({'c': 3, 'd': 4}, o._defaults)
2191        self.assertEqual('foo_0', o.a)
2192        self.assertEqual(2, o.b)
2193        self.assertEqual(3, o.c)
2194        self.assertEqual(4, o.d)
2195        self.assertEqual(2, o.id)
2196
2197    def test_full_get_or_create(self):
2198        """Test a DjangoModelFactory with all fields in get_or_create."""
2199        class TestModelFactory(factory.django.DjangoModelFactory):
2200            class Meta:
2201                model = TestModel
2202                django_get_or_create = ('a', 'b', 'c', 'd')
2203
2204            a = factory.Sequence(lambda n: 'foo_%s' % n)
2205            b = 2
2206            c = 3
2207            d = 4
2208
2209        o = TestModelFactory()
2210        self.assertEqual({}, o._defaults)
2211        self.assertEqual('foo_0', o.a)
2212        self.assertEqual(2, o.b)
2213        self.assertEqual(3, o.c)
2214        self.assertEqual(4, o.d)
2215        self.assertEqual(2, o.id)
2216
2217
2218class PostGenerationTestCase(unittest.TestCase):
2219    def test_post_generation(self):
2220        class TestObjectFactory(factory.Factory):
2221            class Meta:
2222                model = TestObject
2223
2224            one = 1
2225
2226            @factory.post_generation
2227            def incr_one(self, _create, _increment):
2228                self.one += 1
2229
2230        obj = TestObjectFactory.build()
2231        self.assertEqual(2, obj.one)
2232        self.assertFalse(hasattr(obj, 'incr_one'))
2233
2234        obj = TestObjectFactory.build(one=2)
2235        self.assertEqual(3, obj.one)
2236        self.assertFalse(hasattr(obj, 'incr_one'))
2237
2238    def test_post_generation_hook(self):
2239        class TestObjectFactory(factory.Factory):
2240            class Meta:
2241                model = TestObject
2242
2243            one = 1
2244
2245            @factory.post_generation
2246            def incr_one(self, _create, _increment):
2247                self.one += 1
2248                return 42
2249
2250            @classmethod
2251            def _after_postgeneration(cls, obj, create, results):
2252                obj.create = create
2253                obj.results = results
2254
2255        obj = TestObjectFactory.build()
2256        self.assertEqual(2, obj.one)
2257        self.assertFalse(obj.create)
2258        self.assertEqual({'incr_one': 42}, obj.results)
2259
2260    def test_post_generation_extraction(self):
2261        class TestObjectFactory(factory.Factory):
2262            class Meta:
2263                model = TestObject
2264
2265            one = 1
2266
2267            @factory.post_generation
2268            def incr_one(self, _create, increment=1):
2269                self.one += increment
2270
2271        obj = TestObjectFactory.build(incr_one=2)
2272        self.assertEqual(3, obj.one)
2273        self.assertFalse(hasattr(obj, 'incr_one'))
2274
2275        obj = TestObjectFactory.build(one=2, incr_one=2)
2276        self.assertEqual(4, obj.one)
2277        self.assertFalse(hasattr(obj, 'incr_one'))
2278
2279    def test_post_generation_extraction_lambda(self):
2280
2281        def my_lambda(obj, create, extracted, **kwargs):
2282            self.assertTrue(isinstance(obj, TestObject))
2283            self.assertFalse(create)
2284            self.assertEqual(extracted, 42)
2285            self.assertEqual(kwargs, {'foo': 13})
2286
2287        class TestObjectFactory(factory.Factory):
2288            class Meta:
2289                model = TestObject
2290
2291            bar = factory.PostGeneration(my_lambda)
2292
2293        TestObjectFactory.build(bar=42, bar__foo=13)
2294
2295    def test_post_generation_override_with_extra(self):
2296        class TestObjectFactory(factory.Factory):
2297            class Meta:
2298                model = TestObject
2299
2300            one = 1
2301
2302            @factory.post_generation
2303            def incr_one(self, _create, override, **extra):
2304                multiplier = extra.get('multiplier', 1)
2305                if override is None:
2306                    override = 1
2307                self.one += override * multiplier
2308
2309        obj = TestObjectFactory.build()
2310        self.assertEqual(1 + 1 * 1, obj.one)
2311        obj = TestObjectFactory.build(incr_one=2)
2312        self.assertEqual(1 + 2 * 1, obj.one)
2313        obj = TestObjectFactory.build(incr_one__multiplier=4)
2314        self.assertEqual(1 + 1 * 4, obj.one)
2315        obj = TestObjectFactory.build(incr_one=2, incr_one__multiplier=5)
2316        self.assertEqual(1 + 2 * 5, obj.one)
2317
2318        # Passing extras through inherited params
2319        class OtherTestObjectFactory(TestObjectFactory):
2320            class Params:
2321                incr_one__multiplier = 4
2322
2323        obj = OtherTestObjectFactory.build()
2324        self.assertEqual(1 + 1 * 4, obj.one)
2325
2326    def test_post_generation_method_call(self):
2327        class TestObject:
2328            def __init__(self, one=None, two=None):
2329                self.one = one
2330                self.two = two
2331                self.extra = None
2332
2333            def call(self, *args, **kwargs):
2334                self.extra = (args, kwargs)
2335
2336        class TestObjectFactory(factory.Factory):
2337            class Meta:
2338                model = TestObject
2339            one = 3
2340            two = 2
2341            post_call = factory.PostGenerationMethodCall('call', one=1)
2342
2343        obj = TestObjectFactory.build()
2344        self.assertEqual(3, obj.one)
2345        self.assertEqual(2, obj.two)
2346        self.assertEqual(((), {'one': 1}), obj.extra)
2347
2348        obj = TestObjectFactory.build(post_call__one=2, post_call__two=3)
2349        self.assertEqual(3, obj.one)
2350        self.assertEqual(2, obj.two)
2351        self.assertEqual(((), {'one': 2, 'two': 3}), obj.extra)
2352
2353    def test_post_generation_extraction_declaration(self):
2354        LIBRARY = {}
2355
2356        Book = collections.namedtuple('Book', ['author'])
2357
2358        class BookFactory(factory.Factory):
2359            class Meta:
2360                model = Book
2361
2362            author = factory.Faker('name')
2363            register__reference = factory.Sequence(lambda n: n)
2364
2365            @factory.post_generation
2366            def register(self, create, extracted, reference=0, **kwargs):
2367                LIBRARY[reference] = self
2368
2369        book = BookFactory.build()
2370        self.assertEqual({0: book}, LIBRARY)
2371
2372
2373class RelatedFactoryTestCase(unittest.TestCase):
2374    def test_related_factory(self):
2375        class TestRelatedObject:
2376            def __init__(self, obj=None, one=None, two=None):
2377                obj.related = self
2378                self.one = one
2379                self.two = two
2380                self.three = obj
2381
2382        class TestRelatedObjectFactory(factory.Factory):
2383            class Meta:
2384                model = TestRelatedObject
2385            one = 1
2386            two = factory.LazyAttribute(lambda o: o.one + 1)
2387
2388        class TestObjectFactory(factory.Factory):
2389            class Meta:
2390                model = TestObject
2391            one = 3
2392            two = 2
2393            three = factory.RelatedFactory(
2394                TestRelatedObjectFactory,
2395                factory_related_name='obj',
2396            )
2397
2398        obj = TestObjectFactory.build()
2399        # Normal fields
2400        self.assertEqual(3, obj.one)
2401        self.assertEqual(2, obj.two)
2402        # RelatedFactory was built
2403        self.assertIsNone(obj.three)
2404        self.assertIsNotNone(obj.related)
2405        self.assertEqual(1, obj.related.one)
2406        self.assertEqual(2, obj.related.two)
2407        # RelatedFactory was passed "parent" object
2408        self.assertEqual(obj, obj.related.three)
2409
2410        obj = TestObjectFactory.build(three__one=3)
2411        # Normal fields
2412        self.assertEqual(3, obj.one)
2413        self.assertEqual(2, obj.two)
2414        # RelatedFactory was build
2415        self.assertIsNone(obj.three)
2416        self.assertIsNotNone(obj.related)
2417        # three__one was correctly parse
2418        self.assertEqual(3, obj.related.one)
2419        self.assertEqual(4, obj.related.two)
2420        # RelatedFactory received "parent" object
2421        self.assertEqual(obj, obj.related.three)
2422
2423    def test_related_factory_no_name(self):
2424        relateds = []
2425
2426        class TestRelatedObject:
2427            def __init__(self, obj=None, one=None, two=None):
2428                relateds.append(self)
2429                self.one = one
2430                self.two = two
2431                self.three = obj
2432
2433        class TestRelatedObjectFactory(factory.Factory):
2434            class Meta:
2435                model = TestRelatedObject
2436            one = 1
2437            two = factory.LazyAttribute(lambda o: o.one + 1)
2438
2439        class TestObjectFactory(factory.Factory):
2440            class Meta:
2441                model = TestObject
2442            one = 3
2443            two = 2
2444            three = factory.RelatedFactory(TestRelatedObjectFactory)
2445
2446        obj = TestObjectFactory.build()
2447        # Normal fields
2448        self.assertEqual(3, obj.one)
2449        self.assertEqual(2, obj.two)
2450        # RelatedFactory was built
2451        self.assertIsNone(obj.three)
2452        self.assertEqual(1, len(relateds))
2453        related = relateds[0]
2454        self.assertEqual(1, related.one)
2455        self.assertEqual(2, related.two)
2456        self.assertIsNone(related.three)
2457
2458        obj = TestObjectFactory.build(three__one=3)
2459        # Normal fields
2460        self.assertEqual(3, obj.one)
2461        self.assertEqual(2, obj.two)
2462        # RelatedFactory was build
2463        self.assertIsNone(obj.three)
2464        self.assertEqual(2, len(relateds))
2465
2466        related = relateds[1]
2467        self.assertEqual(3, related.one)
2468        self.assertEqual(4, related.two)
2469
2470    def test_related_factory_selfattribute(self):
2471        class TestRelatedObject:
2472            def __init__(self, obj=None, one=None, two=None):
2473                obj.related = self
2474                self.one = one
2475                self.two = two
2476                self.three = obj
2477
2478        class TestRelatedObjectFactory(factory.Factory):
2479            class Meta:
2480                model = TestRelatedObject
2481            one = 1
2482            two = factory.LazyAttribute(lambda o: o.one + 1)
2483
2484        class TestObjectFactory(factory.Factory):
2485            class Meta:
2486                model = TestObject
2487            one = 3
2488            two = 2
2489            three = factory.RelatedFactory(
2490                TestRelatedObjectFactory,
2491                factory_related_name='obj',
2492                two=factory.SelfAttribute('obj.two'),
2493            )
2494
2495        obj = TestObjectFactory.build(two=4)
2496        self.assertEqual(3, obj.one)
2497        self.assertEqual(4, obj.two)
2498        self.assertEqual(1, obj.related.one)
2499        self.assertEqual(4, obj.related.two)
2500
2501    def test_parameterized_related_factory(self):
2502        class TestRelatedObject:
2503            def __init__(self, obj=None, one=None, two=None):
2504                obj.related = self
2505                self.one = one
2506                self.two = two
2507                self.related = obj
2508
2509        class TestRelatedObjectFactory(factory.Factory):
2510            class Meta:
2511                model = TestRelatedObject
2512            one = 1
2513            two = factory.LazyAttribute(lambda o: o.one + 1)
2514
2515        class TestObjectFactory(factory.Factory):
2516            class Meta:
2517                model = TestObject
2518
2519            class Params:
2520                blah = 1
2521
2522            one = 3
2523            two = 2
2524            three = factory.RelatedFactory(
2525                TestRelatedObjectFactory,
2526                factory_related_name='obj',
2527            )
2528            three__two = factory.SelfAttribute('..blah')
2529
2530        obj = TestObjectFactory.build()
2531        self.assertEqual(3, obj.one)
2532        self.assertEqual(2, obj.two)
2533        self.assertEqual(1, obj.related.one)
2534        self.assertEqual(1, obj.related.two)
2535
2536        obj2 = TestObjectFactory.build(blah='blah')
2537        self.assertEqual('blah', obj2.related.two)
2538
2539
2540class RelatedListFactoryTestCase(unittest.TestCase):
2541    def test_related_factory_list_of_varying_size(self):
2542        # Create our list of expected "related object counts"
2543        related_list_sizes = [5, 5, 4, 4, 3, 3, 2, 2, 1, 1]
2544        RELATED_LIST_SIZE = lambda: related_list_sizes.pop()
2545
2546        class TestRelatedObject:
2547            def __init__(self, obj=None, one=None, two=None):
2548                # Mock out the 'List of Related Objects' generated by RelatedFactoryList
2549                if hasattr(obj, 'related_list'):
2550                    obj.related_list.append(self)
2551                else:
2552                    obj.related_list = [self]
2553                self.one = one
2554                self.two = two
2555                self.three = obj
2556
2557        class TestRelatedObjectFactoryList(factory.Factory):
2558            class Meta:
2559                model = TestRelatedObject
2560            one = 1
2561            two = factory.LazyAttribute(lambda o: o.one + 1)
2562
2563        class TestObjectFactory(factory.Factory):
2564            class Meta:
2565                model = TestObject
2566            one = 3
2567            two = 2
2568            # RELATED_LIST_SIZE is a lambda, this allows flexibility, as opposed
2569            # to creating "n" related objects for every parent object...
2570            three = factory.RelatedFactoryList(TestRelatedObjectFactoryList,
2571                                               'obj',
2572                                               size=RELATED_LIST_SIZE)
2573            # Create 5 TestObjectFactories: Each with 1, 2, ... 5 related objs
2574        for related_list_size in reversed(related_list_sizes[1::2]):
2575            obj = TestObjectFactory.build()
2576            # Normal fields
2577            self.assertEqual(3, obj.one)
2578            self.assertEqual(2, obj.two)
2579            # RelatedFactory was built
2580            self.assertIsNone(obj.three)
2581            self.assertIsNotNone(obj.related_list)
2582
2583            for related_obj in obj.related_list:
2584                self.assertEqual(1, related_obj.one)
2585                self.assertEqual(2, related_obj.two)
2586            # Each RelatedFactory in the RelatedFactoryList was passed the "parent" object
2587            self.assertEqual(related_list_size, len(obj.related_list))
2588            # obj.related is the list of TestRelatedObject(s)
2589            for related_obj in obj.related_list:
2590                self.assertEqual(obj, related_obj.three)
2591
2592            obj = TestObjectFactory.build(three__one=3)
2593            # Normal fields
2594            self.assertEqual(3, obj.one)
2595            self.assertEqual(2, obj.two)
2596            # RelatedFactory was build
2597            self.assertIsNone(obj.three)
2598            self.assertIsNotNone(obj.related_list)
2599            # three__one was correctly parse
2600            for related_obj in obj.related_list:
2601                self.assertEqual(3, related_obj.one)
2602                self.assertEqual(4, related_obj.two)
2603            # Each RelatedFactory in RelatedFactoryList received "parent" object
2604            self.assertEqual(related_list_size, len(obj.related_list))
2605            for related_obj in obj.related_list:
2606                self.assertEqual(obj, related_obj.three)
2607
2608    def test_related_factory_list_of_static_size(self):
2609        RELATED_LIST_SIZE = 4
2610
2611        class TestRelatedObject:
2612            def __init__(self, obj=None, one=None, two=None):
2613                # Mock out the 'List of Related Objects' generated by RelatedFactoryList
2614                if hasattr(obj, 'related_list'):
2615                    obj.related_list.append(self)
2616                else:
2617                    obj.related_list = [self]
2618
2619                self.one = one
2620                self.two = two
2621                self.three = obj
2622
2623        class TestRelatedObjectFactoryList(factory.Factory):
2624            class Meta:
2625                model = TestRelatedObject
2626            one = 1
2627            two = factory.LazyAttribute(lambda o: o.one + 1)
2628
2629        class TestObjectFactory(factory.Factory):
2630            class Meta:
2631                model = TestObject
2632            one = 3
2633            two = 2
2634            three = factory.RelatedFactoryList(TestRelatedObjectFactoryList, 'obj',
2635                                               size=RELATED_LIST_SIZE)
2636
2637        obj = TestObjectFactory.build()
2638        # Normal fields
2639        self.assertEqual(3, obj.one)
2640        self.assertEqual(2, obj.two)
2641        # RelatedFactory was built
2642        self.assertIsNone(obj.three)
2643        self.assertIsNotNone(obj.related_list)
2644
2645        for related_obj in obj.related_list:
2646            self.assertEqual(1, related_obj.one)
2647            self.assertEqual(2, related_obj.two)
2648        # Each RelatedFactory in the RelatedFactoryList was passed the "parent" object
2649        self.assertEqual(RELATED_LIST_SIZE, len(obj.related_list))
2650        # obj.related is the list of TestRelatedObject(s)
2651        for related_obj in obj.related_list:
2652            self.assertEqual(obj, related_obj.three)
2653
2654        obj = TestObjectFactory.build(three__one=3)
2655        # Normal fields
2656        self.assertEqual(3, obj.one)
2657        self.assertEqual(2, obj.two)
2658        # RelatedFactory was build
2659        self.assertIsNone(obj.three)
2660        self.assertIsNotNone(obj.related_list)
2661        # three__one was correctly parse
2662        for related_obj in obj.related_list:
2663            self.assertEqual(3, related_obj.one)
2664            self.assertEqual(4, related_obj.two)
2665        # Each RelatedFactory in RelatedFactoryList received "parent" object
2666        self.assertEqual(RELATED_LIST_SIZE, len(obj.related_list))
2667        for related_obj in obj.related_list:
2668            self.assertEqual(obj, related_obj.three)
2669
2670
2671class RelatedFactoryExtractionTestCase(unittest.TestCase):
2672    def setUp(self):
2673        self.relateds = []
2674
2675        class TestRelatedObject:
2676            def __init__(subself, obj):
2677                self.relateds.append(subself)
2678                subself.obj = obj
2679                obj.related = subself
2680
2681        class TestRelatedObjectFactory(factory.Factory):
2682            class Meta:
2683                model = TestRelatedObject
2684
2685        class TestObjectFactory(factory.Factory):
2686            class Meta:
2687                model = TestObject
2688            one = factory.RelatedFactory(
2689                TestRelatedObjectFactory,
2690                factory_related_name='obj',
2691            )
2692
2693        self.TestRelatedObject = TestRelatedObject
2694        self.TestRelatedObjectFactory = TestRelatedObjectFactory
2695        self.TestObjectFactory = TestObjectFactory
2696
2697    def test_no_extraction(self):
2698        o = self.TestObjectFactory()
2699        self.assertEqual(1, len(self.relateds))
2700        rel = self.relateds[0]
2701        self.assertEqual(o, rel.obj)
2702        self.assertEqual(rel, o.related)
2703
2704    def test_passed_value(self):
2705        o = self.TestObjectFactory(one=42)
2706        self.assertEqual([], self.relateds)
2707        self.assertFalse(hasattr(o, 'related'))
2708
2709    def test_passed_none(self):
2710        o = self.TestObjectFactory(one=None)
2711        self.assertEqual([], self.relateds)
2712        self.assertFalse(hasattr(o, 'related'))
2713
2714
2715class CircularTestCase(unittest.TestCase):
2716    def test_example(self):
2717        sys.path.insert(0, os.path.abspath(os.path.dirname(__file__)))
2718
2719        from .cyclic import foo
2720        f = foo.FooFactory.build(bar__foo=None)
2721        self.assertEqual(42, f.x)
2722        self.assertEqual(13, f.bar.y)
2723        self.assertIsNone(f.bar.foo)
2724
2725        from .cyclic import bar
2726        b = bar.BarFactory.build(foo__bar__foo__bar=None)
2727        self.assertEqual(13, b.y)
2728        self.assertEqual(42, b.foo.x)
2729        self.assertEqual(13, b.foo.bar.y)
2730        self.assertEqual(42, b.foo.bar.foo.x)
2731        self.assertIsNone(b.foo.bar.foo.bar)
2732
2733
2734class RepeatableRandomSeedFakerTests(unittest.TestCase):
2735    def test_same_seed_is_used_between_fuzzy_and_faker_generators(self):
2736        class StudentFactory(factory.Factory):
2737            one = factory.fuzzy.FuzzyDecimal(4.0)
2738            two = factory.Faker('name')
2739            three = factory.Faker('name', locale='it')
2740            four = factory.Faker('name')
2741
2742            class Meta:
2743                model = TestObject
2744
2745        seed = 1000
2746        factory.random.reseed_random(seed)
2747        students_1 = (StudentFactory(), StudentFactory())
2748
2749        factory.random.reseed_random(seed)
2750        students_2 = (StudentFactory(), StudentFactory())
2751
2752        self.assertEqual(students_1[0].one, students_2[0].one)
2753        self.assertEqual(students_1[0].two, students_2[0].two)
2754        self.assertEqual(students_1[0].three, students_2[0].three)
2755        self.assertEqual(students_1[0].four, students_2[0].four)
2756
2757
2758class SelfReferentialTests(unittest.TestCase):
2759    def test_no_parent(self):
2760        from .cyclic import self_ref
2761
2762        obj = self_ref.TreeElementFactory(parent__parent__parent=None)
2763        self.assertIsNone(obj.parent.parent.parent)
2764
2765    def test_deep(self):
2766        from .cyclic import self_ref
2767
2768        obj = self_ref.TreeElementFactory(parent__parent__parent__parent=None)
2769        self.assertIsNotNone(obj.parent)
2770        self.assertIsNotNone(obj.parent.parent)
2771        self.assertIsNotNone(obj.parent.parent.parent)
2772        self.assertIsNone(obj.parent.parent.parent.parent)
2773
2774
2775class DictTestCase(unittest.TestCase):
2776    def test_empty_dict(self):
2777        class TestObjectFactory(factory.Factory):
2778            class Meta:
2779                model = TestObject
2780            one = factory.Dict({})
2781
2782        o = TestObjectFactory()
2783        self.assertEqual({}, o.one)
2784
2785    def test_naive_dict(self):
2786        class TestObjectFactory(factory.Factory):
2787            class Meta:
2788                model = TestObject
2789            one = factory.Dict({'a': 1})
2790
2791        o = TestObjectFactory()
2792        self.assertEqual({'a': 1}, o.one)
2793
2794    def test_sequence_dict(self):
2795        class TestObjectFactory(factory.Factory):
2796            class Meta:
2797                model = TestObject
2798            one = factory.Dict({'a': factory.Sequence(lambda n: n + 2)})
2799
2800        o1 = TestObjectFactory()
2801        o2 = TestObjectFactory()
2802
2803        self.assertEqual({'a': 2}, o1.one)
2804        self.assertEqual({'a': 3}, o2.one)
2805
2806    def test_dict_override(self):
2807        class TestObjectFactory(factory.Factory):
2808            class Meta:
2809                model = TestObject
2810            one = factory.Dict({'a': 1})
2811
2812        o = TestObjectFactory(one__a=2)
2813        self.assertEqual({'a': 2}, o.one)
2814
2815    def test_dict_extra_key(self):
2816        class TestObjectFactory(factory.Factory):
2817            class Meta:
2818                model = TestObject
2819            one = factory.Dict({'a': 1})
2820
2821        o = TestObjectFactory(one__b=2)
2822        self.assertEqual({'a': 1, 'b': 2}, o.one)
2823
2824    def test_dict_merged_fields(self):
2825        class TestObjectFactory(factory.Factory):
2826            class Meta:
2827                model = TestObject
2828            two = 13
2829            one = factory.Dict({
2830                'one': 1,
2831                'two': 2,
2832                'three': factory.SelfAttribute('two'),
2833            })
2834
2835        o = TestObjectFactory(one__one=42)
2836        self.assertEqual({'one': 42, 'two': 2, 'three': 2}, o.one)
2837
2838    def test_nested_dicts(self):
2839        class TestObjectFactory(factory.Factory):
2840            class Meta:
2841                model = TestObject
2842            one = 1
2843            two = factory.Dict({
2844                'one': 3,
2845                'two': factory.SelfAttribute('one'),
2846                'three': factory.Dict({
2847                    'one': 5,
2848                    'two': factory.SelfAttribute('..one'),
2849                    'three': factory.SelfAttribute('...one'),
2850                }),
2851            })
2852
2853        o = TestObjectFactory()
2854        self.assertEqual(1, o.one)
2855        self.assertEqual({
2856            'one': 3,
2857            'two': 3,
2858            'three': {
2859                'one': 5,
2860                'two': 3,
2861                'three': 1,
2862            },
2863        }, o.two)
2864
2865
2866class ListTestCase(unittest.TestCase):
2867    def test_empty_list(self):
2868        class TestObjectFactory(factory.Factory):
2869            class Meta:
2870                model = TestObject
2871            one = factory.List([])
2872
2873        o = TestObjectFactory()
2874        self.assertEqual([], o.one)
2875
2876    def test_naive_list(self):
2877        class TestObjectFactory(factory.Factory):
2878            class Meta:
2879                model = TestObject
2880            one = factory.List([1])
2881
2882        o = TestObjectFactory()
2883        self.assertEqual([1], o.one)
2884
2885    def test_long_list(self):
2886        class TestObjectFactory(factory.Factory):
2887            class Meta:
2888                model = TestObject
2889            one = factory.List(list(range(100)))
2890
2891        o = TestObjectFactory()
2892        self.assertEqual(list(range(100)), o.one)
2893
2894    def test_sequence_list(self):
2895        class TestObjectFactory(factory.Factory):
2896            class Meta:
2897                model = TestObject
2898            one = factory.List([factory.Sequence(lambda n: n + 2)])
2899
2900        o1 = TestObjectFactory()
2901        o2 = TestObjectFactory()
2902
2903        self.assertEqual([2], o1.one)
2904        self.assertEqual([3], o2.one)
2905
2906    def test_list_override(self):
2907        class TestObjectFactory(factory.Factory):
2908            class Meta:
2909                model = TestObject
2910            one = factory.List([1])
2911
2912        o = TestObjectFactory(one__0=2)
2913        self.assertEqual([2], o.one)
2914
2915    def test_list_extra_key(self):
2916        class TestObjectFactory(factory.Factory):
2917            class Meta:
2918                model = TestObject
2919            one = factory.List([1])
2920
2921        o = TestObjectFactory(one__1=2)
2922        self.assertEqual([1, 2], o.one)
2923
2924    def test_list_merged_fields(self):
2925        class TestObjectFactory(factory.Factory):
2926            class Meta:
2927                model = TestObject
2928            two = 13
2929            one = factory.List([
2930                1,
2931                2,
2932                factory.SelfAttribute('1'),
2933            ])
2934
2935        o = TestObjectFactory(one__0=42)
2936        self.assertEqual([42, 2, 2], o.one)
2937
2938    def test_nested_lists(self):
2939        class TestObjectFactory(factory.Factory):
2940            class Meta:
2941                model = TestObject
2942
2943            one = 1
2944            two = factory.List([
2945                3,
2946                factory.SelfAttribute('0'),
2947                factory.List([
2948                    5,
2949                    factory.SelfAttribute('..0'),
2950                    factory.SelfAttribute('...one'),
2951                ]),
2952            ])
2953
2954        o = TestObjectFactory()
2955        self.assertEqual(1, o.one)
2956        self.assertEqual([
2957            3,
2958            3,
2959            [
2960                5,
2961                3,
2962                1,
2963            ],
2964        ], o.two)
2965