def test_identical(self):
"""
The diff between two identical models, or a model and itself should be
None.
"""
vals = {'a': 'Lorem', 'b': 'Ipsum',
'c': datetime.datetime.now(), 'd': 123}
m1 = Diff_M1.objects.create(**vals)
m2 = Diff_M1.objects.create(**vals)
d = diff.diff(m1, m1).as_dict()
self.assertEqual(d, None)
d = diff.diff(m1, m2).as_dict()
self.assertEqual(d, None)
def _async_cache_post_edit(instance, created=False, deleted=False, raw=False):
from pages.models import Page
from maps.models import MapData
from tags.models import PageTagSet
from links.models import Link, IncludedPage, IncludedTagList
from tags.cache import django_invalidate_tag_view, varnish_invalidate_tag_view
from versionutils.diff import diff
if isinstance(instance, Page):
# First, let's clear out the Varnish cache for this page
varnish_invalidate_page(instance)
# Then we clear the cache for pages that depend on this page
if created or deleted:
# Clear the cache for pages that link to this page, as the
# link dashed-underline-status has changed.
# First, make sure and get all the page links, whether or not the
# destination page exists:
links_to_here = set([l.source for l in instance.links_to_here.all()])
other_links = Link.objects.filter(destination_name__iexact=instance.slug)
other_links = [Page(name=l.source.name, slug=l.source.slug, region=instance.region) for l in other_links]
links_to_here = set.union(links_to_here, other_links)
for p in links_to_here:
varnish_invalidate_page(p)
django_invalidate_page(p)
# Clear out the cache for pages that include this page
for p in instance.pages_that_include_this.all():
varnish_invalidate_page(p.source)
django_invalidate_page(p.source)
elif isinstance(instance, MapData):
varnish_invalidate_page(instance.page)
# Only ever deal with PageTagSet if deleted (otherwise we deal with m2m_changed)
elif isinstance(instance, PageTagSet) and deleted:
varnish_invalidate_page(instance.page)
django_invalidate_page(instance.page)
if instance.versions.all().count() == 1:
changed = [t.slug for t in instance.tags.all()]
else:
# Most recent two versions
v2, v1 = instance.versions.all()[:2]
items = diff(v1, v2).get_diff()['tags'].get_diff()
changed = [t.slug for t in set.union(items['added'], items['deleted'])]
# Clear tag list views
for slug in changed:
invalidate_region_tag_views(slug, instance.region)
invalidate_global_tag_view(slug)
# Clear out the pages that include a 'list of tagged pages' of the deleted
# tags:
slugs_before_delete = [t.slug for t in instance.versions.all()[1].tags.all()]
for tl in IncludedTagList.objects.filter(included_tag__slug__in=slugs_before_delete):
varnish_invalidate_page(tl.source)
django_invalidate_page(tl.source)
def _async_pagetagset_m2m_changed(instance):
from links.models import IncludedTagList
from versionutils.diff import diff
varnish_invalidate_page(instance.page)
django_invalidate_page(instance.page)
# This seems roundabout because it is. We clear() out the tag set each time
# the PageTagSet is changed[1], so we have to check what's changed in this
# roundabout manner.
#
# 1. Not sure why, but may be worth looking into.
if instance.versions.all().count() == 1:
changed = [t.slug for t in instance.tags.all()]
else:
# Most recent two versions
v2, v1 = instance.versions.all()[:2]
items = diff(v1, v2).get_diff()['tags'].get_diff()
changed = [t.slug for t in set.union(items['added'], items['deleted'])]
# Clear tag list views
for slug in changed:
invalidate_region_tag_views(slug, instance.region)
invalidate_global_tag_view(slug)
# Clear caches of pages that include these tags as "list of tagged pages"
for tl in IncludedTagList.objects.filter(included_tag__slug__in=changed):
varnish_invalidate_page(tl.source)
django_invalidate_page(tl.source)
def test_property_diff(self):
"""
The "fields" included in a diff don't have to be fields at all and can
be properties, for example, as long as a custom ModelDiff is registered
which dictates what FieldDiff to use for the "field".
"""
diff.register(FakeFieldModel, FakeFieldModelDiff)
a = FakeFieldModel(a='abc')
b = FakeFieldModel(a='def')
d = diff.diff(a, b)
self.assertTrue(isinstance(d['b'], (TextFieldDiff,)))
def test_foreign_key(self):
"""
The diff between two ForeignKey fields should be the same as the diff
between the two objects referenced by the fields
"""
vals = {'a': 'Lorem', 'b': 'Ipsum',
'c': datetime.datetime.now(), 'd': 123}
m1 = Diff_M1.objects.create(**vals)
vals = {'a': 'Dolor', 'b': 'Ipsum',
'c': datetime.datetime.now(), 'd': 123}
m2 = Diff_M1.objects.create(**vals)
m3 = Diff_M4ForeignKey.objects.create(a=m1)
m4 = Diff_M4ForeignKey.objects.create(a=m2)
d1 = diff.diff(m3, m4).as_dict()
self.assertTrue(d1['a'])
d2 = diff.diff(m1, m2).as_dict()
self.assertEqual(d1['a'], d2)
def test_nearly_identical(self):
"""
The diff between models should consist of only the fields that are
different.
"""
vals = {'a': 'Lorem', 'b': 'Ipsum',
'c': datetime.datetime.now(), 'd': 123}
m1 = Diff_M1.objects.create(**vals)
vals['a'] = 'Ipsum'
m2 = Diff_M1.objects.create(**vals)
d = diff.diff(m1, m2).as_dict()
self.assertTrue(len(d) == 1)
def test_foreign_key_identical(self):
"""
The diff between two ForeignKey fields to the same object should be
None.
"""
vals = {'a': 'Lorem', 'b': 'Ipsum',
'c': datetime.datetime.now(), 'd': 123}
m1 = Diff_M1.objects.create(**vals)
m3 = Diff_M4ForeignKey.objects.create(a=m1)
m4 = Diff_M4ForeignKey.objects.create(a=m1)
d = diff.diff(m3, m4).as_dict()
self.assertTrue(d is None)
def get_context_data(self, **kwargs):
context = super(PageCompareView, self).get_context_data(**kwargs)
context['page_diff'] = diff.diff(context['old'], context['new'])
return context
def get_context_data(self, **kwargs):
context = super(PageCompareView, self).get_context_data(**kwargs)
context["page_diff"] = diff.diff(context["old"], context["new"])
return context
def get_context_data(self, **kwargs):
context = super(PageCompareView, self).get_context_data(**kwargs)
context['page_diff'] = diff.diff(context['old'], context['new'])
return context
