class PrepareIDNNameTests(unittest.TestCase): """ Tests for L{wokkel.generic.prepareIDNName}. """ suppress = [ SUPPRESS(category=DeprecationWarning, message=re.escape( deprecate.getDeprecationWarningString( generic.prepareIDNName, Version("wokkel", 18, 0, 0), replacement="unicode.encode('idna')"))) ] def test_deprecated(self): """ prepareIDNName is deprecated. """ self.callDeprecated( (Version("wokkel", 18, 0, 0), "unicode.encode('idna')"), generic.prepareIDNName, ("example.com")) test_deprecated.suppress = [] def test_unicode(self): """ A unicode all-ASCII name is converted to an ASCII byte string. """ name = u"example.com" result = generic.prepareIDNName(name) self.assertEqual(b"example.com", result) def test_unicodeNonASCII(self): """ A unicode with non-ASCII is converted to its ACE equivalent. """ name = u"\u00e9chec.example.com" result = generic.prepareIDNName(name) self.assertEqual(b"xn--chec-9oa.example.com", result) def test_unicodeHalfwidthIdeographicFullStop(self): """ Exotic dots in unicode names are converted to Full Stop. """ name = u"\u00e9chec.example\uff61com" result = generic.prepareIDNName(name) self.assertEqual(b"xn--chec-9oa.example.com", result) def test_unicodeTrailingDot(self): """ Unicode names with trailing dots retain the trailing dot. L{encodings.idna.ToASCII} doesn't allow the empty string as the input, hence the implementation needs to strip a trailing dot, and re-add it after encoding the labels. """ name = u"example.com." result = generic.prepareIDNName(name) self.assertEqual(b"example.com.", result)
def deprecatedDeferredGenerator(f): """ Calls L{deferredGenerator} while suppressing the deprecation warning. @param f: Function to call @return: Return value of function. """ return runWithWarningsSuppressed([ SUPPRESS(message="twisted.internet.defer.deferredGenerator was " "deprecated") ], deferredGenerator, f)
class PublicNavAthenaLivePageTestCase(_PublicAthenaLivePageTestMixin, TestCase): """ Tests for L{PublicNavAthenaLivePage}. """ suppress = [SUPPRESS(category=DeprecationWarning)] def createPage(self, forUser): return PublicNavAthenaLivePage(self.siteStore, TestFragment(), forUser=forUser)
class LoopbackTestCase(LoopbackTestCaseMixin, unittest.TestCase): loopbackFunc = staticmethod(loopback.loopback) def testRegularFunction(self): """ Suppress loopback deprecation warning. """ return LoopbackTestCaseMixin.testRegularFunction(self) testRegularFunction.suppress = [ SUPPRESS(message="loopback\(\) is deprecated", category=DeprecationWarning)]
def _getDeprecationSuppression(f): """ Returns a tuple of arguments needed to suppress deprecation warnings from a specified function. @param f: function to suppress dperecation warnings for @type f: L{callable} @return: tuple to add to C{suppress} attribute """ return SUPPRESS(category=DeprecationWarning, message='%s was deprecated' % (fullyQualifiedName(f), ))
class DeprecationTests(TestCase): """ Tests for deprecations in C{twisted.python.util}. """ def test_getPluginDirs(self): """ L{util.getPluginDirs} is deprecated. """ util.getPluginDirs() currentWarnings = self.flushWarnings( offendingFunctions=[self.test_getPluginDirs] ) self.assertEqual( currentWarnings[0]["message"], "twisted.python.util.getPluginDirs is deprecated since Twisted " "12.2.", ) self.assertEqual(currentWarnings[0]["category"], DeprecationWarning) self.assertEqual(len(currentWarnings), 1) def test_addPluginDir(self): """ L{util.addPluginDir} is deprecated. """ util.addPluginDir() currentWarnings = self.flushWarnings( offendingFunctions=[self.test_addPluginDir] ) self.assertEqual( currentWarnings[0]["message"], "twisted.python.util.addPluginDir is deprecated since Twisted " "12.2.", ) self.assertEqual(currentWarnings[0]["category"], DeprecationWarning) self.assertEqual(len(currentWarnings), 1) test_addPluginDir.suppress = [ # type: ignore[attr-defined] SUPPRESS( category=DeprecationWarning, message="twisted.python.util.getPluginDirs is deprecated", ) ]
class DeprecationTests(unittest.TestCase): """ Tests for deprecations in C{twisted.python.util}. """ def test_getPluginDirs(self): """ L{util.getPluginDirs} is deprecated. """ util.getPluginDirs() currentWarnings = self.flushWarnings( offendingFunctions=[self.test_getPluginDirs]) self.assertEqual( currentWarnings[0]['message'], "twisted.python.util.getPluginDirs is deprecated since Twisted " "12.2.") self.assertEqual(currentWarnings[0]['category'], DeprecationWarning) self.assertEqual(len(currentWarnings), 1) def test_addPluginDir(self): """ L{util.addPluginDir} is deprecated. """ util.addPluginDir() currentWarnings = self.flushWarnings( offendingFunctions=[self.test_addPluginDir]) self.assertEqual( currentWarnings[0]['message'], "twisted.python.util.addPluginDir is deprecated since Twisted " "12.2.") self.assertEqual(currentWarnings[0]['category'], DeprecationWarning) self.assertEqual(len(currentWarnings), 1) test_addPluginDir.suppress = [ SUPPRESS(category=DeprecationWarning, message="twisted.python.util.getPluginDirs is deprecated") ]
from twisted.web.error import (FlattenerError, MissingTemplateLoader, MissingRenderMethod) from twisted.web.template import renderElement from twisted.web._element import UnexposedMethodError from twisted.web.test._util import FlattenTestCase from twisted.web.test.test_web import DummyRequest from twisted.web.server import NOT_DONE_YET from twisted.python.compat import NativeStringIO as StringIO from twisted.logger import globalLogPublisher from twisted.test.proto_helpers import EventLoggingObserver _xmlFileSuppress = SUPPRESS(category=DeprecationWarning, message="Passing filenames or file objects to XMLFile is " "deprecated since Twisted 12.1. Pass a FilePath instead.") class TagFactoryTests(TestCase): """ Tests for L{_TagFactory} through the publicly-exposed L{tags} object. """ def test_lookupTag(self): """ HTML tags can be retrieved through C{tags}. """ tag = tags.a self.assertEqual(tag.tagName, "a")
class DeferredGeneratorTests(BaseDefgenTests, unittest.TestCase): # First provide all the generator impls necessary for BaseDefgenTests @deprecatedDeferredGenerator def _genBasics(self): x = waitForDeferred(getThing()) yield x x = x.getResult() self.assertEqual(x, "hi") ow = waitForDeferred(getOwie()) yield ow try: ow.getResult() except ZeroDivisionError as e: self.assertEqual(str(e), "OMG") yield "WOOSH" return @deprecatedDeferredGenerator def _genBuggy(self): yield waitForDeferred(getThing()) 1 // 0 @deprecatedDeferredGenerator def _genNothing(self): if False: yield 1 # type: ignore[unreachable] @deprecatedDeferredGenerator def _genHandledTerminalFailure(self): x = waitForDeferred( defer.fail(TerminalException("Handled Terminal Failure"))) yield x try: x.getResult() except TerminalException: pass @deprecatedDeferredGenerator def _genHandledTerminalAsyncFailure(self, d): x = waitForDeferred(d) yield x try: x.getResult() except TerminalException: pass def _genStackUsage(self): for x in range(5000): # Test with yielding a deferred x = waitForDeferred(defer.succeed(1)) yield x x = x.getResult() yield 0 _genStackUsage = deprecatedDeferredGenerator(_genStackUsage) def _genStackUsage2(self): for x in range(5000): # Test with yielding a random value yield 1 yield 0 _genStackUsage2 = deprecatedDeferredGenerator(_genStackUsage2) # Tests unique to deferredGenerator def testDeferredYielding(self): """ Ensure that yielding a Deferred directly is trapped as an error. """ # See the comment _deferGenerator about d.callback(Deferred). def _genDeferred(): yield getThing() _genDeferred = deprecatedDeferredGenerator(_genDeferred) return self.assertFailure(_genDeferred(), TypeError) suppress = [ SUPPRESS(message="twisted.internet.defer.waitForDeferred was " "deprecated") ]
class DeferredTests(unittest.TestCase): touched = False def _cb_fail(self, reason): self.fail(reason) def _cb_error(self, reason): raise RuntimeError(reason) def _cb_skip(self, reason): raise unittest.SkipTest(reason) def _touchClass(self, ignored): self.__class__.touched = True def setUp(self): self.__class__.touched = False def test_pass(self): return defer.succeed('success') def test_passGenerated(self): self._touchClass(None) yield None test_passGenerated = runWithWarningsSuppressed( [ SUPPRESS(message="twisted.internet.defer.deferredGenerator was " "deprecated") ], defer.deferredGenerator, test_passGenerated) @defer.inlineCallbacks def test_passInlineCallbacks(self): """ Test case that is decorated with L{defer.inlineCallbacks}. """ self._touchClass(None) yield None def test_fail(self): return defer.fail(self.failureException('I fail')) def test_failureInCallback(self): d = defer.succeed('fail') d.addCallback(self._cb_fail) return d def test_errorInCallback(self): d = defer.succeed('error') d.addCallback(self._cb_error) return d def test_skip(self): d = defer.succeed('skip') d.addCallback(self._cb_skip) d.addCallback(self._touchClass) return d def test_thread(self): return threads.deferToThread(lambda : None) def test_expectedFailure(self): d = defer.succeed('todo') d.addCallback(self._cb_error) return d test_expectedFailure.todo = "Expected failure"
from axiom.dependency import installOn from axiom.test.util import QueryCounter from xmantissa.webapp import PrivateApplication from xmantissa.ixmantissa import IWebTranslator, IColumn from xmantissa.error import Unsortable from xmantissa.scrolltable import (InequalityModel, ScrollableView, ScrollingFragment, ScrollingElement, SequenceScrollingFragment, StoreIDSequenceScrollingFragment, AttributeColumn, UnsortableColumnWrapper, UnsortableColumn) _unsortableColumnSuppression = SUPPRESS(message=escape( "Use UnsortableColumnWrapper(AttributeColumn(*a, **kw)) " "instead of UnsortableColumn(*a, **kw)."), category=DeprecationWarning) class DataThunk(Item): a = integer() b = integer() c = text() class DataThunkWithIndex(Item): """ Another testing utility, similar to L{DataThunk}, but with an indexed attribute, so that sorting complexity is independent of the number of instances which exist, so that performance testing can be done. """
class TestPage(unittest.TestCase): def test_simple(self): xhtml = '<ul id="nav"><li>one</li><li>two</li><li>three</li></ul>' r = rend.Page(docFactory=loaders.htmlstr(xhtml)) return deferredRender(r).addCallback( lambda result: self.assertEqual(result, xhtml)) test_simple.suppress = [ SUPPRESS(message=r"\[v0.8\] htmlstr is deprecated because it's buggy. " "Please start using xmlfile and/or xmlstr.") ] def test_extend(self): xhtml = '<ul id="nav"><li>one</li><li>two</li><li>three</li></ul>' class R(rend.Page): docFactory = loaders.htmlstr(xhtml) r = R() return deferredRender(r).addCallback( lambda result: self.assertEqual(result, xhtml)) test_extend.suppress = [ SUPPRESS(message=r"\[v0.8\] htmlstr is deprecated because it's buggy. " "Please start using xmlfile and/or xmlstr.") ] def test_data(self): xhtml = ('<ul id="nav" nevow:data="numbers" nevow:render="sequence">' '<li nevow:pattern="item" nevow:render="string">number</li>' '</ul>') class R(rend.Page): docFactory = loaders.htmlstr(xhtml) def data_numbers(self, context, data): return ['one', 'two', 'three'] r = R() return deferredRender(r).addCallback(lambda result: self.assertEqual( result, '<ul id="nav"><li>one</li><li>two</li><li>three</li></ul>') ) test_data.suppress = [ SUPPRESS(message=r"\[v0.8\] htmlstr is deprecated because it's buggy. " "Please start using xmlfile and/or xmlstr.") ] def test_noData(self): """Test when data is missing, i.e. self.original is None and no data directives had been used""" class R(rend.Page): docFactory = loaders.htmlstr('<p nevow:render="foo"></p>') def render_foo(self, ctx, data): return ctx.tag.clear()[data] r = R() return deferredRender(r).addCallback( lambda result: self.assertIn('None', result)) test_noData.suppress = [ SUPPRESS(message=r"\[v0.8\] htmlstr is deprecated because it's buggy. " "Please start using xmlfile and/or xmlstr.") ] def test_render(self): xhtml = '<span nevow:render="replace">replace this</span>' class R(rend.Page): docFactory = loaders.htmlstr(xhtml) def render_replace(self, context, data): return context.tag.clear()['abc'] r = R() return deferredRender(r).addCallback( lambda result: self.assertEqual(result, '<span>abc</span>')) test_render.suppress = [ SUPPRESS(message=r"\[v0.8\] htmlstr is deprecated because it's buggy. " "Please start using xmlfile and/or xmlstr.") ] def test_dataAndRender(self): xhtml = ''' <table nevow:data="numbers" nevow:render="sequence"> <tr nevow:pattern="header"><th>English</th><th>French</th></tr> <tr nevow:pattern="item" nevow:render="row"><td><nevow:slot name="english"/></td><td><nevow:slot name="french"/></td></tr> </table> ''' class R(rend.Page): docFactory = loaders.htmlstr(xhtml) def data_numbers(self, context, data): return [ ['one', 'un/une'], ['two', 'deux'], ['three', 'trois'], ] def render_row(self, context, data): context.fillSlots('english', data[0]) context.fillSlots('french', data[1]) return context.tag r = R() d = deferredRender(r) d.addCallback(lambda result: self.assertEqual( result, '<table>' '<tr><th>English</th><th>French</th></tr>' '<tr><td>one</td><td>un/une</td></tr>' '<tr><td>two</td><td>deux</td></tr>' '<tr><td>three</td><td>trois</td></tr>' '</table>')) test_dataAndRender.suppress = [ SUPPRESS(message=r"\[v0.8\] htmlstr is deprecated because it's buggy. " "Please start using xmlfile and/or xmlstr.") ] def test_stanData(self): class R(rend.Page): def data_numbers(context, data): return ['one', 'two', 'three'] tags = ul(data=data_numbers, render=directive('sequence'))[li( pattern='item')[span(render=str)]] docFactory = loaders.stan(tags) r = R() return deferredRender(r).addCallback(lambda result: self.assertEqual( result, '<ul><li>one</li><li>two</li><li>three</li></ul>')) def test_stanRender(self): class R(rend.Page): def render_replace(context, data): return context.tag.clear()['abc'] tags = span(render=render_replace)['replace this'] docFactory = loaders.stan(tags) r = R() return deferredRender(r).addCallback( lambda result: self.assertEqual(result, '<span>abc</span>')) def test_stanDataAndRender(self): class R(rend.Page): def data_numbers(context, data): return [ ['one', 'un/une'], ['two', 'deux'], ['three', 'trois'], ] def render_row(context, data): context.fillSlots('english', data[0]) context.fillSlots('french', data[1]) return context.tag tags = table(data=data_numbers, render=directive('sequence'))[ tr(pattern='header')[th['English'], th['French']], tr(pattern='item', render=render_row)[td[slot('english')], td[slot('french')]], ] docFactory = loaders.stan(tags) r = R() return deferredRender(r).addCallback(lambda result: self.assertEqual( result, '<table><tr><th>English</th><th>French</th></tr><tr><td>one</td><td>un/une</td></tr><tr><td>two</td><td>deux</td></tr><tr><td>three</td><td>trois</td></tr></table>' )) def test_composite(self): class R(rend.Page): def render_inner(self, context, data): return rend.Page(docFactory=loaders.stan(div(id='inner'))) docFactory = loaders.stan( div(id='outer')[span(render=render_inner)]) r = R() return deferredRender(r).addCallback(lambda result: self.assertEqual( result, '<div id="outer"><div id="inner"></div></div>')) def _testDocFactoryInStanTree(self, docFactory, expected): class Page(rend.Page): docFactory = loaders.stan( div[invisible(render=directive('included'))]) def __init__(self, included): self.included = included rend.Page.__init__(self) def render_included(self, context, data): return self.included return deferredRender(Page(docFactory)).addCallback( self.assertEqual, '<div>' + expected + '</div>') def test_stanInStanTree(self): """ """ return self._testDocFactoryInStanTree(loaders.stan(p['fee']), '<p>fee</p>') def test_htmlStringInStanTree(self): """ Test that an htmlstr loader in a stan document is flattened by having its document loaded and flattened. """ return self._testDocFactoryInStanTree(loaders.htmlstr('<p>fi</p>'), '<p>fi</p>') test_htmlStringInStanTree.suppress = [ SUPPRESS(message=r"\[v0.8\] htmlstr is deprecated because it's buggy. " "Please start using xmlfile and/or xmlstr.") ] def test_xmlStringInStanTree(self): """ Like L{test_htmlStringInStanTree}, but for an xmlstr loader. """ return self._testDocFactoryInStanTree(loaders.xmlstr('<p>fo</p>'), '<p>fo</p>') def test_htmlFileInStanTree(self): """ Like L{test_htmlStringInStanTree}, but for an htmlfile loader. """ doc = '<p>fum</p>' temp = self.mktemp() f = file(temp, 'w') f.write(doc) f.close() return self._testDocFactoryInStanTree(loaders.htmlfile(temp), '<p>fum</p>') test_htmlFileInStanTree.suppress = [ SUPPRESS( message=r"\[v0.8\] htmlfile is deprecated because it's buggy. " "Please start using xmlfile and/or xmlstr.") ] def test_xmlFileInStanTree(self): """ Like L{test_htmlStringInStanTree}, but for an xmlfile loader. """ doc = '<p>I</p>' temp = self.mktemp() f = file(temp, 'w') f.write(doc) f.close() return self._testDocFactoryInStanTree(loaders.xmlfile(temp), '<p>I</p>') def test_reusedDocFactory(self): """ Test that a docFactory which is used more than once behaves properly both times. """ class Page(rend.Page): docFactory = loaders.stan( div[invisible(render=directive('included'))]) def __init__(self, included): self.included = included rend.Page.__init__(self) def render_included(self, context, data): return self.included p1 = Page(loaders.stan('first')) p2 = Page(loaders.xmlstr('<p>second</p>')) d = deferredRender(p1) def rendered(result): self.assertEqual(result, '<div>first</div>') return deferredRender(p2) d.addCallback(rendered) def renderedAgain(result): self.assertEqual(result, '<div><p>second</p></div>') d.addCallback(renderedAgain) return d def test_buffered(self): class Page(rend.Page): buffered = True docFactory = loaders.stan(html[head[title['test']]]) p = Page() return deferredRender(p).addCallback(lambda result: self.assertEqual( result, '<html><head><title>test</title></head></html>')) def test_component(self): """ Test that the data is remembered correctly when a Page is embedded in a component-like manner. """ class Data: foo = 'foo' bar = 'bar' class Component(rend.Fragment): def render_foo(self, context, data): return strong[data.foo] def render_bar(self, context, data): return data.bar docFactory = loaders.stan(p[render_foo, ' ', render_bar]) class Page(rend.Page): docFactory = loaders.stan(div[Component(Data())]) page = Page() return deferredRender(page).addCallback( lambda result: self.assertEqual( result, '<div><p><strong>foo</strong> bar</p></div>')) def test_fragmentContext(self): # A fragment is remembered as the IRendererFactory. It must create a new context # to avoid messing up the page's context. class Fragment(rend.Fragment): docFactory = loaders.stan(p(render=directive('foo'))) def render_foo(self, ctx, data): return 'foo' class Page(rend.Page): docFactory = loaders.stan( html(render=directive("template"))[body[ p(render=directive("before")), p[slot(name="maincontent")], p(render=directive("after")), ], ]) def render_before(self, context, data): return context.tag["before"] def render_template(self, context, data): context.fillSlots('maincontent', Fragment()) return context.tag def render_after(self, context, data): return context.tag["after"] result = Page().renderSynchronously() # print result self.assertFalse("'foo' was not found" in result) self.assertFalse("'after' was not found" in result) def test_rendererNotFound(self): """ An unparameterized renderer which is not defined should render a message about the renderer not being defined. Wanted behaviour: missing renderers etc. raise an exception, with some helpful hints on where to locate the typo. Feel free to replace test_rendererNotFound{,Parametrized} with unit tests for the exception raising behaviour, if you do implement it. """ class Page(rend.Page): docFactory = loaders.stan(html(render=directive("notfound"))) page = Page() result = page.renderSynchronously() self.assertEqual( result, "<html>The renderer named 'notfound' was not found in %s.</html>" % util.escapeToXML(repr(page))) test_rendererNotFound.suppress = [ SUPPRESS( category=DeprecationWarning, message=("Renderer 'notfound' missing on nevow.test.test_rend.Page" " will result in an exception.")) ] def test_rendererNotFoundParameterized(self): """ A parameterized renderer which is not defined should render a message about the renderer not being defined. """ class Page(rend.Page): docFactory = loaders.stan(html(render=directive("notfound dummy"))) page = Page() result = page.renderSynchronously() self.assertEqual( result, "<html>The renderer named 'notfound' was not found in %s.</html>" % util.escapeToXML(repr(page))) test_rendererNotFoundParameterized.suppress = [ SUPPRESS( category=DeprecationWarning, message=("Renderer 'notfound' missing on nevow.test.test_rend.Page" " will result in an exception.")) ] def test_missingRendererDeprecated(self): """ Using a renderer which is not defined should emit a deprecation warning. """ rendererName = "notfound" class MisdefinedPage(rend.Page): docFactory = loaders.stan(html(render=directive(rendererName))) page = MisdefinedPage() message = "Renderer %r missing on %s will result in an exception." message %= (rendererName, qual(MisdefinedPage)) self.assertWarns(DeprecationWarning, message, rend.__file__, page.renderSynchronously) if getattr(unittest.TestCase, 'assertWarns', None) is None: test_missingRendererDeprecated.skip = "TestCase.assertWarns missing" def test_addSlash(self): """ Accessing a resource that has addSlash set via a path without a trailing slash generates a redirect. """ class RootPage(rend.Page): def child_child(self, ctx): return SlashyPage() class SlashyPage(rend.Page): addSlash = True docFactory = loaders.stan(div(id='inner')) root = RootPage() r = self.successResultOf(getResource(root, b'/child')) r.tag.renderHTTP(r) req = inevow.IRequest(r) self.assertTrue(req.redirected_to.endswith(b'/'))