示例#1
0
 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)
示例#2
0
 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)
示例#3
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)
示例#4
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)
示例#5
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)
示例#6
0
    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)
示例#7
0
    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)
示例#8
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)
示例#9
0
    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)
示例#10
0
    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')
示例#11
0
    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'])
示例#12
0
    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)
示例#13
0
 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())
示例#14
0
    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)
示例#15
0
 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())
示例#16
0
    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())
示例#17
0
    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))
示例#18
0
    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())
示例#19
0
    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()))
示例#20
0
    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)
示例#21
0
    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))
示例#22
0
    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)
示例#23
0
    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)
示例#24
0
 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)
示例#25
0
 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))
示例#26
0
 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)
示例#27
0
 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))