python类Page()的实例源码

def test_blog_child_of_anything(self):
        """
        Ensures that the Blog page can be child of any kind of Page
        """
        self.assertCanCreateAt(Page, Blog)

def test_post_cannot_be_child_of_anything(self):
        """
        Ensures that a Post page cannot be a child of a generic page
        """
        self.assertCanNotCreateAt(Page, Post)

def test_post_cannot_have_children(self):
        """
        Ensures that a Post page cannot have any kind of children
        """
        self.assertCanNotCreateAt(Post, Page)

def test_static_page_child_of_anything(self):
        """
        Ensures that a Static page can be child of any kind of Page
        """
        self.assertCanCreateAt(Page, StaticPage)

def setUp(self):
        self.root_page = Page.objects.get(id=2)

        # Add child page
        self.child_page = SimplePage(
            title="foobarbaz",
            content="hello",
        )
        self.root_page.add_child(instance=self.child_page)

def test_serialize(self):
        """The value of a ModelChooserBlock (a Page object) should serialize to an ID"""
        block = blocks.ModelChooserBlock('core_page')
        self.assertEqual(block.get_prep_value(self.child_page), self.child_page.id)

        # None should serialize to None
        self.assertEqual(block.get_prep_value(None), None)

def test_deserialize(self):
        """The serialized value of a ModelChooserBlock (an ID) should deserialize to a Page object"""
        block = blocks.ModelChooserBlock('core_page')
        self.assertEqual(isinstance(block.to_python(self.child_page.id), Page), isinstance(self.child_page, Page))

        # None should deserialize to None
        self.assertEqual(block.to_python(None), None)

def test_to_python(self):
        block = blocks.ModelChooserBlock('core_page')
        test_page = self.child_page

        value = block.to_python(test_page.pk)
        self.assertEqual(isinstance(value, Page), isinstance(test_page, Page))
        self.assertEqual(block.to_python(None), None)

def test_target_model(self):
        block = blocks.ModelChooserBlock('core_page')
        self.assertEqual(block.target_model, Page)

def test_get_target_model_string(self):
        widget = widgets.ModelChooserWidget('wagtailcore.Page', **self.get_widget_options())
        model = widget.target_model()
        self.assertEqual(model.__class__, Page)

def test_get_target_model_class(self):
        widget = widgets.ModelChooserWidget(Page, **self.get_widget_options())
        model = widget.target_model()
        self.assertEqual(model.__class__, Page)

def test_get_instance_none_value(self):
        widget = widgets.ModelChooserWidget(Page, **self.get_widget_options())
        self.assertFalse(widget.get_instance(''))

def test_get_instance_page_value(self):
        widget = widgets.ModelChooserWidget(Page, **self.get_widget_options())
        self.assertEqual(widget.get_instance(2), self.root_page)

def test_get_instance_no_page_value_is_none(self):
        widget = widgets.ModelChooserWidget(Page, **self.get_widget_options())
        self.assertEqual(widget.get_instance(999), None)

def test_get_internal_value(self):
        id_ = uuid.uuid4()

        class Stub:
            pk = None

        stub = Stub()
        stub.pk = id_
        widget = widgets.ModelChooserWidget(Page, **self.get_widget_options())
        value = widget.get_internal_value(stub)
        self.assertEqual(value, str(id_))

def test_get_js_init_data(self):
        widget = widgets.ModelChooserWidget(Page, **self.get_widget_options())
        data = widget.get_js_init_data('field-1', None, self.root_page)
        expected_data = {
            'label': 'Page',
            'required': True,
            'initial_display_value': 'Welcome to your new Wagtail site!',
            'display': 'title',
            'list_display': [{'name': 'title', 'label': 'Title'}],
            'endpoint': '/admin/modelchoosers/api/v1/model/wagtailcore.Page',
            'pk_name': 'id',
        }

        self.assertEqual(data, expected_data)

def test_render_js_init(self):
        widget = widgets.ModelChooserWidget(Page, **self.get_widget_options())
        js_init = widget.render_js_init('field-1', None, self.root_page)

        expected_pattern = (
            r'^'                                        # Start of line
            r'wagtailModelChoosers.initModelChooser\('  # Function name
            r'".+"'                                     # First argument, the field id (a string)
            r', '                                       # Comma and space between arguments
            r'.+'                                       # Second argument, the data (an object)
            r'\)'                                       # End of function
            r'$'                                        # End of line
        )

        self.assertRegex(js_init, expected_pattern)

def test_render_html(self):
        widget = widgets.ModelChooserWidget(Page, **self.get_widget_options())
        html = widget.render_html('test', None, {})
        self.assertIn('<input type="hidden" value="" name="test" >', html)

def test_render_html_with_value(self):
        widget = widgets.ModelChooserWidget(Page, **self.get_widget_options())
        html = widget.render_html('test', self.root_page, {})
        self.assertIn('<input type="hidden" value="2" name="test" >', html)

def save(self, *args, **kwargs):
    self.full_clean()

    update_descendant_url_paths = False
    is_new = self.id is None

    if is_new:
        self.set_url_path(self.get_parent())
    else:
        # update url paths if:
        # a) update_fields is specified and it includes any slug field
        # or
        # b) update_fields is not specified (check all slug fields in that case)
        slug_fields = get_translation_fields('slug')
        update_fields = kwargs.get('update_fields', slug_fields)
        updated_slug_fields = [f for f in slug_fields if f in update_fields]
        if updated_slug_fields:
            old_record = Page.objects.get(id=self.id)
            if any(getattr(old_record, f) != getattr(self, f) for f in updated_slug_fields):
                self.set_url_path(self.get_parent())
                update_descendant_url_paths = True

    result = super(Page, self).save(*args, **kwargs)

    if update_descendant_url_paths:
        self._update_descendant_lang_url_paths(old_record)

    if Site.objects.filter(root_page=self).exists():
        delete_root_path_cache()

    if is_new:
        cls = type(self)
        logger.info(
            "Page created: \"%s\" id=%d content_type=%s.%s path=%s",
            self.title,
            self.id,
            cls._meta.app_label,
            cls.__name__,
            self.url_path
        )

    return result