3956162881

Build Type

push

github

Committed by Michael Howitz

Commit Message

Update to deprecation warning free releases.

Run Details

4401 of 7036 branches covered (62.55%)

Branch coverage included in aggregate %.

27161 of 31488 relevant lines covered (86.26%)

0.86 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

99.41

/src/Products/PageTemplates/tests/testZopePageTemplate.py

"""
ZopePageTemplate regression tests.

Ensures that adding a page template works correctly.
"""

import unittest

import transaction
import Zope2
import zope.component.testing
from Products.PageTemplates.interfaces import IUnicodeEncodingConflictResolver
from Products.PageTemplates.PageTemplateFile import guess_type
from Products.PageTemplates.unicodeconflictresolver import \
    PreferredCharsetResolver
from Products.PageTemplates.utils import charsetFromMetaEquiv
from Products.PageTemplates.utils import encodingFromXMLPreamble
from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
from Products.PageTemplates.ZopePageTemplate import manage_addPageTemplate
from Testing.makerequest import makerequest
from Testing.testbrowser import Browser
from Testing.ZopeTestCase import FunctionalTestCase
from Testing.ZopeTestCase import ZopeTestCase
from Testing.ZopeTestCase import installProduct
from zope.component import provideUtility
from zope.pagetemplate.pagetemplatefile import DEFAULT_ENCODING
from zope.publisher.http import HTTPCharsets
from zope.traversing.adapters import DefaultTraversable

from .util import useChameleonEngine
from .util import useOldZopeEngine


ascii_binary = b'<html><body>hello world</body></html>'
iso885915_binary = '<html><body>üöäÜÖÄß</body></html>'.encode('iso-8859-15')
utf8_text = iso885915_binary.decode('iso-8859-15').encode('utf-8')

xml_template = '''<?xml version="1.0" encoding="%s"?>
<foo>
üöäÜÖÄß
</foo>
'''

xml_binary_iso_8859_15 = (xml_template % 'iso-8859-15').encode('iso-8859-15')
xml_binary_utf8 = (xml_template % 'utf-8').encode('utf-8')

html_template_w_header = '''
<html>
    <head>
        <META http-equiv="content-type" content="text/html; charset=%s">
    </head>
    <body>
    test üöäÜÖÄß
    </body>
</html>
'''

html_binary_iso_8859_15_w_header = (
    html_template_w_header % 'iso-8859-15').encode('iso-8859-15')
html_binary_utf8_w_header = (html_template_w_header % 'utf-8').encode('utf-8')

html_template_wo_header = '''
<html>
    <body>
    test üöäÜÖÄß
    </body>
</html>
'''

# html_iso_8859_15_wo_header = html_template_wo_header
html_binary_utf8_wo_header = html_template_wo_header.encode('utf-8')

xml_with_upper_attr = b'''<?xml version="1.0"?>
<foo>
   <bar ATTR="1" />
</foo>
'''

html_with_upper_attr = b'''<html><body>
<foo>
   <bar ATTR="1" />
</foo>
</body></html>
'''

installProduct('PageTemplates')


class ZPTUtilsTests(unittest.TestCase):

    def afterSetUp(self):
        useChameleonEngine()

    def testExtractEncodingFromXMLPreamble(self):
        extract = encodingFromXMLPreamble
        self.assertEqual(extract(b'<?xml version="1.0" ?>'), DEFAULT_ENCODING)
        self.assertEqual(extract(b'<?xml encoding="utf-8" '
                                 b'version="1.0" ?>'),
                         'utf-8')
        self.assertEqual(extract(b'<?xml encoding="UTF-8" '
                                 b'version="1.0" ?>'),
                         'utf-8')
        self.assertEqual(extract(b'<?xml encoding="ISO-8859-15" '
                                 b'version="1.0" ?>'),
                         'iso-8859-15')
        self.assertEqual(extract(b'<?xml encoding="iso-8859-15" '
                                 b'version="1.0" ?>'),
                         'iso-8859-15')

    def testExtractCharsetFromMetaHTTPEquivTag(self):
        extract = charsetFromMetaEquiv
        self.assertEqual(extract(b'<html><META http-equiv="content-type" '
                                 b'content="text/html; '
                                 b'charset=UTF-8"></html>'),
                         'utf-8')
        self.assertEqual(extract(b'<html><META http-equiv="content-type" '
                                 b'content="text/html; '
                                 b'charset=iso-8859-15"></html>'),
                         'iso-8859-15')
        self.assertEqual(extract(b'<html><META http-equiv="content-type" '
                                 b'content="text/html"></html>'),
                         None)
        self.assertEqual(extract(b'<html>...<html>'), None)


class ZPTUnicodeEncodingConflictResolution(ZopeTestCase):

    select_engine = staticmethod(useOldZopeEngine)

    def afterSetUp(self):
        self.select_engine()
        zope.component.provideAdapter(DefaultTraversable, (None,))
        zope.component.provideAdapter(HTTPCharsets, (None,))
        provideUtility(PreferredCharsetResolver,
                       IUnicodeEncodingConflictResolver)

    def testISO_8859_15(self):
        manage_addPageTemplate(self.app, 'test',
                               text=(b'<div tal:content="python: '
                                     b'request.get(\'data\')" />'),
                               encoding='ascii')
        zpt = self.app['test']
        self.app.REQUEST.set('HTTP_ACCEPT_CHARSET', 'ISO-8859-15,utf-8')
        self.app.REQUEST.set('data', 'üöä'.encode('iso-8859-15'))
        result = zpt.pt_render()
        self.assertIn('<div>üöä</div>', result)

    def testUTF8(self):
        manage_addPageTemplate(self.app, 'test',
                               text=(b'<div tal:content="python: '
                                     b'request.get(\'data\')" />'),
                               encoding='ascii')
        zpt = self.app['test']
        self.app.REQUEST.set('HTTP_ACCEPT_CHARSET', 'utf-8,ISO-8859-15')
        self.app.REQUEST.set('data', 'üöä'.encode())
        result = zpt.pt_render()
        self.assertIn('<div>üöä</div>', result)

    def testUTF8WrongPreferredCharset(self):
        manage_addPageTemplate(self.app, 'test',
                               text=(b'<div tal:content="python: '
                                     b'request.get(\'data\')" />'),
                               encoding='ascii')
        zpt = self.app['test']
        self.app.REQUEST.set('HTTP_ACCEPT_CHARSET', 'iso-8859-15')
        self.app.REQUEST.set('data', 'üöä'.encode())
        result = zpt.pt_render()
        self.assertNotIn('<div>üöä</div>', result)

    def testStructureWithAccentedChars(self):
        raw = '<div tal:content="structure python: \'üöä\'" />'
        manage_addPageTemplate(self.app, 'test',
                               text=raw.encode('iso-8859-15'),
                               encoding='iso-8859-15')
        zpt = self.app['test']
        self.app.REQUEST.set('HTTP_ACCEPT_CHARSET', 'iso-8859-15,utf-8')
        result = zpt.pt_render()
        self.assertIn('<div>üöä</div>', result)

    def testBug151020(self):
        raw = '<div tal:content="structure python: \'üöä\'" />'
        manage_addPageTemplate(self.app, 'test',
                               text=raw.encode('iso-8859-15'),
                               encoding='iso-8859-15')
        zpt = self.app['test']
        self.app.REQUEST.set('HTTP_ACCEPT_CHARSET',
                             'x-user-defined, iso-8859-15,utf-8')
        result = zpt.pt_render()
        self.assertIn('<div>üöä</div>', result)

    def test_bug_198274(self):
        # See https://bugs.launchpad.net/bugs/198274
        # ZPT w/ '_text' not assigned can't be unpickled.
        import pickle
        empty = ZopePageTemplate(id='empty', text=b' ',
                                 content_type='text/html',
                                 output_encoding='ascii')
        state = pickle.dumps(empty, protocol=1)
        pickle.loads(state)

    def testBug246983(self):
        # See https://bugs.launchpad.net/bugs/246983
        self.app.REQUEST.set('HTTP_ACCEPT_CHARSET', 'utf-8')
        self.app.REQUEST.set('data', 'üöä'.encode())
        # Direct inclusion of encoded strings is hadled normally by the unicode
        # conflict resolver
        textDirect = b"""
        <tal:block content="request/data" />
        """.strip()
        manage_addPageTemplate(self.app, 'test', text=textDirect)
        zpt = self.app['test']
        self.assertEqual(zpt.pt_render(), 'üöä')
        # Indirect inclusion of encoded strings through String Expressions
        # should be resolved as well.
        textIndirect = b"""
        <tal:block content="string:x ${request/data}" />
        """.strip()
        zpt.pt_edit(textIndirect, zpt.content_type)
        self.assertEqual(zpt.pt_render(), 'x üöä')

    def testDebugFlags(self):
        # Test for bug 229549
        manage_addPageTemplate(self.app, 'test',
                               text=b'<div tal:content="string:foo">bar</div>',
                               encoding='ascii')
        zpt = self.app['test']
        from zope.publisher.base import DebugFlags
        self.app.REQUEST.debug = DebugFlags()
        self.assertEqual(zpt.pt_render(), '<div>foo</div>')
        self.app.REQUEST.debug.showTAL = True
        self.assertEqual(zpt.pt_render(),
                         '<div tal:content="string:foo">foo</div>')
        self.app.REQUEST.debug.sourceAnnotations = True
        self.assertEqual(zpt.pt_render().startswith('<!--'), True)


class ZPTUnicodeEncodingConflictResolution_chameleon(
        ZPTUnicodeEncodingConflictResolution):

    select_engine = staticmethod(useChameleonEngine)


class ZopePageTemplateFileTests(ZopeTestCase):

    def afterSetUp(self):
        useChameleonEngine()

    def test_class_conforms_to_IWriteLock(self):
        from OFS.interfaces import IWriteLock
        from zope.interface.verify import verifyClass
        verifyClass(IWriteLock, ZopePageTemplate)

    def testPT_RenderWithAscii(self):
        manage_addPageTemplate(self.app, 'test',
                               text=ascii_binary, encoding='ascii')
        zpt = self.app['test']
        result = zpt.pt_render()
        # use startswith() because the renderer appends a trailing \n
        self.assertEqual(result.encode('ascii').startswith(ascii_binary), True)
        self.assertEqual(zpt.output_encoding, 'utf-8')

    def testPT_RenderUnicodeExpr(self):
        # Check workaround for unicode incompatibility of ZRPythonExpr.
        # See https://mail.zope.dev/pipermail/zope/2007-February/170537.html
        manage_addPageTemplate(self.app, 'test',
                               text=('<span tal:content="python: '
                                     'u\'\xfe\'" />'),
                               encoding='iso-8859-15')
        zpt = self.app['test']
        zpt.pt_render()  # should not raise a UnicodeDecodeError

    def testPT_RenderWithISO885915(self):
        manage_addPageTemplate(self.app, 'test',
                               text=iso885915_binary, encoding='iso-8859-15')
        zpt = self.app['test']
        result = zpt.pt_render()
        # use startswith() because the renderer appends a trailing \n
        res_encoded = result.encode('iso-8859-15')
        self.assertTrue(res_encoded.startswith(iso885915_binary))
        self.assertEqual(zpt.output_encoding, 'utf-8')

    def testPT_RenderWithUTF8(self):
        manage_addPageTemplate(self.app, 'test',
                               text=utf8_text, encoding='utf-8')
        zpt = self.app['test']
        result = zpt.pt_render()
        # use startswith() because the renderer appends a trailing \n
        self.assertEqual(result.encode('utf-8').startswith(utf8_text), True)
        self.assertEqual(zpt.output_encoding, 'utf-8')

    def testWriteAcceptsUnicode(self):
        manage_addPageTemplate(self.app, 'test', '', encoding='utf-8')
        zpt = self.app['test']
        s = 'this is unicode'
        zpt.write(s)
        self.assertEqual(zpt.read(), s)
        self.assertEqual(isinstance(zpt.read(), str), True)

    def testEditWithContentTypeCharset(self):
        manage_addPageTemplate(self.app, 'test', xml_binary_utf8,
                               encoding='utf-8')
        zpt = self.app['test']
        xml_unicode = xml_binary_utf8.decode('utf-8').strip()
        zpt.pt_edit(xml_unicode, 'text/xml')
        zpt.pt_edit(xml_unicode, 'text/xml; charset=utf-8')
        self.assertEqual(zpt.read(), xml_unicode)

    def _createZPT(self):
        manage_addPageTemplate(self.app, 'test',
                               text=utf8_text, encoding='utf-8')
        zpt = self.app['test']
        return zpt

    def _makePUTRequest(self, body):
        return {'BODY': body}

    def _put(self, text):
        zpt = self._createZPT()
        content_type = guess_type('', text)
        zpt.pt_edit(text, content_type)
        return zpt

    def testPutHTMLIso8859_15WithCharsetInfo(self):
        zpt = self._put(html_binary_iso_8859_15_w_header)
        self.assertEqual(zpt.output_encoding, 'iso-8859-15')
        self.assertEqual(zpt.content_type, 'text/html')

    def testPutHTMLUTF8_WithCharsetInfo(self):
        zpt = self._put(html_binary_utf8_w_header)
        self.assertEqual(zpt.output_encoding, 'utf-8')
        self.assertEqual(zpt.content_type, 'text/html')

    def testPutHTMLUTF8_WithoutCharsetInfo(self):
        zpt = self._put(html_binary_utf8_wo_header)
        self.assertEqual(zpt.output_encoding, 'utf-8')
        self.assertEqual(zpt.content_type, 'text/html')

    def testPutXMLIso8859_15(self):
        zpt = self._put(xml_binary_iso_8859_15)
        self.assertEqual(zpt.output_encoding, 'iso-8859-15')
        self.assertEqual(zpt.content_type, 'text/xml')
        zpt.pt_render()  # should not raise an exception

    def testPutXMLUTF8(self):
        zpt = self._put(xml_binary_utf8)
        self.assertEqual(zpt.output_encoding, 'utf-8')
        self.assertEqual(zpt.content_type, 'text/xml')
        zpt.pt_render()  # should not raise an exception

    def testXMLAttrsMustNotBeLowercased(self):
        zpt = self._put(xml_with_upper_attr)
        self.assertEqual(zpt.content_type, 'text/xml')
        result = zpt.pt_render()
        self.assertEqual('ATTR' in result, True)

    def testHTMLAttrsAreLowerCased(self):
        # BBB Only the old Zope page template engine does this munging
        useOldZopeEngine()
        zpt = self._put(html_with_upper_attr)
        self.content_type = 'text/html'
        result = zpt.pt_render()
        self.assertEqual('ATTR' in result, False)


class PreferredCharsetUnicodeResolverTests(unittest.TestCase):

    def testPreferredCharsetResolverWithoutRequestAndWithoutEncoding(self):
        # This test checks the edgecase where the unicode conflict resolver
        # is called with a context object having no REQUEST
        # Since switching from ``management_page_charset`` set on the
        # REQUEST to the ``default-zpublisher-encoding`` configuration
        # setting that is always available, this test will return a
        # correctly decoded value.
        context = object()
        result = PreferredCharsetResolver.resolve(context, 'üöä', None)
        self.assertEqual(result, 'üöä')


class ZPTRegressions(unittest.TestCase):

    def setUp(self):
        useChameleonEngine()
        transaction.begin()
        self.app = makerequest(Zope2.app())
        f = self.app.manage_addProduct['PageTemplates'].manage_addPageTemplate
        self._addPT = f
        self.title = 'title of page template'
        self.text = 'text of page template'

    def tearDown(self):
        transaction.abort()
        self.app._p_jar.close()

    def testAddWithParams(self):
        pt = self._addPT('pt1', title=self.title, text=self.text)
        self.assertEqual(pt.title, self.title)
        self.assertEqual(pt.document_src(), self.text)

    def testAddWithoutParams(self):
        pt = self._addPT('pt1')
        with open(pt._default_content_fn) as fd:
            default_text = fd.read()
        self.assertEqual(pt.title, '')
        self.assertEqual(pt.document_src().strip(), default_text.strip())

    def testAddWithRequest(self):
        # Test manage_add with file
        request = self.app.REQUEST
        request.form['file'] = DummyFileUpload(filename='some file',
                                               data=self.text,
                                               content_type='text/html')
        self._addPT('pt1', REQUEST=request)
        # no object is returned when REQUEST is passed.
        pt = self.app.pt1
        self.assertEqual(pt.document_src(), self.text)

    def testAddWithRequestButNoFile(self):
        # Collector #596: manage_add with text but no file
        request = self.app.REQUEST
        self._addPT('pt1', text=self.text, REQUEST=request)
        # no object is returned when REQUEST is passed.
        pt = self.app.pt1
        self.assertEqual(pt.document_src(), self.text)


class ZPTMacros(zope.component.testing.PlacelessSetup, unittest.TestCase):

    def setUp(self):
        super().setUp()
        useChameleonEngine()
        zope.component.provideAdapter(DefaultTraversable, (None,))

        transaction.begin()
        self.app = makerequest(Zope2.app())
        f = self.app.manage_addProduct['PageTemplates'].manage_addPageTemplate
        self._addPT = f
        self.title = 'title of page template'
        self.text = """
<metal:block use-macro="template/macros/themacro">
  <p metal:fill-slot="theslot">
    This is in the slot
  </p>
</metal:block>
<tal:block condition="nothing">
<div metal:define-macro="themacro">
  <h1>This is the header</h1>
  <p metal:define-slot="theslot">
    This will be replaced
  </p>
</div>
</tal:block>
"""
        self.result = """<div>
  <h1>This is the header</h1>
  <p>
    This is in the slot
  </p>
</div>
"""

    def tearDown(self):
        super().tearDown()

        transaction.abort()
        self.app._p_jar.close()

    def testMacroExpansion(self):
        request = self.app.REQUEST
        self._addPT('pt1', text=self.text, REQUEST=request)
        pt = self.app.pt1
        self.assertEqual(pt(), self.result)

    def testPtErrors(self):
        request = self.app.REQUEST
        self._addPT('pt1', text=self.text, REQUEST=request)
        pt = self.app.pt1
        pt.pt_render(source=True)
        self.assertEqual(pt.pt_errors(), None)


class SrcTests(unittest.TestCase):

    def setUp(self):
        useChameleonEngine()

    def _getTargetClass(self):
        from Products.PageTemplates.ZopePageTemplate import Src
        return Src

    def _makeOne(self, zpt=None):
        if zpt is None:
            zpt = self._makeTemplate()
        zpt.test_src = self._getTargetClass()()
        return zpt.test_src

    def _makeTemplate(self, id='test', source='<html/>'):
        from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
        return ZopePageTemplate(id, source)

    def test___before_publishing_traverse___wo__hacked_path(self):
        src = self._makeOne()
        request = DummyRequest()
        src.__before_publishing_traverse__(None, request)
        self.assertFalse('_hacked_path' in request.__dict__)

    def test___before_publishing_traverse___w__hacked_path_false(self):
        src = self._makeOne()
        request = DummyRequest()
        request._hacked_path = False
        src.__before_publishing_traverse__(None, request)
        self.assertFalse(request._hacked_path)

    def test___before_publishing_traverse___w__hacked_path_true(self):
        src = self._makeOne()
        request = DummyRequest()
        request._hacked_path = True
        src.__before_publishing_traverse__(None, request)
        self.assertFalse(request._hacked_path)

    def test___call__(self):
        template = self._makeTemplate(source='TESTING')
        src = self._makeOne(template)
        request = DummyRequest()
        response = object()
        self.assertEqual(src(request, response), 'TESTING')


class ZPTBrowserTests(FunctionalTestCase):
    """Browser testing ZopePageTemplate"""

    def afterSetUp(self):
        useChameleonEngine()

    def setUp(self):
        from Products.PageTemplates.ZopePageTemplate import \
            manage_addPageTemplate
        super().setUp()

        Zope2.App.zcml.load_site(force=True)

        uf = self.app.acl_users
        uf.userFolderAddUser('manager', 'manager_pass', ['Manager'], [])
        manage_addPageTemplate(self.app, 'page_template')

        self.browser = Browser()
        self.browser.login('manager', 'manager_pass')
        self.browser.open('http://localhost/page_template/manage_main')

    def test_pt_upload__no_file(self):
        """It renders an error message if no file is uploaded."""
        self.browser.getControl('Upload File').click()
        self.assertIn('No file specified', self.browser.contents)


class DummyRequest(dict):
    pass


class DummyFileUpload:

    def __init__(self, data='', filename='', content_type=''):
        self.data = data
        self.filename = filename
        self.headers = {'content_type': content_type}

    def read(self):
        return self.data


def test_suite():
    return unittest.TestSuite((
        unittest.defaultTestLoader.loadTestsFromTestCase(ZPTRegressions),
        unittest.defaultTestLoader.loadTestsFromTestCase(ZPTUtilsTests),
        unittest.defaultTestLoader.loadTestsFromTestCase(ZPTMacros),
        unittest.defaultTestLoader.loadTestsFromTestCase(
            ZopePageTemplateFileTests),
        unittest.defaultTestLoader.loadTestsFromTestCase(
            ZPTUnicodeEncodingConflictResolution),
        unittest.defaultTestLoader.loadTestsFromTestCase(ZPTBrowserTests),
        unittest.defaultTestLoader.loadTestsFromTestCase(
            PreferredCharsetUnicodeResolverTests),
        unittest.defaultTestLoader.loadTestsFromTestCase(SrcTests),
    ))

1	"""
2	ZopePageTemplate regression tests.
3
4	Ensures that adding a page template works correctly.
5	"""
6
7	import unittest	1✔
8
9	import transaction	1✔
10	import Zope2	1✔
11	import zope.component.testing	1✔
12	from Products.PageTemplates.interfaces import IUnicodeEncodingConflictResolver	1✔
13	from Products.PageTemplates.PageTemplateFile import guess_type	1✔
14	from Products.PageTemplates.unicodeconflictresolver import \	1✔
15	PreferredCharsetResolver
16	from Products.PageTemplates.utils import charsetFromMetaEquiv	1✔
17	from Products.PageTemplates.utils import encodingFromXMLPreamble	1✔
18	from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate	1✔
19	from Products.PageTemplates.ZopePageTemplate import manage_addPageTemplate	1✔
20	from Testing.makerequest import makerequest	1✔
21	from Testing.testbrowser import Browser	1✔
22	from Testing.ZopeTestCase import FunctionalTestCase	1✔
23	from Testing.ZopeTestCase import ZopeTestCase	1✔
24	from Testing.ZopeTestCase import installProduct	1✔
25	from zope.component import provideUtility	1✔
26	from zope.pagetemplate.pagetemplatefile import DEFAULT_ENCODING	1✔
27	from zope.publisher.http import HTTPCharsets	1✔
28	from zope.traversing.adapters import DefaultTraversable	1✔
29
30	from .util import useChameleonEngine	1✔
31	from .util import useOldZopeEngine	1✔
32
33
34	ascii_binary = b'<html><body>hello world</body></html>'	1✔
35	iso885915_binary = '<html><body>üöäÜÖÄß</body></html>'.encode('iso-8859-15')	1✔
36	utf8_text = iso885915_binary.decode('iso-8859-15').encode('utf-8')	1✔
37
38	xml_template = '''<?xml version="1.0" encoding="%s"?>	1✔
39	<foo>
40	üöäÜÖÄß
41	</foo>
42	'''
43
44	xml_binary_iso_8859_15 = (xml_template % 'iso-8859-15').encode('iso-8859-15')	1✔
45	xml_binary_utf8 = (xml_template % 'utf-8').encode('utf-8')	1✔
46
47	html_template_w_header = '''	1✔
48	<html>
49	<head>
50	<META http-equiv="content-type" content="text/html; charset=%s">
51	</head>
52	<body>
53	test üöäÜÖÄß
54	</body>
55	</html>
56	'''
57
58	html_binary_iso_8859_15_w_header = (	1✔
59	html_template_w_header % 'iso-8859-15').encode('iso-8859-15')
60	html_binary_utf8_w_header = (html_template_w_header % 'utf-8').encode('utf-8')	1✔
61
62	html_template_wo_header = '''	1✔
63	<html>
64	<body>
65	test üöäÜÖÄß
66	</body>
67	</html>
68	'''
69
70	# html_iso_8859_15_wo_header = html_template_wo_header
71	html_binary_utf8_wo_header = html_template_wo_header.encode('utf-8')	1✔
72
73	xml_with_upper_attr = b'''<?xml version="1.0"?>	1✔
74	<foo>
75	<bar ATTR="1" />
76	</foo>
77	'''
78
79	html_with_upper_attr = b'''<html><body>	1✔
80	<foo>
81	<bar ATTR="1" />
82	</foo>
83	</body></html>
84	'''
85
86	installProduct('PageTemplates')	1✔
87
88
89	class ZPTUtilsTests(unittest.TestCase):	1✔
90
91	def afterSetUp(self):	1✔
92	useChameleonEngine()	×
93
94	def testExtractEncodingFromXMLPreamble(self):	1✔
95	extract = encodingFromXMLPreamble	1✔
96	self.assertEqual(extract(b'<?xml version="1.0" ?>'), DEFAULT_ENCODING)	1✔
97	self.assertEqual(extract(b'<?xml encoding="utf-8" '	1✔
98	b'version="1.0" ?>'),
99	'utf-8')
100	self.assertEqual(extract(b'<?xml encoding="UTF-8" '	1✔
101	b'version="1.0" ?>'),
102	'utf-8')
103	self.assertEqual(extract(b'<?xml encoding="ISO-8859-15" '	1✔
104	b'version="1.0" ?>'),
105	'iso-8859-15')
106	self.assertEqual(extract(b'<?xml encoding="iso-8859-15" '	1✔
107	b'version="1.0" ?>'),
108	'iso-8859-15')
109
110	def testExtractCharsetFromMetaHTTPEquivTag(self):	1✔
111	extract = charsetFromMetaEquiv	1✔
112	self.assertEqual(extract(b'<html><META http-equiv="content-type" '	1✔
113	b'content="text/html; '
114	b'charset=UTF-8"></html>'),
115	'utf-8')
116	self.assertEqual(extract(b'<html><META http-equiv="content-type" '	1✔
117	b'content="text/html; '
118	b'charset=iso-8859-15"></html>'),
119	'iso-8859-15')
120	self.assertEqual(extract(b'<html><META http-equiv="content-type" '	1✔
121	b'content="text/html"></html>'),
122	None)
123	self.assertEqual(extract(b'<html>...<html>'), None)	1✔
124
125
126	class ZPTUnicodeEncodingConflictResolution(ZopeTestCase):	1✔
127
128	select_engine = staticmethod(useOldZopeEngine)	1✔
129
130	def afterSetUp(self):	1✔
131	self.select_engine()	1✔
132	zope.component.provideAdapter(DefaultTraversable, (None,))	1✔
133	zope.component.provideAdapter(HTTPCharsets, (None,))	1✔
134	provideUtility(PreferredCharsetResolver,	1✔
135	IUnicodeEncodingConflictResolver)
136
137	def testISO_8859_15(self):	1✔
138	manage_addPageTemplate(self.app, 'test',	1✔
139	text=(b'<div tal:content="python: '
140	b'request.get(\'data\')" />'),
141	encoding='ascii')
142	zpt = self.app['test']	1✔
143	self.app.REQUEST.set('HTTP_ACCEPT_CHARSET', 'ISO-8859-15,utf-8')	1✔
144	self.app.REQUEST.set('data', 'üöä'.encode('iso-8859-15'))	1✔
145	result = zpt.pt_render()	1✔
146	self.assertIn('<div>üöä</div>', result)	1✔
147
148	def testUTF8(self):	1✔
149	manage_addPageTemplate(self.app, 'test',	1✔
150	text=(b'<div tal:content="python: '
151	b'request.get(\'data\')" />'),
152	encoding='ascii')
153	zpt = self.app['test']	1✔
154	self.app.REQUEST.set('HTTP_ACCEPT_CHARSET', 'utf-8,ISO-8859-15')	1✔
155	self.app.REQUEST.set('data', 'üöä'.encode())	1✔
156	result = zpt.pt_render()	1✔
157	self.assertIn('<div>üöä</div>', result)	1✔
158
159	def testUTF8WrongPreferredCharset(self):	1✔
160	manage_addPageTemplate(self.app, 'test',	1✔
161	text=(b'<div tal:content="python: '
162	b'request.get(\'data\')" />'),
163	encoding='ascii')
164	zpt = self.app['test']	1✔
165	self.app.REQUEST.set('HTTP_ACCEPT_CHARSET', 'iso-8859-15')	1✔
166	self.app.REQUEST.set('data', 'üöä'.encode())	1✔
167	result = zpt.pt_render()	1✔
168	self.assertNotIn('<div>üöä</div>', result)	1✔
169
170	def testStructureWithAccentedChars(self):	1✔
171	raw = '<div tal:content="structure python: \'üöä\'" />'	1✔
172	manage_addPageTemplate(self.app, 'test',	1✔
173	text=raw.encode('iso-8859-15'),
174	encoding='iso-8859-15')
175	zpt = self.app['test']	1✔
176	self.app.REQUEST.set('HTTP_ACCEPT_CHARSET', 'iso-8859-15,utf-8')	1✔
177	result = zpt.pt_render()	1✔
178	self.assertIn('<div>üöä</div>', result)	1✔
179
180	def testBug151020(self):	1✔
181	raw = '<div tal:content="structure python: \'üöä\'" />'	1✔
182	manage_addPageTemplate(self.app, 'test',	1✔
183	text=raw.encode('iso-8859-15'),
184	encoding='iso-8859-15')
185	zpt = self.app['test']	1✔
186	self.app.REQUEST.set('HTTP_ACCEPT_CHARSET',	1✔
187	'x-user-defined, iso-8859-15,utf-8')
188	result = zpt.pt_render()	1✔
189	self.assertIn('<div>üöä</div>', result)	1✔
190
191	def test_bug_198274(self):	1✔
192	# See https://bugs.launchpad.net/bugs/198274
193	# ZPT w/ '_text' not assigned can't be unpickled.
194	import pickle	1✔
195	empty = ZopePageTemplate(id='empty', text=b' ',	1✔
196	content_type='text/html',
197	output_encoding='ascii')
198	state = pickle.dumps(empty, protocol=1)	1✔
199	pickle.loads(state)	1✔
200
201	def testBug246983(self):	1✔
202	# See https://bugs.launchpad.net/bugs/246983
203	self.app.REQUEST.set('HTTP_ACCEPT_CHARSET', 'utf-8')	1✔
204	self.app.REQUEST.set('data', 'üöä'.encode())	1✔
205	# Direct inclusion of encoded strings is hadled normally by the unicode
206	# conflict resolver
207	textDirect = b"""	1✔
208	<tal:block content="request/data" />
209	""".strip()
210	manage_addPageTemplate(self.app, 'test', text=textDirect)	1✔
211	zpt = self.app['test']	1✔
212	self.assertEqual(zpt.pt_render(), 'üöä')	1✔
213	# Indirect inclusion of encoded strings through String Expressions
214	# should be resolved as well.
215	textIndirect = b"""	1✔
216	<tal:block content="string:x ${request/data}" />
217	""".strip()
218	zpt.pt_edit(textIndirect, zpt.content_type)	1✔
219	self.assertEqual(zpt.pt_render(), 'x üöä')	1✔
220
221	def testDebugFlags(self):	1✔
222	# Test for bug 229549
223	manage_addPageTemplate(self.app, 'test',	1✔
224	text=b'<div tal:content="string:foo">bar</div>',
225	encoding='ascii')
226	zpt = self.app['test']	1✔
227	from zope.publisher.base import DebugFlags	1✔
228	self.app.REQUEST.debug = DebugFlags()	1✔
229	self.assertEqual(zpt.pt_render(), '<div>foo</div>')	1✔
230	self.app.REQUEST.debug.showTAL = True	1✔
231	self.assertEqual(zpt.pt_render(),	1✔
232	'<div tal:content="string:foo">foo</div>')
233	self.app.REQUEST.debug.sourceAnnotations = True	1✔
234	self.assertEqual(zpt.pt_render().startswith('<!--'), True)	1✔
235
236
237	class ZPTUnicodeEncodingConflictResolution_chameleon(	1✔
238	ZPTUnicodeEncodingConflictResolution):
239
240	select_engine = staticmethod(useChameleonEngine)	1✔
241
242
243	class ZopePageTemplateFileTests(ZopeTestCase):	1✔
244
245	def afterSetUp(self):	1✔
246	useChameleonEngine()	1✔
247
248	def test_class_conforms_to_IWriteLock(self):	1✔
249	from OFS.interfaces import IWriteLock	1✔
250	from zope.interface.verify import verifyClass	1✔
251	verifyClass(IWriteLock, ZopePageTemplate)	1✔
252
253	def testPT_RenderWithAscii(self):	1✔
254	manage_addPageTemplate(self.app, 'test',	1✔
255	text=ascii_binary, encoding='ascii')
256	zpt = self.app['test']	1✔
257	result = zpt.pt_render()	1✔
258	# use startswith() because the renderer appends a trailing \n
259	self.assertEqual(result.encode('ascii').startswith(ascii_binary), True)	1✔
260	self.assertEqual(zpt.output_encoding, 'utf-8')	1✔
261
262	def testPT_RenderUnicodeExpr(self):	1✔
263	# Check workaround for unicode incompatibility of ZRPythonExpr.
264	# See https://mail.zope.dev/pipermail/zope/2007-February/170537.html
265	manage_addPageTemplate(self.app, 'test',	1✔
266	text=('<span tal:content="python: '
267	'u\'\xfe\'" />'),
268	encoding='iso-8859-15')
269	zpt = self.app['test']	1✔
270	zpt.pt_render() # should not raise a UnicodeDecodeError	1✔
271
272	def testPT_RenderWithISO885915(self):	1✔
273	manage_addPageTemplate(self.app, 'test',	1✔
274	text=iso885915_binary, encoding='iso-8859-15')
275	zpt = self.app['test']	1✔
276	result = zpt.pt_render()	1✔
277	# use startswith() because the renderer appends a trailing \n
278	res_encoded = result.encode('iso-8859-15')	1✔
279	self.assertTrue(res_encoded.startswith(iso885915_binary))	1✔
280	self.assertEqual(zpt.output_encoding, 'utf-8')	1✔
281
282	def testPT_RenderWithUTF8(self):	1✔
283	manage_addPageTemplate(self.app, 'test',	1✔
284	text=utf8_text, encoding='utf-8')
285	zpt = self.app['test']	1✔
286	result = zpt.pt_render()	1✔
287	# use startswith() because the renderer appends a trailing \n
288	self.assertEqual(result.encode('utf-8').startswith(utf8_text), True)	1✔
289	self.assertEqual(zpt.output_encoding, 'utf-8')	1✔
290
291	def testWriteAcceptsUnicode(self):	1✔
292	manage_addPageTemplate(self.app, 'test', '', encoding='utf-8')	1✔
293	zpt = self.app['test']	1✔
294	s = 'this is unicode'	1✔
295	zpt.write(s)	1✔
296	self.assertEqual(zpt.read(), s)	1✔
297	self.assertEqual(isinstance(zpt.read(), str), True)	1✔
298
299	def testEditWithContentTypeCharset(self):	1✔
300	manage_addPageTemplate(self.app, 'test', xml_binary_utf8,	1✔
301	encoding='utf-8')
302	zpt = self.app['test']	1✔
303	xml_unicode = xml_binary_utf8.decode('utf-8').strip()	1✔
304	zpt.pt_edit(xml_unicode, 'text/xml')	1✔
305	zpt.pt_edit(xml_unicode, 'text/xml; charset=utf-8')	1✔
306	self.assertEqual(zpt.read(), xml_unicode)	1✔
307
308	def _createZPT(self):	1✔
309	manage_addPageTemplate(self.app, 'test',	1✔
310	text=utf8_text, encoding='utf-8')
311	zpt = self.app['test']	1✔
312	return zpt	1✔
313
314	def _makePUTRequest(self, body):	1✔
315	return {'BODY': body}	×
316
317	def _put(self, text):	1✔
318	zpt = self._createZPT()	1✔
319	content_type = guess_type('', text)	1✔
320	zpt.pt_edit(text, content_type)	1✔
321	return zpt	1✔
322
323	def testPutHTMLIso8859_15WithCharsetInfo(self):	1✔
324	zpt = self._put(html_binary_iso_8859_15_w_header)	1✔
325	self.assertEqual(zpt.output_encoding, 'iso-8859-15')	1✔
326	self.assertEqual(zpt.content_type, 'text/html')	1✔
327
328	def testPutHTMLUTF8_WithCharsetInfo(self):	1✔
329	zpt = self._put(html_binary_utf8_w_header)	1✔
330	self.assertEqual(zpt.output_encoding, 'utf-8')	1✔
331	self.assertEqual(zpt.content_type, 'text/html')	1✔
332
333	def testPutHTMLUTF8_WithoutCharsetInfo(self):	1✔
334	zpt = self._put(html_binary_utf8_wo_header)	1✔
335	self.assertEqual(zpt.output_encoding, 'utf-8')	1✔
336	self.assertEqual(zpt.content_type, 'text/html')	1✔
337
338	def testPutXMLIso8859_15(self):	1✔
339	zpt = self._put(xml_binary_iso_8859_15)	1✔
340	self.assertEqual(zpt.output_encoding, 'iso-8859-15')	1✔
341	self.assertEqual(zpt.content_type, 'text/xml')	1✔
342	zpt.pt_render() # should not raise an exception	1✔
343
344	def testPutXMLUTF8(self):	1✔
345	zpt = self._put(xml_binary_utf8)	1✔
346	self.assertEqual(zpt.output_encoding, 'utf-8')	1✔
347	self.assertEqual(zpt.content_type, 'text/xml')	1✔
348	zpt.pt_render() # should not raise an exception	1✔
349
350	def testXMLAttrsMustNotBeLowercased(self):	1✔
351	zpt = self._put(xml_with_upper_attr)	1✔
352	self.assertEqual(zpt.content_type, 'text/xml')	1✔
353	result = zpt.pt_render()	1✔
354	self.assertEqual('ATTR' in result, True)	1✔
355
356	def testHTMLAttrsAreLowerCased(self):	1✔
357	# BBB Only the old Zope page template engine does this munging
358	useOldZopeEngine()	1✔
359	zpt = self._put(html_with_upper_attr)	1✔
360	self.content_type = 'text/html'	1✔
361	result = zpt.pt_render()	1✔
362	self.assertEqual('ATTR' in result, False)	1✔
363
364
365	class PreferredCharsetUnicodeResolverTests(unittest.TestCase):	1✔
366
367	def testPreferredCharsetResolverWithoutRequestAndWithoutEncoding(self):	1✔
368	# This test checks the edgecase where the unicode conflict resolver
369	# is called with a context object having no REQUEST
370	# Since switching from ``management_page_charset`` set on the
371	# REQUEST to the ``default-zpublisher-encoding`` configuration
372	# setting that is always available, this test will return a
373	# correctly decoded value.
374	context = object()	1✔
375	result = PreferredCharsetResolver.resolve(context, 'üöä', None)	1✔
376	self.assertEqual(result, 'üöä')	1✔
377
378
379	class ZPTRegressions(unittest.TestCase):	1✔
380
381	def setUp(self):	1✔
382	useChameleonEngine()	1✔
383	transaction.begin()	1✔
384	self.app = makerequest(Zope2.app())	1✔
385	f = self.app.manage_addProduct['PageTemplates'].manage_addPageTemplate	1✔
386	self._addPT = f	1✔
387	self.title = 'title of page template'	1✔
388	self.text = 'text of page template'	1✔
389
390	def tearDown(self):	1✔
391	transaction.abort()	1✔
392	self.app._p_jar.close()	1✔
393
394	def testAddWithParams(self):	1✔
395	pt = self._addPT('pt1', title=self.title, text=self.text)	1✔
396	self.assertEqual(pt.title, self.title)	1✔
397	self.assertEqual(pt.document_src(), self.text)	1✔
398
399	def testAddWithoutParams(self):	1✔
400	pt = self._addPT('pt1')	1✔
401	with open(pt._default_content_fn) as fd:	1✔
402	default_text = fd.read()	1✔
403	self.assertEqual(pt.title, '')	1✔
404	self.assertEqual(pt.document_src().strip(), default_text.strip())	1✔
405
406	def testAddWithRequest(self):	1✔
407	# Test manage_add with file
408	request = self.app.REQUEST	1✔
409	request.form['file'] = DummyFileUpload(filename='some file',	1✔
410	data=self.text,
411	content_type='text/html')
412	self._addPT('pt1', REQUEST=request)	1✔
413	# no object is returned when REQUEST is passed.
414	pt = self.app.pt1	1✔
415	self.assertEqual(pt.document_src(), self.text)	1✔
416
417	def testAddWithRequestButNoFile(self):	1✔
418	# Collector #596: manage_add with text but no file
419	request = self.app.REQUEST	1✔
420	self._addPT('pt1', text=self.text, REQUEST=request)	1✔
421	# no object is returned when REQUEST is passed.
422	pt = self.app.pt1	1✔
423	self.assertEqual(pt.document_src(), self.text)	1✔
424
425
426	class ZPTMacros(zope.component.testing.PlacelessSetup, unittest.TestCase):	1✔
427
428	def setUp(self):	1✔
429	super().setUp()	1✔
430	useChameleonEngine()	1✔
431	zope.component.provideAdapter(DefaultTraversable, (None,))	1✔
432
433	transaction.begin()	1✔
434	self.app = makerequest(Zope2.app())	1✔
435	f = self.app.manage_addProduct['PageTemplates'].manage_addPageTemplate	1✔
436	self._addPT = f	1✔
437	self.title = 'title of page template'	1✔
438	self.text = """	1✔
439	<metal:block use-macro="template/macros/themacro">
440	<p metal:fill-slot="theslot">
441	This is in the slot
442	</p>
443	</metal:block>
444	<tal:block condition="nothing">
445	<div metal:define-macro="themacro">
446	<h1>This is the header</h1>
447	<p metal:define-slot="theslot">
448	This will be replaced
449	</p>
450	</div>
451	</tal:block>
452	"""
453	self.result = """<div>	1✔
454	<h1>This is the header</h1>
455	<p>
456	This is in the slot
457	</p>
458	</div>
459	"""
460
461	def tearDown(self):	1✔
462	super().tearDown()	1✔
463
464	transaction.abort()	1✔
465	self.app._p_jar.close()	1✔
466
467	def testMacroExpansion(self):	1✔
468	request = self.app.REQUEST	1✔
469	self._addPT('pt1', text=self.text, REQUEST=request)	1✔
470	pt = self.app.pt1	1✔
471	self.assertEqual(pt(), self.result)	1✔
472
473	def testPtErrors(self):	1✔
474	request = self.app.REQUEST	1✔
475	self._addPT('pt1', text=self.text, REQUEST=request)	1✔
476	pt = self.app.pt1	1✔
477	pt.pt_render(source=True)	1✔
478	self.assertEqual(pt.pt_errors(), None)	1✔
479
480
481	class SrcTests(unittest.TestCase):	1✔
482
483	def setUp(self):	1✔
484	useChameleonEngine()	1✔
485
486	def _getTargetClass(self):	1✔
487	from Products.PageTemplates.ZopePageTemplate import Src	1✔
488	return Src	1✔
489
490	def _makeOne(self, zpt=None):	1✔
491	if zpt is None:	1✔
492	zpt = self._makeTemplate()	1✔
493	zpt.test_src = self._getTargetClass()()	1✔
494	return zpt.test_src	1✔
495
496	def _makeTemplate(self, id='test', source='<html/>'):	1✔
497	from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate	1✔
498	return ZopePageTemplate(id, source)	1✔
499
500	def test___before_publishing_traverse___wo__hacked_path(self):	1✔
501	src = self._makeOne()	1✔
502	request = DummyRequest()	1✔
503	src.__before_publishing_traverse__(None, request)	1✔
504	self.assertFalse('_hacked_path' in request.__dict__)	1✔
505
506	def test___before_publishing_traverse___w__hacked_path_false(self):	1✔
507	src = self._makeOne()	1✔
508	request = DummyRequest()	1✔
509	request._hacked_path = False	1✔
510	src.__before_publishing_traverse__(None, request)	1✔
511	self.assertFalse(request._hacked_path)	1✔
512
513	def test___before_publishing_traverse___w__hacked_path_true(self):	1✔
514	src = self._makeOne()	1✔
515	request = DummyRequest()	1✔
516	request._hacked_path = True	1✔
517	src.__before_publishing_traverse__(None, request)	1✔
518	self.assertFalse(request._hacked_path)	1✔
519
520	def test___call__(self):	1✔
521	template = self._makeTemplate(source='TESTING')	1✔
522	src = self._makeOne(template)	1✔
523	request = DummyRequest()	1✔
524	response = object()	1✔
525	self.assertEqual(src(request, response), 'TESTING')	1✔
526
527
528	class ZPTBrowserTests(FunctionalTestCase):	1✔
529	"""Browser testing ZopePageTemplate"""
530
531	def afterSetUp(self):	1✔
532	useChameleonEngine()	1✔
533
534	def setUp(self):	1✔
535	from Products.PageTemplates.ZopePageTemplate import \	1✔
536	manage_addPageTemplate
537	super().setUp()	1✔
538
539	Zope2.App.zcml.load_site(force=True)	1✔
540
541	uf = self.app.acl_users	1✔
542	uf.userFolderAddUser('manager', 'manager_pass', ['Manager'], [])	1✔
543	manage_addPageTemplate(self.app, 'page_template')	1✔
544
545	self.browser = Browser()	1✔
546	self.browser.login('manager', 'manager_pass')	1✔
547	self.browser.open('http://localhost/page_template/manage_main')	1✔
548
549	def test_pt_upload__no_file(self):	1✔
550	"""It renders an error message if no file is uploaded."""
551	self.browser.getControl('Upload File').click()	1✔
552	self.assertIn('No file specified', self.browser.contents)	1✔
553
554
555	class DummyRequest(dict):	1✔
556	pass	1✔
557
558
559	class DummyFileUpload:	1✔
560
561	def __init__(self, data='', filename='', content_type=''):	1✔
562	self.data = data	1✔
563	self.filename = filename	1✔
564	self.headers = {'content_type': content_type}	1✔
565
566	def read(self):	1✔
567	return self.data	1✔
568
569
570	def test_suite():	1✔
571	return unittest.TestSuite((	1✔
572	unittest.defaultTestLoader.loadTestsFromTestCase(ZPTRegressions),
573	unittest.defaultTestLoader.loadTestsFromTestCase(ZPTUtilsTests),
574	unittest.defaultTestLoader.loadTestsFromTestCase(ZPTMacros),
575	unittest.defaultTestLoader.loadTestsFromTestCase(
576	ZopePageTemplateFileTests),
577	unittest.defaultTestLoader.loadTestsFromTestCase(
578	ZPTUnicodeEncodingConflictResolution),
579	unittest.defaultTestLoader.loadTestsFromTestCase(ZPTBrowserTests),
580	unittest.defaultTestLoader.loadTestsFromTestCase(
581	PreferredCharsetUnicodeResolverTests),
582	unittest.defaultTestLoader.loadTestsFromTestCase(SrcTests),
583	))

zopefoundation / Zope / 3956162881

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous