예제 #1
0
 def test_mutable_model_base(self):
     another_model_def = ModelDefinition.objects.create(
         app_label='mutant', object_name='AnotherModel')
     another_model_class = another_model_def.model_class()
     auto_pk_column = another_model_class._meta.pk.get_attname_column()[1]
     self.assertModelTablesColumnExists(another_model_class, auto_pk_column)
     with self.assertChecksumChange():
         CharFieldDefinition.objects.create(model_def=self.model_def,
                                            name='f1',
                                            max_length=25)
     model_class = self.model_def.model_class()
     with self.assertChecksumChange(another_model_def):
         base_definition = BaseDefinition(model_def=another_model_def)
         base_definition.base = model_class
         base_definition.save()
     self.assertModelTablesColumnDoesntExists(another_model_class,
                                              auto_pk_column)
     self.assertEqual(model_class.anothermodel.related.related_model,
                      another_model_class)
     remove_from_app_cache(another_model_class).mark_as_obsolete()
     self.assertFalse(hasattr(model_class, 'anothermodel'))
     another_model = another_model_class.objects.create(f1='Martinal')
     self.assertTrue(hasattr(model_class, 'anothermodel'))
     self.assertTrue(another_model_class.objects.exists())
     with self.assertChecksumChange():
         with self.assertChecksumChange(another_model_def):
             CharFieldDefinition.objects.create(model_def=self.model_def,
                                                name='f2',
                                                max_length=25,
                                                null=True)
     another_model = another_model_class.objects.get(pk=another_model.pk)
     self.assertIsNone(another_model.f2)
     another_model.f2 = 'Placebo'
     another_model.save()
예제 #2
0
 def test_mutable_model_base(self):
     another_model_def = ModelDefinition.objects.create(
         app_label='mutant', object_name='AnotherModel'
     )
     another_model_class = another_model_def.model_class()
     auto_pk_column = another_model_class._meta.pk.get_attname_column()[1]
     self.assertModelTablesColumnExists(another_model_class, auto_pk_column)
     with self.assertChecksumChange():
         CharFieldDefinition.objects.create(
             model_def=self.model_def, name='f1', max_length=25
         )
     model_class = self.model_def.model_class()
     with self.assertChecksumChange(another_model_def):
         base_definition = BaseDefinition(model_def=another_model_def)
         base_definition.base = model_class
         base_definition.save()
     self.assertModelTablesColumnDoesntExists(another_model_class, auto_pk_column)
     self.assertEqual(model_class.anothermodel.related.model, another_model_class)
     remove_from_app_cache(another_model_class).mark_as_obsolete()
     self.assertFalse(hasattr(model_class, 'anothermodel'))
     another_model = another_model_class.objects.create(f1='Martinal')
     self.assertTrue(hasattr(model_class, 'anothermodel'))
     self.assertTrue(another_model_class.objects.exists())
     with self.assertChecksumChange():
         with self.assertChecksumChange(another_model_def):
             CharFieldDefinition.objects.create(
                 model_def=self.model_def, name='f2', max_length=25,
                 null=True
             )
     another_model = another_model_class.objects.get(pk=another_model.pk)
     self.assertIsNone(another_model.f2)
     another_model.f2 = 'Placebo'
     another_model.save()
예제 #3
0
 def test_mutable_model_base(self):
     another_model_def = ModelDefinition.objects.create(
         app_label='app', object_name='AnotherModel')
     AnotherModel = another_model_def.model_class()
     auto_pk_column = AnotherModel._meta.pk.get_attname_column()[1]
     self.assertModelTablesColumnExists(AnotherModel, auto_pk_column)
     with self.assertChecksumChange():
         CharFieldDefinition.objects.create(model_def=self.model_def,
                                            name='f1',
                                            max_length=25)
     with self.assertChecksumChange(another_model_def):
         base_definition = BaseDefinition(model_def=another_model_def)
         base_definition.base = self.model_def.model_class()
         base_definition.save()
     self.assertModelTablesColumnDoesntExists(AnotherModel, auto_pk_column)
     another_model = AnotherModel.objects.create(f1='Martinal')
     self.assertTrue(AnotherModel.objects.exists())
     with self.assertChecksumChange():
         with self.assertChecksumChange(another_model_def):
             CharFieldDefinition.objects.create(model_def=self.model_def,
                                                name='f2',
                                                max_length=25,
                                                null=True)
     another_model = AnotherModel.objects.get(pk=another_model.pk)
     self.assertIsNone(another_model.f2)
     another_model.f2 = 'Placebo'
     another_model.save()
예제 #4
0
 def test_mutable_model_base(self):
     another_model_def = ModelDefinition.objects.create(
         app_label='app', object_name='AnotherModel'
     )
     AnotherModel = another_model_def.model_class()
     auto_pk_column = AnotherModel._meta.pk.get_attname_column()[1]
     self.assertModelTablesColumnExists(AnotherModel, auto_pk_column)
     with self.assertChecksumChange():
         CharFieldDefinition.objects.create(
             model_def=self.model_def, name='f1', max_length=25
         )
     with self.assertChecksumChange(another_model_def):
         base_definition = BaseDefinition(model_def=another_model_def)
         base_definition.base = self.model_def.model_class()
         base_definition.save()
     self.assertModelTablesColumnDoesntExists(AnotherModel, auto_pk_column)
     another_model = AnotherModel.objects.create(f1='Martinal')
     self.assertTrue(AnotherModel.objects.exists())
     with self.assertChecksumChange():
         with self.assertChecksumChange(another_model_def):
             CharFieldDefinition.objects.create(
                 model_def=self.model_def, name='f2', max_length=25,
                 null=True
             )
     another_model = AnotherModel.objects.get(pk=another_model.pk)
     self.assertIsNone(another_model.f2)
     another_model.f2 = 'Placebo'
     another_model.save()
예제 #5
0
 def test_mutable_model_base(self):
     another_model_def = ModelDefinition.objects.create(app_label='app',
                                                        object_name='AnotherModel')
     AnotherModel = another_model_def.model_class()
     CharFieldDefinition.objects.create(model_def=self.model_def,
                                        name='f1', max_length=25)
     base_definition = BaseDefinition(model_def=another_model_def)
     base_definition.base = self.model_def.model_class()
     base_definition.save()
     another_model = AnotherModel.objects.create(f1='Martinal')
     self.assertTrue(AnotherModel.objects.exists())
     CharFieldDefinition.objects.create(model_def=self.model_def,
                                        name='f2', max_length=25, null=True)
     another_model = AnotherModel.objects.get(pk=another_model.pk)
     self.assertIsNone(another_model.f2)
     another_model.f2 = 'Placebo'
     another_model.save()
예제 #6
0
 def test_bases_creation(self):
     mixin_base = BaseDefinition(base=Mixin)
     abstract_base = BaseDefinition(base=AbstractModel)
     abstract_concrete_base = BaseDefinition(
         base=AbstractConcreteModelSubclass)
     model_def = ModelDefinition.objects.create(
         app_label='mutant',
         object_name='OtherModel',
         bases=[mixin_base, abstract_base, abstract_concrete_base],
     )
     model = model_def.model_class()
     self.assertModelTablesColumnDoesntExists(model, 'id')
     self.assertModelTablesColumnExists(model, 'concretemodel_ptr_id')
     self.assertModelTablesColumnExists(model, 'abstract_model_field')
     self.assertModelTablesColumnDoesntExists(model, 'concrete_model_field')
     self.assertModelTablesColumnExists(
         model, 'abstract_concrete_model_subclass_field')
예제 #7
0
 def test_get_or_create(self):
     """
     Make sure bases and fields defaults are reaching the model initializer.
     """
     field = CharFieldDefinition(name='name', max_length=32)
     base = BaseDefinition(base=AbstractModel)
     ModelDefinition.objects.get_or_create(app_label='mutant',
                                           object_name='OtherModel',
                                           defaults={
                                               'bases': [base],
                                               'fields': [field]
                                           })
     self.assertIsNotNone(field.pk)
     self.assertIsNotNone(base.pk)
예제 #8
0
 def test_clean(self):
     bd = BaseDefinition(model_def=self.model_def)
     # Base must be a class
     bd.base = BaseDefinitionTest.test_clean
     self.assertRaisesMessage(
         ValidationError, _('Base must be a class.'), bd.clean
     )
     # Subclasses of MutableModel are valid bases
     bd.base = ModelDefinition.objects.create(
         app_label='mutant', object_name='AnotherModel'
     ).model_class()
     try:
         bd.clean()
     except ValidationError:
         self.fail('MutableModel subclasses are valid bases.')
     # But model definition can't be bases of themselves
     bd.base = self.model_def.model_class()
     self.assertRaisesMessage(
         ValidationError,
         _("A model definition can't be a base of itself."),
         bd.clean
     )
     # Mixin objets are valid bases
     bd.base = Mixin
     try:
         bd.clean()
     except ValidationError:
         self.fail('Mixin objets are valid bases.')
     # Abstract model subclasses are valid bases
     bd.base = AbstractModel
     try:
         bd.clean()
     except ValidationError:
         self.fail('Abstract Model are valid bases')
     # Proxy model are not valid bases
     bd.base = ProxyModel
     self.assertRaisesMessage(
         ValidationError, _("Base can't be a proxy model."), bd.clean
     )
예제 #9
0
 def test_clean(self):
     bd = BaseDefinition(model_def=self.model_def)
     # Base must be a class
     bd.base = BaseDefinitionTest.test_clean
     self.assertRaisesMessage(ValidationError, _('Base must be a class.'),
                              bd.clean)
     # Subclasses of MutableModel are valid bases
     bd.base = ModelDefinition.objects.create(
         app_label='mutant', object_name='AnotherModel').model_class()
     try:
         bd.clean()
     except ValidationError:
         self.fail('MutableModel subclasses are valid bases.')
     # But model definition can't be bases of themselves
     bd.base = self.model_def.model_class()
     self.assertRaisesMessage(
         ValidationError,
         _("A model definition can't be a base of itself."), bd.clean)
     # Mixin objets are valid bases
     bd.base = Mixin
     try:
         bd.clean()
     except ValidationError:
         self.fail('Mixin objets are valid bases.')
     # Abstract model subclasses are valid bases
     bd.base = AbstractModel
     try:
         bd.clean()
     except ValidationError:
         self.fail('Abstract Model are valid bases')
     # Proxy model are not valid bases
     bd.base = ProxyModel
     self.assertRaisesMessage(ValidationError,
                              _("Base can't be a proxy model."), bd.clean)