def test_initial_state(self):
self.assertTrue(reversion.is_registered(Factory))
self.assertTrue(reversion.is_registered(Car))
self.assertEqual(Revision.objects.all().count(), 3)
self.assertEqual(len(self.version_ids), 3)
self.assertEqual(Version.objects.all().count(), 10)
def testInlineAdmin(self):
self.assertTrue(is_registered(InlineTestParentModel))
# make sure model is following the child FK
self.assertTrue('children' in get_adapter(InlineTestParentModel).follow)
self.createInlineObjects()
# unregister model
unregister(InlineTestParentModel)
self.assertFalse(is_registered(InlineTestParentModel))
# re-register without following
register(InlineTestParentModel)
self.assertTrue(is_registered(InlineTestParentModel))
# make sure model is NOT following the child FK
self.assertFalse('children' in get_adapter(InlineTestParentModel).follow)
self.createInlineObjects()
def testDecoratorArgs(self):
# Test a decorator with arguments
@register(format='yaml')
class DecoratorArgsModel(models.Model):
pass
self.assertTrue(is_registered(DecoratorArgsModel))
def testInlineAdmin(self):
self.assertTrue(is_registered(InlineTestParentModel))
# make sure model is following the child FK
self.assertTrue(
'children' in get_adapter(InlineTestParentModel).follow)
self.createInlineObjects()
# unregister model
unregister(InlineTestParentModel)
self.assertFalse(is_registered(InlineTestParentModel))
# re-register without following
register(InlineTestParentModel)
self.assertTrue(is_registered(InlineTestParentModel))
# make sure model is NOT following the child FK
self.assertFalse(
'children' in get_adapter(InlineTestParentModel).follow)
self.createInlineObjects()
def check_deregistration(self, test_model):
# Unregister the model and text.
unregister(test_model)
self.assertFalse(is_registered(test_model))
self.assertRaises(RegistrationError, lambda: unregister(test_model))
self.assertTrue(test_model not in get_registered_models())
self.assertRaises(RegistrationError, lambda: isinstance(get_adapter(test_model)))
def check_registration(self, test_model):
# Register the model and test.
register(test_model)
self.assertTrue(is_registered(test_model))
self.assertRaises(RegistrationError, lambda: register(test_model))
self.assertTrue(test_model in get_registered_models())
self.assertTrue(isinstance(get_adapter(test_model), VersionAdapter))
def check_registration(self, test_model):
# Register the model and test.
register(test_model)
self.assertTrue(is_registered(test_model))
self.assertRaises(RegistrationError, lambda: register(test_model))
self.assertTrue(test_model in get_registered_models())
self.assertTrue(isinstance(get_adapter(test_model), VersionAdapter))
def _register_model(admin, model):
if not hasattr(admin, "reversion_format"):
admin.reversion_format = "json"
if not is_registered(model):
inline_fields = []
for inline in getattr(admin, "inlines", []):
inline_model = inline.model
if getattr(inline, "generic_inline", False):
ct_field = getattr(inline, "ct_field", "content_type")
ct_fk_field = getattr(inline, "ct_fk_field", "object_id")
for field in model._meta.many_to_many:
if (isinstance(field, GenericRelation)
and field.rel.to == inline_model
and field.object_id_field_name == ct_fk_field
and field.content_type_field_name == ct_field):
inline_fields.append(field.name)
_autoregister(admin, inline_model)
else:
fk_name = getattr(inline, "fk_name", None)
if not fk_name:
for field in inline_model._meta.fields:
if isinstance(field,
(models.ForeignKey,
models.OneToOneField)) and issubclass(
model, field.rel.to):
fk_name = field.name
_autoregister(admin, inline_model, follow=[fk_name])
if not inline_model._meta.get_field(fk_name).rel.is_hidden():
accessor = inline_model._meta.get_field(
fk_name).remote_field.get_accessor_name()
inline_fields.append(accessor)
_autoregister(admin, model, inline_fields)
def testDecorator(self):
# Test the use of register as a decorator
@register
class DecoratorModel(models.Model):
pass
self.assertTrue(is_registered(DecoratorModel))
def get_models(self, options):
# Load admin classes.
if "django.contrib.admin" in settings.INSTALLED_APPS:
admin.autodiscover()
# Get options.
app_labels = options["app_label"]
# Parse model classes.
if len(app_labels) == 0:
selected_models = apps.get_models()
else:
selected_models = set()
for label in app_labels:
if "." in label:
# This is an app.Model specifier.
try:
model = apps.get_model(label)
except LookupError:
raise CommandError("Unknown model: {}".format(label))
selected_models.add(model)
else:
# This is just an app - no model qualifier.
app_label = label
try:
app = apps.get_app_config(app_label)
except LookupError:
raise CommandError("Unknown app: {}".format(app_label))
selected_models.update(app.get_models())
for model in selected_models:
if is_registered(model):
yield model
def _register_model(admin, model):
if not hasattr(admin, 'reversion_format'):
admin.reversion_format = 'json'
if not is_registered(model):
inline_fields = []
for inline in getattr(admin, 'inlines', []):
inline_model = inline.model
if getattr(inline, 'generic_inline', False):
ct_field = getattr(inline, 'ct_field', 'content_type')
ct_fk_field = getattr(inline, 'ct_fk_field', 'object_id')
for field in model._meta.many_to_many:
if isinstance(field, GenericRelation) \
and field.rel.to == inline_model \
and field.object_id_field_name == ct_fk_field \
and field.content_type_field_name == ct_field:
inline_fields.append(field.name)
_autoregister(admin, inline_model)
else:
fk_name = getattr(inline, 'fk_name', None)
if not fk_name:
for field in inline_model._meta.fields:
if isinstance(field, (models.ForeignKey, models.OneToOneField)) and issubclass(model, field.rel.to):
fk_name = field.name
_autoregister(admin, inline_model, follow=[fk_name])
if not inline_model._meta.get_field(fk_name).rel.is_hidden():
accessor = inline_model._meta.get_field(fk_name).remote_field.get_accessor_name()
inline_fields.append(accessor)
_autoregister(admin, model, inline_fields)
def _register_model(admin, model):
if not hasattr(admin, 'reversion_format'):
admin.reversion_format = 'json'
if not is_registered(model):
inline_fields = []
for inline in getattr(admin, 'inlines', []):
inline_model = inline.model
if getattr(inline, 'generic_inline', False):
ct_field = getattr(inline, 'ct_field', 'content_type')
ct_fk_field = getattr(inline, 'ct_fk_field', 'object_id')
for field in model._meta.many_to_many:
if isinstance(field, GenericRelation) \
and field.rel.to == inline_model \
and field.object_id_field_name == ct_fk_field \
and field.content_type_field_name == ct_field:
inline_fields.append(field.name)
_autoregister(admin, inline_model)
else:
fk_name = getattr(inline, 'fk_name', None)
if not fk_name:
for field in inline_model._meta.fields:
if isinstance(field,
(models.ForeignKey,
models.OneToOneField)) and issubclass(
model, field.remote_field.model):
fk_name = field.name
_autoregister(admin, inline_model, follow=[fk_name])
if not inline_model._meta.get_field(
fk_name).remote_field.is_hidden():
accessor = inline_model._meta.get_field(
fk_name).remote_field.get_accessor_name()
inline_fields.append(accessor)
_autoregister(admin, model, inline_fields)
def get_models(self, options):
# Load admin classes.
admin.autodiscover()
# Get options.
app_labels = options["app_label"]
# Parse model classes.
if len(app_labels) == 0:
selected_models = apps.get_models()
else:
selected_models = set()
for label in app_labels:
if "." in label:
# This is an app.Model specifier.
try:
model = apps.get_model(label)
except LookupError:
raise CommandError("Unknown model: {}".format(label))
selected_models.add(model)
else:
# This is just an app - no model qualifier.
app_label = label
try:
app = apps.get_app_config(app_label)
except LookupError:
raise CommandError("Unknown app: {}".format(app_label))
selected_models.update(app.get_models())
for model in selected_models:
if is_registered(model):
yield model
def _reversion_autoregister(self, model, follow):
if not is_registered(model):
for parent_model, field in model._meta.concrete_model._meta.parents.items(
):
follow += (field.name, )
self._reversion_autoregister(parent_model, ())
self.reversion_register(model, follow=follow)
def check_deregistration(self, test_model):
# Unregister the model and text.
unregister(test_model)
self.assertFalse(is_registered(test_model))
self.assertRaises(RegistrationError, lambda: unregister(test_model))
self.assertTrue(test_model not in get_registered_models())
self.assertRaises(RegistrationError,
lambda: isinstance(get_adapter(test_model)))
def testEagerRegistration(self):
# Register the model and test.
register(ReversionTestModel3, eager_signals=[pre_delete])
self.assertTrue(is_registered(ReversionTestModel3))
self.assertRaises(RegistrationError, lambda: register(ReversionTestModel3, eager_signals=[pre_delete]))
self.assertTrue(ReversionTestModel3 in get_registered_models())
self.assertTrue(isinstance(get_adapter(ReversionTestModel3), VersionAdapter))
self.assertEqual([], default_revision_manager._signals[ReversionTestModel3])
self.assertEqual([pre_delete], default_revision_manager._eager_signals[ReversionTestModel3])
# Unregister the model and text.
unregister(ReversionTestModel3)
self.assertFalse(is_registered(ReversionTestModel3))
self.assertRaises(RegistrationError, lambda: unregister(ReversionTestModel3))
self.assertTrue(ReversionTestModel3 not in get_registered_models())
self.assertRaises(RegistrationError, lambda: isinstance(get_adapter(ReversionTestModel3)))
self.assertFalse(ReversionTestModel3 in default_revision_manager._signals)
self.assertFalse(ReversionTestModel3 in default_revision_manager._eager_signals)
def register_processes():
try:
from reversion import revisions
except ImportError:
pass
else:
for model in utils.get_processes():
if not revisions.is_registered(model):
revisions.register(model)
def register_workflows():
try:
from reversion import revisions
except ImportError:
pass
else:
for workflow in utils.get_workflows():
if not revisions.is_registered(workflow):
revisions.register(workflow)
def test_initial_state(self):
self.assertTrue(reversion.is_registered(VariantModel))
self.assertEqual(VariantModel.objects.count(), 1)
count = len(self.test_data) + 1 # incl. initial
self.assertEqual(reversion.get_for_object(self.item).count(), count)
self.assertEqual(Revision.objects.all().count(), count)
self.assertEqual(len(self.version_ids), count)
def _autoregister(admin, model, follow=None):
"""Registers a model with reversion, if required."""
if model._meta.proxy:
raise RegistrationError("Proxy models cannot be used with django-reversion, register the parent class instead")
if not is_registered(model):
follow = follow or []
for parent_cls, field in model._meta.parents.items():
follow.append(field.name)
_autoregister(admin, parent_cls)
register(model, follow=follow, format=admin.reversion_format)
def _autoregister(admin, model, follow=None):
"""Registers a model with reversion, if required."""
if model._meta.proxy:
raise RegistrationError("Proxy models cannot be used with django-reversion, register the parent class instead")
if not is_registered(model):
follow = follow or []
for parent_cls, field in model._meta.parents.items():
follow.append(field.name)
_autoregister(admin, parent_cls)
register(model, follow=follow, format=admin.reversion_format)
def test_initial_state(self):
self.assertTrue(reversion.is_registered(SimpleModel))
self.assertEqual(SimpleModel.objects.count(), 2)
self.assertEqual(SimpleModel.objects.all()[0].text, "version two")
self.assertEqual(reversion.get_for_object(self.item1).count(), 2)
self.assertEqual(list(self.version_ids1), [2, 1])
self.assertEqual(list(self.version_ids1), [2, 1])
self.assertEqual(list(self.version_ids2), [7, 6, 5, 4, 3])
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
# Automatically register models if required.
if not is_registered(self.model):
inline_fields = ()
for inline in self.inlines:
inline_model, follow_field = self._reversion_introspect_inline_admin(inline)
if inline_model:
self._reversion_autoregister(inline_model, ())
if follow_field:
inline_fields += (follow_field,)
self._reversion_autoregister(self.model, inline_fields)
def __init__(self, *args, **kwargs):
super(VersionAdmin, self).__init__(*args, **kwargs)
# Automatically register models if required.
if not is_registered(self.model):
inline_fields = ()
for inline in self.inlines:
inline_model, follow_field = self._reversion_introspect_inline_admin(inline)
if inline_model:
self._reversion_autoregister(inline_model, ())
if follow_field:
inline_fields += (follow_field,)
self._reversion_autoregister(self.model, inline_fields)
def test_initial_state(self):
self.assertTrue(reversion.is_registered(SimpleModel))
self.assertEqual(SimpleModel.objects.count(), 2)
self.assertEqual(SimpleModel.objects.all()[0].text, "version two")
self.assertEqual(reversion.get_for_object(self.item1).count(), 2)
self.assertEqual(reversion.get_for_object(self.item2).count(), 5)
self.assertEqual(Revision.objects.all().count(), 7)
self.assertEqual(Version.objects.all().count(), 7)
# query.ValuesListQuerySet() -> list():
self.assertEqual(list(self.version_ids1), [2, 1])
self.assertEqual(list(self.version_ids2), [7, 6, 5, 4, 3])
def testInlineProxyAdmin(self):
self.assertTrue(is_registered(InlineTestParentModelProxy))
# make sure model is following the child FK
self.assertTrue('children' in get_adapter(InlineTestParentModelProxy).follow)
parent_pk = self.createInlineProxyObjects()
# Check that the current version includes the inlines.
versions = list(get_for_object_reference(InlineTestParentModelProxy, parent_pk))
response = self.client.get(reverse("admin:test_reversion_inlinetestparentmodelproxy_revision", args=(parent_pk, versions[0].pk)))
self.assertContains(response, "parent version2") # Check parent model.
self.assertContains(response, "non-generic child version 1") # Check inline child model.
# Check that the first version does not include the inlines.
response = self.client.get(reverse("admin:test_reversion_inlinetestparentmodelproxy_revision", args=(parent_pk, versions[1].pk)))
self.assertContains(response, "parent version1") # Check parent model.
self.assertNotContains(response, "non-generic child version 1") # Check inline child model.
def register_concept_reversions(concept_class, *args, **kwargs):
from reversion import revisions as reversion
follows = kwargs.get('reversion', {}).get('follow', [])
# Register the concept with reversion
reversion.register(concept_class,
follow=follows,
format='aristotle_mdr_json')
follow_classes = kwargs.get('reversion', {}).get('follow_classes', [])
for cls in follow_classes:
reversion.register(cls)
if reversion.is_registered(_concept):
reversion.unregister(_concept)
def __init__(self, *args, **kwargs):
super(VersionAdmin, self).__init__(*args, **kwargs)
# Check that database transactions are supported.
if not connection.features.uses_savepoints:
raise ImproperlyConfigured("Cannot use VersionAdmin with a database that does not support savepoints.")
# Automatically register models if required.
if not is_registered(self.model):
inline_fields = ()
for inline in self.inlines:
inline_model, follow_field = self._reversion_introspect_inline_admin(inline)
if inline_model:
self._reversion_autoregister(inline_model, ())
if follow_field:
inline_fields += (follow_field,)
self._reversion_autoregister(self.model, inline_fields)
def log_object_removal(sender, instance, **kwargs):
"""Custom post-delete hook.
We want to know who was responsible for an object deletion.
"""
from reversion.models import Version
if not reversion.is_registered(sender):
return
del_list = reversion.get_deleted(sender)
try:
version = del_list.get(object_id=instance.id)
except Version.DoesNotExist:
return
logger = logging.getLogger("modoboa.admin")
msg = _("%(object)s '%(name)s' %(action)s by user %(user)s") % {
"object": smart_text(version.content_type).capitalize(),
"name": version.object_repr, "action": _("deleted"),
"user": get_request().user.username
}
logger.critical(msg)
def log_object_removal(sender, instance, **kwargs):
"""Custom post-delete hook.
We want to know who was responsible for an object deletion.
"""
from reversion.models import Version
from modoboa.lib.signals import get_request
if not reversion.is_registered(sender):
return
del_list = reversion.get_deleted(sender)
try:
version = del_list.get(object_id=instance.id)
except Version.DoesNotExist:
return
logger = logging.getLogger("modoboa.admin")
msg = _("%(object)s '%(name)s' %(action)s by user %(user)s") % {
"object": unicode(version.content_type).capitalize(),
"name": version.object_repr, "action": _("deleted"),
"user": get_request().user.username
}
logger.critical(msg)
def log_object_removal(sender, instance, **kwargs):
"""Custom post-delete hook.
We want to know who was responsible for an object deletion.
"""
if not reversion.is_registered(sender):
return
del_list = Version.objects.get_deleted(sender)
try:
version = del_list.get(object_id=instance.id)
except Version.DoesNotExist:
return
logger = logging.getLogger("modoboa.admin")
msg = _("%(object)s '%(name)s' %(action)s by ") % {
"object": smart_text(version.content_type).capitalize(),
"name": version.object_repr, "action": _("deleted")
}
request = get_request()
if request:
msg += _("user {}").format(request.user.username)
else:
msg += _("management command")
logger.critical(msg)
def log_object_removal(sender, instance, **kwargs):
"""Custom post-delete hook.
We want to know who was responsible for an object deletion.
"""
if not reversion.is_registered(sender):
return
del_list = Version.objects.get_deleted(sender)
try:
version = del_list.get(object_id=instance.id)
except Version.DoesNotExist:
return
logger = logging.getLogger("modoboa.admin")
msg = _("%(object)s '%(name)s' %(action)s by ") % {
"object": smart_text(version.content_type).capitalize(),
"name": version.object_repr,
"action": _("deleted")
}
request = get_request()
if request:
msg += _("user {}").format(request.user.username)
else:
msg += _("management command")
logger.critical(msg)
def testInlineProxyAdmin(self):
self.assertTrue(is_registered(InlineTestParentModelProxy))
# make sure model is following the child FK
self.assertTrue(
'children' in get_adapter(InlineTestParentModelProxy).follow)
parent_pk = self.createInlineProxyObjects()
# Check that the current version includes the inlines.
versions = list(
get_for_object_reference(InlineTestParentModelProxy, parent_pk))
response = self.client.get(
reverse("admin:test_reversion_inlinetestparentmodelproxy_revision",
args=(parent_pk, versions[0].pk)))
self.assertContains(response, "parent version2") # Check parent model.
self.assertContains(
response,
"non-generic child version 1") # Check inline child model.
# Check that the first version does not include the inlines.
response = self.client.get(
reverse("admin:test_reversion_inlinetestparentmodelproxy_revision",
args=(parent_pk, versions[1].pk)))
self.assertContains(response, "parent version1") # Check parent model.
self.assertNotContains(
response,
"non-generic child version 1") # Check inline child model.
def is_registered(*args, **kwargs):
return revisions.is_registered(*args, **kwargs)
def testAutoRegisterWorks(self):
self.assertTrue(is_registered(ChildTestAdminModel))
self.assertTrue(is_registered(ParentTestAdminModel))
self.assertTrue(is_registered(InlineTestChildModel))
self.assertTrue(is_registered(InlineTestChildGenericModel))
self.assertTrue(is_registered(InlineTestParentModel))
def testDecoratorArgs(self):
# Test a decorator with arguments
@register(format='yaml')
class DecoratorArgsModel(models.Model):
pass
self.assertTrue(is_registered(DecoratorArgsModel))
def is_registered(*args, **kwargs):
return revisions.is_registered(*args, **kwargs)
def _reversion_autoregister(self, model, follow):
if not is_registered(model):
for parent_model, field in model._meta.concrete_model._meta.parents.items():
follow += (field.name,)
self._reversion_autoregister(parent_model, ())
self.reversion_register(model, follow=follow)
def testAutoRegisterWorks(self):
self.assertTrue(is_registered(ChildTestAdminModel))
self.assertTrue(is_registered(ParentTestAdminModel))
self.assertTrue(is_registered(InlineTestChildModel))
self.assertTrue(is_registered(InlineTestChildGenericModel))
self.assertTrue(is_registered(InlineTestParentModel))
def can_etag(self, obj):
return hasattr(obj, "_meta") and revisions.is_registered(type(obj))
def testDecorator(self):
# Test the use of register as a decorator
@register
class DecoratorModel(models.Model):
pass
self.assertTrue(is_registered(DecoratorModel))
