def testConstructionTypeError(self): """ Test type error for reader/renderer arguments. """ # Content with self.assertRaises(exceptions.MooseDocsException) as e: Translator(None, 'foo', HTMLRenderer(), []) self.assertIn("The argument 'content' must be", e.exception.message) # Reader content = page.PageNodeBase(None) with self.assertRaises(exceptions.MooseDocsException) as e: Translator(content, 'foo', HTMLRenderer(), []) self.assertIn("The argument 'reader' must be", e.exception.message) # Renderer with self.assertRaises(exceptions.MooseDocsException) as e: Translator(content, MarkdownReader(), 'foo', []) self.assertIn("The argument 'renderer' must be", e.exception.message) # Extensions with self.assertRaises(exceptions.MooseDocsException) as e: Translator(content, MarkdownReader(), HTMLRenderer(), ['foo']) self.assertIn("The argument 'extensions' must be", e.exception.message)
def testTokenizeException(self): root = tokens.Token(None) content = page.PageNodeBase(None) reader = readers.Reader(lexers.RecursiveLexer('foo')) translator = Translator(content, reader, HTMLRenderer(), []) translator.init('') reader.add('foo', WordComponent()) reader.parse(root, u'throw bar') self.assertIsInstance(root(0), tokens.ExceptionToken) self.assertIsInstance(root(1), tokens.Word) self.assertEqual(root(1).content, u'bar')
def testReinit(self): ast = tokens.Paragraph(None) comp = ParComponent() content = page.PageNodeBase(None) renderer = renderers.HTMLRenderer() translator = Translator(content, MarkdownReader(), renderer, []) translator.init('') renderer.add(tokens.Paragraph, comp) renderer.render(ast) renderer.render(ast) self.assertEqual(comp.count, 2)
def testBasic(self): root = tokens.Token(None) content = page.PageNodeBase(None) reader = readers.Reader(lexers.RecursiveLexer('block', 'inline')) translator = Translator(content, reader, HTMLRenderer(), []) translator.init('') reader.add('block', BlockComponent()) reader.add('inline', WordComponent()) reader.parse(root, u'foo bar') self.assertIsInstance(root(0), tokens.Token) self.assertIsInstance(root(0)(0), tokens.Word) self.assertEqual(root(0)(0).content, u'foo') self.assertIsInstance(root(0)(1), tokens.Word) self.assertEqual(root(0)(1).content, u'bar')
def test(self): comp = RenderComponent() renderer = Renderer() content = page.PageNodeBase(None) t = Translator(content, Reader(RecursiveLexer('foo')), renderer, []) comp.init(t) self.assertEqual(comp.renderer, renderer)
def testConstruction(self): """ Test most basic construction. """ content = page.PageNodeBase(None) translator = Translator(content, MarkdownReader(), HTMLRenderer(), []) self.assertIsInstance(translator.reader, MarkdownReader) self.assertIsInstance(translator.renderer, HTMLRenderer)
def testExtend(self): """ Test the extend method. """ class ExtTester(Extension): """Dummy extension for testing.""" def __init__(self, *args, **kwargs): Extension.__init__(self, *args, **kwargs) self.called = False def extend(self, reader, renderer): self.called = True ext = ExtTester() self.assertFalse(ext.called) content = pages.Page('foo', source='foo') t = Translator([content], Reader(RecursiveLexer('foo')), Renderer(), [ext]) t.init() self.assertTrue(ext.called)
def testRender(self): ast = tokens.Paragraph(None) tokens.String(ast, content=u'foo') content = page.PageNodeBase(None) renderer = renderers.HTMLRenderer() translator = Translator(content, MarkdownReader(), renderer, []) translator.init('') renderer.add(tokens.Paragraph, ParComponent()) renderer.add(tokens.String, StringComponent()) root = renderer.render(ast) self.assertIsInstance(root, html.Tag) self.assertEqual(root.name, 'body') self.assertIsInstance(root(0), html.Tag) self.assertEqual(root(0).name, 'p') self.assertIsInstance(root(0)(0), html.String) self.assertEqual(root(0)(0).content, u'foo')
def testExtend(self): """ Test the extend method. """ class ExtTester(Extension): """Dummy extension for testing.""" def __init__(self, *args, **kwargs): Extension.__init__(self, *args, **kwargs) self.called = False def extend(self, reader, renderer): self.called = True ext = ExtTester() self.assertFalse(ext.called) content = page.PageNodeBase(None) t = Translator(content, Reader(RecursiveLexer('foo')), Renderer(), [ext]) t.init('') self.assertTrue(ext.called) self.assertIs(ext.translator, t)
def testBasic(self): """ Test correct use. """ t = Translator(page.PageNodeBase(None), MarkdownReader(), HTMLRenderer(), []) obj = mixins.TranslatorObject() self.assertFalse(obj.initialized()) obj.init(t) self.assertTrue(obj.initialized()) self.assertIs(obj.translator, t)
def testExceptions(self): """ Test Exceptions. """ t = Translator(page.PageNodeBase(None), MarkdownReader(), HTMLRenderer(), []) obj = mixins.TranslatorObject() with self.assertRaises(exceptions.MooseDocsException) as e: obj.init('') self.assertIn("The argument 'translator'", e.exception.message) with self.assertRaises(exceptions.MooseDocsException) as e: obj.translator self.assertIn("The init() method of", e.exception.message) obj.init(t) with self.assertRaises(exceptions.MooseDocsException) as e: obj.init(t) self.assertIn("already been initialized", e.exception.message)
def testDefault(self): """ Test basic construction and errors. """ comp = TokenComponent() reader = Reader(RecursiveLexer('foo')) content = page.PageNodeBase(None) t = Translator(content, reader, Renderer(), []) comp.init(t) self.assertIsNone(comp.settings) self.assertIs(comp.reader, reader) self.assertEqual(comp.attributes, dict()) defaults = comp.defaultSettings() for key in ['id', 'class', 'style']: self.assertIn(key, defaults) self.assertIsInstance(defaults[key], tuple) self.assertEqual(len(defaults[key]), 2) self.assertEqual(defaults[key][0], u'') self.assertIsInstance(defaults[key][1], unicode)
def testExceptions(self): """ Test that exceptions are raised. """ comp = TokenComponent() reader = Reader(RecursiveLexer('foo')) content = page.PageNodeBase(None) t = Translator(content, reader, Renderer(), []) comp.init(t) with self.assertRaises(NotImplementedError): comp.createToken([], []) # Test defaultSettings return type check class TestToken(TokenComponent): @staticmethod def defaultSettings(): pass with self.assertRaises(exceptions.MooseDocsException) as e: TestToken() self.assertIn("must return a dict", e.exception.message)
def test(self): """ Test basic construction and errors. """ comp = Component() with self.assertRaises(exceptions.MooseDocsException) as e: comp.translator self.assertIn("The init() method of", e.exception.message) with self.assertRaises(exceptions.MooseDocsException) as e: comp.init(42) self.assertIn("The argument 'translator' must be of type", e.exception.message) content = page.PageNodeBase(None) t = Translator(content, Reader(RecursiveLexer('foo')), Renderer(), []) comp.init(t) with self.assertRaises(exceptions.MooseDocsException) as e: comp.init(t) self.assertIn("already been", e.exception.message) self.assertIs(comp.translator, t)