def setUp(self):
     """Sets up the TestModel."""
     # Clear the database.
     Version.objects.all().delete()
     TestModel.objects.all().delete()
     # Register the model.
     reversion.register(TestModel)

def reversion_register(model_class, fields=None, follow=(), format="xml", exclude_fields=None):
    """CMS interface to reversion api - helper function. Registers model for 
    reversion only if reversion is available.
    
    Auto excludes publisher fields.
     
    """
    
    if not 'reversion' in settings.INSTALLED_APPS:
        return
    
    if fields and exclude_fields:
        raise ValueError("Just one of fields, exclude_fields arguments can be passed.")
    
    opts = model_class._meta
    local_fields = opts.local_fields + opts.local_many_to_many
    if fields is None:
        fields = [field.name for field in local_fields]
    
    exclude_fields = exclude_fields or []
    
    if 'publisher' in settings.INSTALLED_APPS:
        from publisher import Publisher
        if issubclass(model_class, Publisher):
            # auto exclude publisher fields
            exclude_fields += ['publisher_is_draft', 'publisher_public', 'publisher_state']
    
    import reversion
    #if exclude_fields:
    fields = filter(lambda name: not name in exclude_fields, fields)        
     
    reversion.register(model_class, fields, follow, format)

 def setUp(self):
     super(FollowModelsTest, self).setUp()
     reversion.unregister(ReversionTestModel1)
     reversion.register(ReversionTestModel1, follow=("testfollowmodel_set",))
     reversion.register(TestFollowModel, follow=("test_model_1", "test_model_2s"))
     self.follow1 = TestFollowModel.objects.create(name="related instance1 version 1", test_model_1=self.test11)
     self.follow1.test_model_2s.add(self.test21, self.test22)

 def testFieldDictFieldFields(self):
     reversion.register(TestModel, fields=("name",))
     with reversion.create_revision():
         obj = TestModel.objects.create()
     self.assertEqual(Version.objects.get_for_object(obj).get().field_dict, {
         "name": "v1",
     })

 def check_registration(self, test_model):
     # Register the model and test.
     reversion.register(test_model)
     self.assertTrue(reversion.is_registered(test_model))
     self.assertRaises(RegistrationError, lambda: reversion.register(test_model))
     self.assertTrue(test_model in reversion.get_registered_models())
     self.assertTrue(isinstance(reversion.get_adapter(test_model), reversion.VersionAdapter))

 def __new__(cls, name, bases, attrs):
     if name in cls.plugins_with_extra_fields:
         ExtraFieldsMixin.media = media_property(ExtraFieldsMixin)
         bases = (ExtraFieldsMixin,) + bases
     if name in cls.plugins_with_sharables:
         SharableGlossaryMixin.media = media_property(SharableGlossaryMixin)
         bases = (SharableGlossaryMixin,) + bases
         attrs['fields'] += (('save_shared_glossary', 'save_as_identifier'), 'shared_glossary',)
         attrs['sharable_fields'] = cls.plugins_with_sharables[name]
         base_model = SharableCascadeElement
     else:
         base_model = CascadeElement
     if name in settings.CMSPLUGIN_CASCADE['plugins_with_extra_render_templates'].keys():
         RenderTemplateMixin.media = media_property(RenderTemplateMixin)
         bases = (RenderTemplateMixin,) + bases
     model_mixins = attrs.pop('model_mixins', ())
     if name == 'SegmentPlugin':
         # SegmentPlugin shall additionally inherit from configured mixin classes
         model_mixins += tuple(import_string(mc[0]) for mc in settings.CMSPLUGIN_CASCADE['segmentation_mixins'])
     module = attrs.get('__module__')
     app_label = attrs.get('app_label', module.split('.')[0])
     attrs['model'] = create_proxy_model(name, app_label, model_mixins, base_model, module=module)
     if is_installed('reversion'):
         import reversion
         if not reversion.is_registered(base_model):
             reversion.register(base_model)
     # handle ambiguous plugin names by appending a symbol
     if 'name' in attrs and settings.CMSPLUGIN_CASCADE['plugin_prefix']:
         attrs['name'] = mark_safe_lazy(string_concat(
             settings.CMSPLUGIN_CASCADE['plugin_prefix'], " ", attrs['name']))
     return super(CascadePluginBaseMetaclass, cls).__new__(cls, name, bases, attrs)

 def __new__(cls, name, bases, attrs):
     if name in cls.plugins_with_extrafields:
         ExtraFieldsMixin.media = media_property(ExtraFieldsMixin)
         bases = (ExtraFieldsMixin,) + bases
     if name in cls.plugins_with_sharables:
         SharableGlossaryMixin.media = media_property(SharableGlossaryMixin)
         bases = (SharableGlossaryMixin,) + bases
         attrs['fields'] += (('save_shared_glossary', 'save_as_identifier'), 'shared_glossary',)
         attrs['sharable_fields'] = cls.plugins_with_sharables[name]
         base_model = SharableCascadeElement
     else:
         base_model = CascadeElement
     if name in getattr(settings, 'CASCADE_PLUGINS_WITH_EXTRA_RENDER_TEMPLATES').keys():
         RenderTemplateMixin.media = media_property(RenderTemplateMixin)
         bases = (RenderTemplateMixin,) + bases
     model_mixins = attrs.pop('model_mixins', ())
     if name == 'SegmentPlugin':
         # SegmentPlugin shall additionally inherit from configured mixin classes
         model_mixins += tuple(import_string(mc[0]) for mc in settings.CASCADE_SEGMENTATION_MIXINS)
     attrs['model'] = create_proxy_model(name, model_mixins, base_model)
     if is_installed('reversion'):
         import reversion
         if not reversion.is_registered(base_model):
             reversion.register(base_model)
     return super(CascadePluginBaseMetaclass, cls).__new__(cls, name, bases, attrs)

def register_model(model, follow = None):
    if not reversion.is_registered(model) and settings.USE_REVERSION:
        #print "registering model with reversion: ", model
        if follow is None:
            reversion.register(model)
        else:
            reversion.register(model, follow = follow)

 def setUp(self):
     # Unregister all registered models.
     self.initial_registered_models = []
     for registered_model in reversion.get_registered_models():
         self.initial_registered_models.append((registered_model, reversion.get_adapter(registered_model).__class__))
         reversion.unregister(registered_model)
     # Register the test models.
     reversion.register(ReversionTestModel1)
     reversion.register(ReversionTestModel2)
     # Create some test data.
     self.test11 = ReversionTestModel1.objects.create(
         name = "model1 instance1 version1",
     )
     self.test12 = ReversionTestModel1.objects.create(
         name = "model1 instance2 version1",
     )
     self.test21 = ReversionTestModel2.objects.create(
         name = "model2 instance1 version1",
     )
     self.test22 = ReversionTestModel2.objects.create(
         name = "model2 instance2 version1",
     )
     self.user = User()
     if CUSTOM_USER_MODEL:
         setattr(self.user, User.USERNAME_FIELD, '1')
     else:
         self.user.username = "user1"

 def setUp(self):
     # Register the test models.
     reversion.register(ReversionTestModel1)
     reversion.register(ReversionTestModel2)
     # Create some test data.
     self.test11 = ReversionTestModel1.objects.create(
         name = "model1 instance1 version1",
     )
     self.test12 = ReversionTestModel1.objects.create(
         name = "model1 instance2 version1",
     )
     self.test21 = ReversionTestModel2.objects.create(
         name = "model2 instance1 version1",
     )
     self.test22 = ReversionTestModel2.objects.create(
         name = "model2 instance2 version1",
     )
     self.user = User.objects.create(
         username = "user1",
     )
     
     # Since we're creating a user, we need to bias our assertions
     # depending on whether or not it will create versions/revisions for
     # self.user.
     self.registered_instance_offset = 0
     if reversion.is_registered(User):
         self.registered_instance_offset = 1

def main():
    options = get_options()
    if not options.app:
        app = pick_app()
    else:
        app = get_app(options.app)
    if not options.model:
        model = pick_model(app)
    else:
        model = get_model(app, options.model)
    try:
        reversion.register(model)
    except:
        pass
    if options.num:
        object = get_object(model, options.num)
    elif options.search:
        object = search_object(model, options.search)
    else:
        object = pick_object(model)

    '''
    field = options.field
    if not field:
        field = pick_field(object)
    edit_object_old(object,field)
    '''
        
    edit_object(model, object)

 def tearDown(self):
     # Unregister the test models.
     reversion.unregister(ReversionTestModel1)
     reversion.unregister(ReversionTestModel2)
     reversion.unregister(ReversionTestModel3)
     # Delete the test models.
     ReversionTestModel1.objects.all().delete()
     ReversionTestModel2.objects.all().delete()
     ReversionTestModel3.objects.all().delete()
     User.objects.all().delete()
     del self.test11
     del self.test12
     del self.test21
     del self.test22
     del self.test31
     del self.test32
     del self.user
     # Delete the revisions index.
     Revision.objects.all().delete()
     # Unregister all remaining models.
     for registered_model in reversion.get_registered_models():
         reversion.unregister(registered_model)
     # Re-register initial registered models.
     for initial_model, adapter in self.initial_registered_models:
         reversion.register(initial_model, adapter_cls=adapter)
     del self.initial_registered_models

 def testCreateRevisionFollow(self):
     reversion.unregister(TestModel)
     reversion.register(TestModel, follow=("related_instances",))
     obj_2 = TestModel.objects.create()
     with reversion.create_revision():
         obj_1 = TestModel.objects.create()
         obj_1.related_instances.add(obj_2)
     self.assertSingleRevision((obj_1, obj_2))

 def testFieldDictFieldExclude(self):
     reversion.register(TestModel, exclude=("name",))
     with reversion.create_revision():
         obj = TestModel.objects.create()
     self.assertEqual(Version.objects.get_for_object(obj).get().field_dict, {
         "id": obj.pk,
         "related": [],
     })

 def testCanUnregisterModel(self):
     """Tests that a model can be unregistered."""
     reversion.unregister(TestModel)
     self.assertFalse(reversion.is_registered(TestModel))
     # Check that duplicate unregistration is disallowed.
     self.assertRaises(RegistrationError, lambda: reversion.unregister(TestModel))
     # Re-register the model.
     reversion.register(TestModel)

 def setUp(self):
     """Sets up the ReversionTestModel."""
     # Clear the database.
     Revision.objects.all().delete()
     ReversionTestModel.objects.all().delete()
     TestRelatedModel.objects.all().delete()
     # Register the models.
     reversion.register(ReversionTestModel, follow=("testrelatedmodel_set",))
     reversion.register(TestRelatedModel, follow=("relation",))

 def register_with_reversion(cls):
     if not reversion:
         raise EnvironmentError("django-reversion is not installed")
     follow = []
     for content_type_model in cls._feincms_content_types:
         related_manager = "%s_set" % content_type_model.__name__.lower()
         follow.append(related_manager)
         reversion.register(content_type_model)
     reversion.register(cls, follow=follow)

    def setUp(self):
        super(ProxyModelApiTest, self).setUp()
        reversion.register(ReversionTestModel1Proxy)
        self.concrete = self.test11
        self.proxy = ReversionTestModel1Proxy.objects.get(pk=self.concrete.pk)

        with reversion.create_revision():
            self.proxy.name = "proxy model"
            self.proxy.save()

 def setUp(self):
     """Sets up a versioned site model to test."""
     reversion.register(Site)
     with reversion.revision:
         site = Site.objects.create(name="site", domain="www.site-rev-1.com")
     with reversion.revision:
         site.domain = "www.site-rev-2.com"
         site.save()
     self.site = site

 def setUp(self):
     # Register the test models.
     reversion.register(ReversionTestModel1)
     reversion.register(ReversionTestModel2)
     # Create some test data.
     self.test11 = ReversionTestModel1.objects.create(name="model1 instance1 version1")
     self.test12 = ReversionTestModel1.objects.create(name="model1 instance2 version1")
     self.test21 = ReversionTestModel2.objects.create(name="model2 instance1 version1")
     self.test22 = ReversionTestModel2.objects.create(name="model2 instance2 version1")
     self.user = User.objects.create(username="user1")