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