[Repoze-checkins] r651 - in repoze.kiss/trunk: . repoze/kiss/tests
Tres Seaver
tseaver at palladion.com
Sun Feb 3 07:37:05 UTC 2008
Author: Tres Seaver <tseaver at palladion.com>
Date: Sun Feb 3 02:37:04 2008
New Revision: 651
Log:
Add unit tests for proxy classes.
Added:
repoze.kiss/trunk/repoze/kiss/tests/test_proxy.py
Modified:
repoze.kiss/trunk/CHANGES.txt
Modified: repoze.kiss/trunk/CHANGES.txt
==============================================================================
--- repoze.kiss/trunk/CHANGES.txt (original)
+++ repoze.kiss/trunk/CHANGES.txt Sun Feb 3 02:37:04 2008
@@ -1,6 +1,6 @@
repoze.kiss (unreleased)
- - Hmm.
+ - Added unit tests for proxy classes.
repoze.kiss 0.1 (2007-10-08)
Added: repoze.kiss/trunk/repoze/kiss/tests/test_proxy.py
==============================================================================
--- (empty file)
+++ repoze.kiss/trunk/repoze/kiss/tests/test_proxy.py Sun Feb 3 02:37:04 2008
@@ -0,0 +1,470 @@
+import unittest
+
+class FSZReSTTests(unittest.TestCase):
+
+ def _getTargetClass(self):
+ from repoze.kiss.proxy import FSZReST
+ return FSZReST
+
+ def _makeOne(self, name='test', source=None):
+ test = self._getTargetClass()(name)
+ if source is not None:
+ test.source = source
+ return test
+
+ def _makeContainer(self, **kw):
+ from ExtensionClass import Base
+
+ class _Container(Base):
+ def __init__(self, **kw):
+ self.acquired = kw.copy()
+
+ return _Container(**kw)
+
+ def test_class_conformsToIZReST(self):
+ from zope.interface.verify import verifyClass
+ from repoze.kiss.proxy import IZReST
+ verifyClass(IZReST, self._getTargetClass())
+
+ def test_instance_conformsToIZReST(self):
+ from zope.interface.verify import verifyObject
+ from repoze.kiss.proxy import IZReST
+ verifyObject(IZReST, self._makeOne())
+
+ def test_renderDiv(self):
+ RST = ('Title\n'
+ '=====\n'
+ '\n'
+ 'This is a paragraph.\n'
+ )
+ fszrst = self._makeOne(source=RST)
+ rendered = filter(None, fszrst.renderDiv().splitlines())
+
+ self.assertEqual(len(rendered), 4, rendered)
+ self.assertEqual(rendered[0], '<div class="document" id="title">')
+ self.assertEqual(rendered[1], '<h1 class="title">Title</h1>')
+ self.assertEqual(rendered[2], '<p>This is a paragraph.</p>')
+ self.assertEqual(rendered[3], '</div>')
+
+ def test___getitem___looks_in_parents_acquired_success(self):
+ container = self._makeContainer(foo='Foo')
+ fszrst = self._makeOne().__of__(container)
+
+ self.assertEquals(fszrst['foo'], 'Foo')
+
+ def test___getitem___looks_in_parents_acquired_nonesuch(self):
+ container = self._makeContainer(foo='Foo')
+ fszrst = self._makeOne().__of__(container)
+
+ self.assertRaises(KeyError, lambda: fszrst['nonesuch'])
+
+class FSStructuredTextTests(unittest.TestCase):
+
+ def _getTargetClass(self):
+ from repoze.kiss.proxy import FSStructuredText
+ return FSStructuredText
+
+ def _makeOne(self, name='test', source=None):
+ test = self._getTargetClass()(name)
+ if source is not None:
+ test.source = source
+ return test
+
+ def test_class_conformsToIStructuredText(self):
+ from zope.interface.verify import verifyClass
+ from repoze.kiss.proxy import IStructuredText
+ verifyClass(IStructuredText, self._getTargetClass())
+
+ def test_instance_conformsToIStructuredText(self):
+ from zope.interface.verify import verifyObject
+ from repoze.kiss.proxy import IStructuredText
+ verifyObject(IStructuredText, self._makeOne())
+
+
+class StructuredTextViewTests(unittest.TestCase):
+
+ def _getTargetClass(self):
+ from repoze.kiss.proxy import StructuredTextView
+ return StructuredTextView
+
+ def _makeOne(self, source=''):
+ class _Request:
+ pass
+ class _Context:
+ def __init__(self, source):
+ self.source = source
+ test = self._getTargetClass()(_Context(source), _Request())
+ return test
+
+ def test_render_empty(self):
+ view = self._makeOne()
+ rendered = filter(None, view.render().splitlines())
+ self.assertEqual(len(rendered), 4)
+ self.assertEqual(rendered[0], '<html>')
+ self.assertEqual(rendered[1], '<body>')
+ self.assertEqual(rendered[2], '</body>')
+ self.assertEqual(rendered[3], '</html>')
+
+
+class FSXSLTTransformTests(unittest.TestCase):
+
+ def _getTargetClass(self):
+ from repoze.kiss.proxy import FSXSLTTransform
+ return FSXSLTTransform
+
+ def _makeOne(self,
+ id='test',
+ instance_name='instance.xml',
+ xslt_name='template.xslt',
+ proxy=None,
+ ):
+ test = self._getTargetClass()(id, instance_name, xslt_name, proxy)
+ return test
+
+ def test_class_conformsToIXSLTTransform(self):
+ from zope.interface.verify import verifyClass
+ from repoze.kiss.proxy import IXSLTTransform
+ verifyClass(IXSLTTransform, self._getTargetClass())
+
+ def test_instance_conformsToIXSLTTransform(self):
+ from zope.interface.verify import verifyObject
+ from repoze.kiss.proxy import IXSLTTransform
+ verifyObject(IXSLTTransform, self._makeOne())
+
+
+class XSLTTransformViewTests(unittest.TestCase):
+
+ def _getTargetClass(self):
+ from repoze.kiss.proxy import XSLTTransformView
+ return XSLTTransformView
+
+ def _makeOne(self, instance_name, xslt_name):
+
+ class _Request:
+ pass
+
+ class _Context:
+ def __init__(self, instance_name, xslt_name, proxy):
+ self._instance_name = instance_name
+ self._xslt_name = xslt_name
+ self._proxy = proxy
+
+ class _Proxy:
+ def _getFQN(self, name):
+ return name
+
+ ctx = _Context(instance_name, xslt_name, _Proxy())
+ test = self._getTargetClass()(ctx, _Request())
+ return test
+
+ def test_render_simple(self):
+ from tempfile import NamedTemporaryFile
+ XML = '<?xml version="1.0"?><xml/>'
+ XSLT = ('<?xml version="1.0"?>'
+ '<xsl:stylesheet '
+ 'xmlns:xsl="http://www.w3.org/1999/XSL/Transform" '
+ 'version="1.0">'
+ '<xsl:template match="/">'
+ '<xsl:copy-of select="/*"/>'
+ '</xsl:template>'
+ '</xsl:stylesheet>'
+ )
+ xml = NamedTemporaryFile()
+ xml.write(XML)
+ xml.flush()
+
+ xslt = NamedTemporaryFile()
+ xslt.write(XSLT)
+ xslt.flush()
+
+ view = self._makeOne(xml.name, xslt.name)
+ rendered = filter(None, view.render().splitlines())
+ self.assertEqual(len(rendered), 2)
+ self.assertEqual(rendered[0], '<?xml version="1.0"?>')
+ self.assertEqual(rendered[1], '<xml/>')
+
+
+class ProxyTests(unittest.TestCase):
+
+ def setUp(self):
+ self._root = None
+
+ def tearDown(self):
+ if self._root is not None:
+ import shutil
+ shutil.rmtree(self._root)
+
+ def _getTargetClass(self):
+ from repoze.kiss.proxy import Proxy
+ return Proxy
+
+ def _makeOne(self, filesystem_path=None):
+ test = self._getTargetClass()(filesystem_path)
+ return test
+
+ def _makeRootDir(self):
+ if self._root is None:
+ from tempfile import mkdtemp
+ self._root = mkdtemp()
+ return self._root
+
+ def _makeSubdir(self, relpath):
+ import os
+ root = self._makeRootDir()
+ if not relpath:
+ return root
+ fqp = os.path.join(root, relpath)
+ if not os.path.isdir(fqp):
+ os.makedirs(fqp)
+ return fqp
+
+ def _makeFile(self, relpath, contents=''):
+ import os
+ root = self._makeRootDir()
+ path, fn = os.path.split(relpath)
+ if path:
+ fqp = os.path.join(root, path)
+ if not os.path.isdir(fqp):
+ os.makedirs(fqp)
+ f = open(os.path.join(root, relpath), 'wb')
+ f.write(contents)
+
+ def test_class_conformsToIXSLTTransform(self):
+ from zope.interface.verify import verifyClass
+ from repoze.kiss.proxy import IProxy
+ verifyClass(IProxy, self._getTargetClass())
+
+ def test_instance_conformsToIXSLTTransform(self):
+ from zope.interface.verify import verifyObject
+ from repoze.kiss.proxy import IProxy
+ verifyObject(IProxy, self._makeOne())
+
+ def test_acquired_at_root_raises_TypeError(self):
+ # Can't use ComputedAttribute with non-zero level; must acquire.
+ root = self._makeRootDir()
+ self._makeFile('foobar.txt', 'foobar')
+ proxy = self._makeOne(root)
+ self.assertRaises(TypeError, lambda: proxy.acquired['foobar.txt'])
+
+ def test_acquired_nonesuch_at_root_raises_KeyError(self):
+ root = self._makeRootDir()
+ proxy = self._makeOne(root)
+ sub = self._makeOne(self._makeSubdir('sub')).__of__(proxy)
+ self.assertRaises(KeyError, lambda: sub.acquired['foobar.txt'])
+
+ def test_acquired_success_at_root(self):
+ root = self._makeRootDir()
+ self._makeFile('foobar.txt', 'foobar')
+ proxy = self._makeOne(root)
+ sub = self._makeOne(self._makeSubdir('sub')).__of__(proxy)
+ f = sub.acquired['foobar.txt']
+ self.assertEqual(f.data, 'foobar')
+
+ def test_acquired_success_at_intermediate(self):
+ root = self._makeRootDir()
+ proxy = self._makeOne(root)
+ self._makeFile('foobar.txt', 'foobar')
+ sub = self._makeOne(self._makeSubdir('sub')).__of__(proxy)
+ self._makeFile('sub/foobar.txt', 'FOOBAR')
+ below = self._makeOne(self._makeSubdir('sub/below')).__of__(sub)
+ f = below.acquired['foobar.txt']
+ self.assertEqual(f.data, 'FOOBAR')
+
+ def test___getitem___nonesuch_raises_KeyError(self):
+ root = self._makeRootDir()
+ proxy = self._makeOne(root)
+ self.assertRaises(KeyError, lambda: proxy['foobar.txt'])
+
+ def test___getitem___prefers_cached(self):
+ from Acquisition import Implicit
+ class _Cached(Implicit):
+ pass
+ cached = _Cached()
+ root = self._makeRootDir()
+ self._makeFile('foobar.txt', 'foobar')
+ proxy = self._makeOne(root)
+ proxy._setCached('foobar.txt', cached)
+ self.failUnless(proxy['foobar.txt'].aq_self is cached)
+
+ def test___getitem___subdir_returns_Proxy(self):
+ root = self._makeRootDir()
+ proxy = self._makeOne(root)
+ self._makeSubdir('sub')
+ sub = proxy['sub']
+ self.failUnless(isinstance(sub, self._getTargetClass()))
+ self.failUnless(sub.aq_parent is proxy)
+
+ def test___getitem___html_present_returns_File(self):
+ from OFS.Image import File
+ root = self._makeRootDir()
+ proxy = self._makeOne(root)
+ self._makeFile('foobar.html', '<html/>')
+ foobar = proxy['foobar.html']
+ self.failUnless(isinstance(foobar, File))
+ self.assertEqual(foobar.data, '<html/>')
+
+ def test___getitem___html_falls_back_to_RST(self):
+ # First, check RST, then STX, then XML/XSLT
+ from repoze.kiss.proxy import FSZReST
+ root = self._makeRootDir()
+ proxy = self._makeOne(root)
+ self._makeFile('foobar.rst', 'abc')
+ self._makeFile('foobar.stx', '123')
+ foobar = proxy['foobar.html']
+ self.failUnless(isinstance(foobar, FSZReST))
+ self.assertEqual(foobar.source, 'abc')
+
+ def test___getitem___html_falls_back_to_STX(self):
+ # First, check RST, then STX, then XML/XSLT
+ from repoze.kiss.proxy import FSStructuredText
+ root = self._makeRootDir()
+ proxy = self._makeOne(root)
+ self._makeFile('foobar.stx', 'abc')
+ self._makeFile('foobar.xml', '123')
+ foobar = proxy['foobar.html']
+ self.failUnless(isinstance(foobar, FSStructuredText))
+ self.assertEqual(foobar.source, 'abc')
+
+ def test___getitem___html_falls_back_to_XML(self):
+ # First, check RST, then STX, then XML/XSLT
+ from repoze.kiss.proxy import FSXSLTTransform
+ root = self._makeRootDir()
+ proxy = self._makeOne(root)
+ self._makeFile('foobar.xml', '123')
+ foobar = proxy['foobar.html']
+ self.failUnless(isinstance(foobar, FSXSLTTransform))
+ self.assertEqual(foobar._instance_name, 'foobar.xml')
+
+ def test___getitem___rst_returns_RST(self):
+ from repoze.kiss.proxy import FSZReST
+ root = self._makeRootDir()
+ proxy = self._makeOne(root)
+ self._makeFile('foobar.rst', 'abc')
+ foobar = proxy['foobar.rst']
+ self.failUnless(isinstance(foobar, FSZReST))
+ self.assertEqual(foobar.source, 'abc')
+
+ def test___getitem___stx_returns_STX(self):
+ from repoze.kiss.proxy import FSStructuredText
+ root = self._makeRootDir()
+ proxy = self._makeOne(root)
+ self._makeFile('foobar.stx', 'abc')
+ foobar = proxy['foobar.stx']
+ self.failUnless(isinstance(foobar, FSStructuredText))
+ self.assertEqual(foobar.source, 'abc')
+
+ def test___getitem___xml_returns_XSLT_transform(self):
+ from repoze.kiss.proxy import FSXSLTTransform
+ root = self._makeRootDir()
+ proxy = self._makeOne(root)
+ self._makeFile('foobar.xml', '123')
+ foobar = proxy['foobar.xml']
+ self.failUnless(isinstance(foobar, FSXSLTTransform))
+ self.assertEqual(foobar._instance_name, 'foobar.xml')
+
+ def test___getitem___pt_returns_ZPT(self):
+ from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
+ root = self._makeRootDir()
+ proxy = self._makeOne(root)
+ self._makeFile('foobar.pt', '<html/>')
+ foobar = proxy['foobar.pt']
+ self.failUnless(isinstance(foobar, ZopePageTemplate))
+ self.assertEqual(foobar._text, '<html/>')
+
+ def test___getitem___zpt_returns_ZPT(self):
+ from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
+ root = self._makeRootDir()
+ proxy = self._makeOne(root)
+ self._makeFile('foobar.zpt', '<html/>')
+ foobar = proxy['foobar.zpt']
+ self.failUnless(isinstance(foobar, ZopePageTemplate))
+ self.assertEqual(foobar._text, '<html/>')
+
+ def test___getitem___jpeg_returns_Image(self):
+ from OFS.Image import Image
+ root = self._makeRootDir()
+ proxy = self._makeOne(root)
+ self._makeFile('foobar.jpeg')
+ foobar = proxy['foobar.jpeg']
+ self.failUnless(isinstance(foobar, Image))
+ self.assertEqual(foobar.data, '')
+
+ def test___getitem___jpg_returns_Image(self):
+ from OFS.Image import Image
+ root = self._makeRootDir()
+ proxy = self._makeOne(root)
+ self._makeFile('foobar.jpg')
+ foobar = proxy['foobar.jpg']
+ self.failUnless(isinstance(foobar, Image))
+ self.assertEqual(foobar.data, '')
+
+ def test___getitem___gif_returns_Image(self):
+ from OFS.Image import Image
+ root = self._makeRootDir()
+ proxy = self._makeOne(root)
+ self._makeFile('foobar.gif')
+ foobar = proxy['foobar.gif']
+ self.failUnless(isinstance(foobar, Image))
+ self.assertEqual(foobar.data, '')
+
+ def test___getitem___png_returns_Image(self):
+ from OFS.Image import Image
+ root = self._makeRootDir()
+ proxy = self._makeOne(root)
+ self._makeFile('foobar.png')
+ foobar = proxy['foobar.png']
+ self.failUnless(isinstance(foobar, Image))
+ self.assertEqual(foobar.data, '')
+
+ def test___getitem___ico_returns_Image(self):
+ from OFS.Image import Image
+ root = self._makeRootDir()
+ proxy = self._makeOne(root)
+ self._makeFile('foobar.ico')
+ foobar = proxy['foobar.ico']
+ self.failUnless(isinstance(foobar, Image))
+ self.assertEqual(foobar.data, '')
+
+ def test___getitem___other_returns_File(self):
+ from OFS.Image import File
+ root = self._makeRootDir()
+ proxy = self._makeOne(root)
+ self._makeFile('foobar.baz')
+ foobar = proxy['foobar.baz']
+ self.failUnless(isinstance(foobar, File))
+ self.assertEqual(foobar.data, '')
+
+class ProxyViewTests(unittest.TestCase):
+
+ def _getTargetClass(self):
+ from repoze.kiss.proxy import ProxyView
+ return ProxyView
+
+ def _makeContext(self, url):
+
+ class _Context:
+ pass
+
+ ctx = _Context()
+ ctx.absolute_url = lambda: url
+ return ctx
+
+ def _makeRequest(self):
+
+ class _Response:
+ _redirected = None
+ def redirect(self, url):
+ self._redirected = url
+
+ response = _Response()
+ return {'RESPONSE': response}, response
+
+ def test_redirect(self):
+ _URL = 'http://example.com/folder'
+ context = self._makeContext(_URL)
+ request, response = self._makeRequest()
+ view = self._getTargetClass()(context, request)
+
+ view.redirect()
+
+ self.assertEqual(response._redirected, '%s/index.html' % _URL)
More information about the Repoze-checkins
mailing list