def test_clone_tree_doesnt_mutate_tree(self): make_a_nice_tree(self.root_node) self.root_node.prefetch_tree() before = self.root_node.depth_first_order() self.root_node.clone_tree() after = self.root_node.depth_first_order() self.assertEqual(before, after)
def test_delete_deep_tree_and_multiple_commits(self): make_a_nice_tree(self.root_node) tracker = VersionTracker.objects.create(working_copy=self.root_node) tracker.commit() tracker.commit() tracker.delete() self.assertEqual(RawTextWidget.objects.count(), 0) self.assertEqual(VersionTracker.objects.filter(pk=tracker.pk).count(), 0)
def test_delete_deep_tree_and_multiple_commits(self): make_a_nice_tree(self.root_node) tracker = VersionTracker.objects.create(working_copy=self.root_node) tracker.commit() tracker.commit() tracker.delete() self.assertEqual(RawTextWidget.objects.count(), 0) self.assertEqual( VersionTracker.objects.filter(pk=tracker.pk).count(), 0)
def test_frozen_reposition(self): left, right = make_a_nice_tree(self.root_node) for node in self.root_node.depth_first_order(): node.is_frozen = True node.save() left, right = Node.objects.get(pk=self.root_node.pk).get_children() before_ids = [i.id for i in self.root_node.depth_first_order()] with self.assertRaises(InvalidOperation): left.content.reposition(self.widgy_site, parent=right.content) with self.assertRaises(InvalidOperation): right.content.reposition(self.widgy_site, right=left.content) with self.assertRaises(InvalidOperation): right.content.add_child(self.widgy_site, RawTextWidget, text='asdf') with self.assertRaises(InvalidOperation): right.content.get_children()[0].add_sibling(self.widgy_site, RawTextWidget, text='asdf') root_node = Node.objects.get(pk=self.root_node.id) self.assertEqual([i.id for i in root_node.depth_first_order()], before_ids)
def test_available_children(self): left, right = make_a_nice_tree(self.root_node, self.widgy_site) subbucket = list(left.get_children())[-1] resp = self.get(self.root_node.to_json(self.widgy_site)['available_children_url']) self.assertEqual(resp.status_code, 200) data = json.loads(resp.content) def select(cls_name): possible_parent_urls = [] for node_url, child_classes in data.iteritems(): for i in child_classes: if i['__class__'] == cls_name: possible_parent_urls.append(node_url) return possible_parent_urls bucket_parents = select('core_tests.bucket') immovablebucket_parents = select('core_tests.immovablebucket') pickybucket_parents = select('core_tests.pickybucket') rawtext_parents = select('core_tests.rawtextwidget') cantgoanywhere_parents = select('core_tests.cantgoanywherewidget') def lists_equal(instances, urls): urls = sorted(map(str, urls)) instance_urls = sorted(str(i.get_api_url(self.widgy_site)) for i in instances) self.assertEqual(instance_urls, urls) lists_equal([], cantgoanywhere_parents) lists_equal([right, left, subbucket, self.root_node], bucket_parents) lists_equal([right, left, subbucket, self.root_node], immovablebucket_parents) lists_equal([right, left, subbucket, self.root_node], pickybucket_parents) lists_equal([right, left, subbucket], rawtext_parents)
def test_reposition(self): left, right = make_a_nice_tree(self.root_node) with self.assertRaises(InvalidTreeMovement): self.root_node.content.reposition(self.widgy_site, parent=left.content) with self.assertRaises(InvalidTreeMovement): left.content.reposition(self.widgy_site, right=self.root_node.content) # swap left and right right.content.reposition(self.widgy_site, right=left.content) new_left, new_right = self.root_node.get_children() self.assertEqual(right, new_left) self.assertEqual(left, new_right) raw_text = new_right.get_first_child() with self.assertRaises(ChildWasRejected): raw_text.content.reposition(self.widgy_site, parent=self.root_node.content, right=new_left.content) subbucket = list(new_right.get_children())[-1] subbucket.content.reposition(self.widgy_site, parent=self.root_node.content, right=new_left.content) new_subbucket, new_left, new_right = self.root_node.get_children() self.assertEqual(new_subbucket, subbucket)
def test_possible_parents(self): def order_ignorant_equals(a, b): self.assertEqual(sorted(a), sorted(b)) left, right = make_a_nice_tree(self.root_node, self.widgy_site) resp = self.get(self.root_node.to_json(self.widgy_site)['possible_parents_url']) possible_parents = json.loads(resp.content) order_ignorant_equals([], possible_parents) resp = self.get(left.to_json(self.widgy_site)['possible_parents_url']) possible_parents = json.loads(resp.content) order_ignorant_equals([right.get_api_url(self.widgy_site), self.root_node.get_api_url(self.widgy_site)], possible_parents) resp = self.get(right.to_json(self.widgy_site)['possible_parents_url']) possible_parents = json.loads(resp.content) order_ignorant_equals([left.get_api_url(self.widgy_site), self.root_node.get_api_url(self.widgy_site), left.content.get_children()[2].node.get_api_url(self.widgy_site)], possible_parents) resp = self.get( left.content.get_children()[0].node.to_json(self.widgy_site)['possible_parents_url']) possible_parents = json.loads(resp.content) order_ignorant_equals([left.get_api_url(self.widgy_site), right.get_api_url(self.widgy_site), left.content.get_children()[2].node.get_api_url(self.widgy_site)], possible_parents)
def test_optimized_compatibility_fetching(self): left, right = make_a_nice_tree(self.root_node, self.widgy_site) # loads . dumps == normalize the types to what json uses, list vs tuple left_json = json.loads(json.dumps(left.to_json(self.widgy_site))) left_url = left_json['url'] root_json = json.loads(json.dumps(self.root_node.to_json(self.widgy_site))) root_url = root_json['url'] def doit(method, *args): url = '{0}?include_compatibility_for={1}'.format(left_url, root_url) ret = json.loads(getattr(self, method)(url, *args).content) compatibility = json.loads(self.get(root_json['available_children_url']).content) if method == 'get': self.assertEqual(left_json, ret['node']) self.assertEqual(compatibility, ret['compatibility']) doit('get') doit('post', { '__class__': 'core_tests.rawtextwidget', 'parent_id': left_url, 'right_id': None, }) doit('put', left_json) doit('delete')
def test_node_templates_view(self): left, right = make_a_nice_tree(self.root_node, self.widgy_site) r = self.get(left.content.to_json(self.widgy_site)['template_url']) # not sure there's much else we can test here self.assertIn('<form', json.loads(r.content)['edit_template'])
def test_has_changes(self): left, right = make_a_nice_tree(self.root_node) vt = VersionTracker.objects.create(working_copy=self.root_node) self.assertTrue(vt.has_changes()) vt.commit() self.assertFalse(vt.has_changes()) left.content.add_child(self.widgy_site, RawTextWidget, text='foo') vt = VersionTracker.objects.get(pk=vt.pk) self.assertTrue(vt.has_changes())
def test_reposition_immovable(self): left, right = make_a_nice_tree(self.root_node, self.widgy_site) bucket = left.content.add_child(self.widgy_site, ImmovableBucket) resp = self.put(bucket.node.get_api_url(self.widgy_site), { 'right_id': None, 'parent_id': right.get_api_url(self.widgy_site), }) self.assertEquals(resp.status_code, 409)
def test_clone_tree(self): left, right = make_a_nice_tree(self.root_node) new_tree = self.root_node.clone_tree() for a, b in zip(self.root_node.depth_first_order(), new_tree.depth_first_order()): self.assertEqual(a.numchild, b.numchild) self.assertEqual(a.content_type_id, b.content_type_id) self.assertEqual(a.get_children_count(), b.get_children_count()) self.assertEqual(b.content.get_attributes(), b.content.get_attributes())
def test_validation_error(self): left, right = make_a_nice_tree(self.root_node, self.widgy_site) obj = RawTextWidget.objects.all()[0] url = obj.get_api_url(self.widgy_site) data = obj.to_json(self.widgy_site) data['attributes']['text'] = '' resp = self.put(url, data) self.assertEqual(resp.status_code, 409) # validation error for field name self.assertIn('text', json.loads(resp.content))
def test_add_with_right_id(self): left, right = make_a_nice_tree(self.root_node, self.widgy_site) before_children = len(left.get_children()) new_child = self.post(self.node_url, { '__class__': 'core_tests.rawtextwidget', 'right_id': left.get_children()[0].get_api_url(self.widgy_site), }) self.assertEqual(new_child.status_code, 201) left = Node.objects.get(pk=left.pk) self.assertEqual(before_children + 1, len(left.get_children()))
def test_delete(self): left, right = make_a_nice_tree(self.root_node, self.widgy_site) number_of_nodes = Node.objects.count() number_of_right_nodes = len(right.get_descendants()) + 1 right_children = right.content.depth_first_order() r = self.delete(right.get_api_url(self.widgy_site)) self.assertEqual(r.status_code, 200) with self.assertRaises(Node.DoesNotExist): Node.objects.get(pk=right.pk) for should_be_deleted in right_children: self.assertFalse(type(should_be_deleted).objects.filter(pk=should_be_deleted.pk).exists()) self.assertEqual(Node.objects.count(), number_of_nodes - number_of_right_nodes)
def test_node_404(self): left, right = make_a_nice_tree(self.root_node, self.widgy_site) before_json = self.root_node.to_json(self.widgy_site) # make a fake url right.pk += 9000 r = self.put(left.get_api_url(self.widgy_site), { 'right_id': None, 'parent_id': right.get_api_url(self.widgy_site), }) right.pk -= 9000 self.assertEqual(r.status_code, 404) self.assertEqual(before_json, Node.objects.get(pk=self.root_node.pk).to_json(self.widgy_site))
def test_unkown_content_type_prefetch(self): """ prefetch_tree follows a different code path, so test it too """ fake_ct = ContentType.objects.create( name='fake', app_label='faaaaake', ) left, right = make_a_nice_tree(self.root_node) left.content_type = fake_ct left.save() root_node = Node.objects.get(pk=self.root_node.pk) root_node.prefetch_tree() content = list(root_node.content.get_children())[0].node.content self.assertIsInstance(content, UnknownWidget) self.assertEqual(content.content_type.app_label, fake_ct.app_label)
def setUp(self): super(TestPrefetchTree, self).setUp() make_a_nice_tree(self.root_node) # ensure the ContentType cache is filled for i in ContentType.objects.all(): ContentType.objects.get_for_id(i.pk)
def test_trees_equal_after_clone(self): left, right = make_a_nice_tree(self.root_node) new_root = self.root_node.clone_tree(freeze=False) self.assertTrue(self.root_node.trees_equal(new_root)) new_root.content.get_children()[0].delete() self.assertFalse(self.root_node.trees_equal(new_root))