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