def test_render_latex_raises_not_implemented(self):
# The BaseLayout does not specify how to render the LaTeX.
layout = BaseLayout(self.create_dummy(), self.create_dummy(),
self.builder)
with self.assertRaises(NotImplementedError):
layout.render_latex('latex')
def test_get_builder_returns_builder(self):
context = self.create_dummy()
request = self.create_dummy()
builder = self.create_dummy()
layout = BaseLayout(context, request, builder)
self.assertEqual(layout.get_builder(), builder)
def test_use_babel_with_particular_option(self):
layout = BaseLayout(self.create_dummy(), self.create_dummy(),
self.builder)
self.assertEqual(layout.get_packages_latex(), '')
layout.use_babel('british')
self.assertEqual(layout.get_packages_latex(),
'\\usepackage[british]{babel}\n')
def test_use_babel_with_multiple_languages(self):
layout = BaseLayout(self.create_dummy(), self.create_dummy(),
self.builder)
self.assertEqual(layout.get_packages_latex(), '')
layout.use_babel(['british', 'french', 'latin'])
self.assertEqual(layout.get_packages_latex(),
'\\usepackage[latin, french, british]{babel}\n')
def setUp(self):
super(TestInjectionAwareConvertObject, self).setUp()
context = self.create_dummy()
request = self.providing_stub(IWithinBookLayer)
builder = self.providing_stub(IBuilder)
self.layout = BaseLayout(context, request, builder)
def test_get_converter_keeps_instance(self):
context = self.create_dummy()
request = self.create_dummy()
builder = self.create_dummy()
layout = BaseLayout(context, request, builder)
self.assertNotEqual(layout.get_converter(), None)
self.assertEqual(layout.get_converter(), layout.get_converter())
def test_use_package_conflicting_order(self):
# Using use_package with conflicting orders should raise exceptions
layout = BaseLayout(self.create_dummy(), self.create_dummy(),
self.builder)
self.assertEqual(layout.get_packages_latex(), '')
# insert_after itself
with self.assertRaises(ConflictingUsePackageOrder) as cm:
layout.use_package('foo', insert_after='foo')
self.assertEqual(
str(cm.exception),
'Cannot insert "foo" after itself (insert_after="foo").')
self.assertEqual(layout.get_packages_latex(), '')
# recursive conflicting order
layout.use_package('baz', insert_after='foo')
layout.use_package('foo', insert_after='bar')
with self.assertRaises(ConflictingUsePackageOrder) as cm:
layout.use_package('bar', insert_after='baz')
self.assertEqual(
str(cm.exception),
'Conflicting order: bar after baz after foo after bar.')
def test_use_babel_with_linguaplone(self):
context = self.mocker.mock()
self.expect(context.getLanguage).result(lambda: 'pt-br')
self.replay()
layout = BaseLayout(context, self.create_dummy(),
self.builder)
self.assertEqual(layout.get_packages_latex(), '')
layout.use_babel()
self.assertEqual(layout.get_packages_latex(),
'\\usepackage[brazilian]{babel}\n')
def test_use_babel_with_unsupported_language(self):
ltool = self.mocker.mock()
self.mock_tool(ltool, 'portal_languages')
self.expect(ltool.getPreferredLanguage()).result('unknown')
self.replay()
layout = BaseLayout(self.create_dummy(), self.create_dummy(),
self.builder)
self.assertEqual(layout.get_packages_latex(), '')
layout.use_babel()
self.assertEqual(layout.get_packages_latex(),
'\\usepackage{babel}\n')
def test_use_package_bad_package_name(self):
layout = BaseLayout(self.create_dummy(), self.create_dummy(),
self.builder)
with self.assertRaises(ValueError) as cm:
layout.use_package(None)
self.assertEqual(
str(cm.exception),
'Package name should be a string, got None (NoneType)')
with self.assertRaises(ValueError) as cm:
layout.use_package(5)
self.assertEqual(
str(cm.exception),
'Package name should be a string, got 5 (int)')
def setUp(self):
super(TestInjectionAwareConvertObject, self).setUp()
context = self.create_dummy()
request = self.providing_stub(IWithinBookLayer)
builder = self.providing_stub(IBuilder)
self.layout = BaseLayout(context, request, builder)
def setUp(self):
super(TestLaTeXInjectionController, self).setUp()
context = self.create_dummy()
self.request = self.providing_stub(IWithinBookLayer)
builder = self.create_dummy()
self.layout = BaseLayout(context, self.request, builder)
def setUp(self):
super(TestInjectionAwareConvertObject, self).setUp()
context = self.create_dummy()
request = self.create_dummy()
directlyProvides(request, IWithinBookLayer)
builder = self.create_dummy()
self.layout = BaseLayout(context, request, builder)
def test_get_view_rendering(self):
class IFoo(Interface):
pass
foo = self.create_dummy()
alsoProvides(foo, IFoo)
class FooView(object):
implements(ILaTeXView)
data = 'foo'
def __init__(self, context, request, layout):
pass
def render(self):
return self.data
provideAdapter(FooView, (IFoo, Interface, Interface), name='')
class PreFooView(FooView):
data = 'pre'
provideAdapter(PreFooView, (IFoo, Interface, Interface),
name='pre-hook')
class PostFooView(FooView):
data = 'post'
provideAdapter(PostFooView, (IFoo, Interface, Interface),
name='post-hook')
context = self.create_dummy()
request = self.create_dummy()
builder = self.create_dummy()
layout = BaseLayout(context, request, builder)
views = layout.get_views_for(foo)
self.assertEqual(len(views), 3)
self.assertEqual(type(views[0]), PreFooView)
self.assertEqual(type(views[1]), FooView)
self.assertEqual(type(views[2]), PostFooView)
self.assertEqual(
layout.render_latex_for(foo), 'pre\nfoo\npost')
def test_use_package(self):
layout = BaseLayout(self.create_dummy(), self.create_dummy(),
self.builder)
self.assertEqual(layout.get_packages_latex(), '')
layout.use_package('inputenc', 'utf8')
self.assertEqual(layout.get_packages_latex(),
'\\usepackage[utf8]{inputenc}\n')
layout.use_package(u'titlesec', 'noindentafter',
insert_after='inputenc')
self.assertEqual(layout.get_packages_latex(),
'\\usepackage[utf8]{inputenc}\n'
'\\usepackage[noindentafter]{titlesec}\n')
layout.use_package('titlesec', 'largestsep')
self.assertEqual(
layout.get_packages_latex(),
'\\usepackage[utf8]{inputenc}\n'
'\\usepackage[noindentafter, largestsep]{titlesec}\n')
layout.use_package('titlesec', 'largestsep')
self.assertEqual(
layout.get_packages_latex(),
'\\usepackage[utf8]{inputenc}\n'
'\\usepackage[noindentafter, largestsep]{titlesec}\n')
layout.use_package('titlesec', options='', append_options=False)
self.assertEqual(
layout.get_packages_latex(),
'\\usepackage[utf8]{inputenc}\n'
'\\usepackage{titlesec}\n')
# clear use-package list
layout._packages = []
layout.use_package('hyperref')
layout.use_package('hyperref', options='colorlinks=false')
layout.use_package('hyperref')
self.assertEqual(
layout.get_packages_latex(),
'\\usepackage[colorlinks=false]{hyperref}\n')
class TestInjectionAwareConvertObject(MockTestCase):
layer = LATEX_ZCML_LAYER
def setUp(self):
super(TestInjectionAwareConvertObject, self).setUp()
context = self.create_dummy()
request = self.providing_stub(IWithinBookLayer)
builder = self.providing_stub(IBuilder)
self.layout = BaseLayout(context, request, builder)
def mock_extender_values(self, mock, **data):
default_data = {
'preLatexCode': '',
'postLatexCode': '',
'preferredColumnLayout': NO_PREFERRED_LAYOUT,
'latexLandscape': False,
'preLatexClearpage': False,
'postLatexClearpage': False,
'preLatexNewpage': False
}
default_data.update(data)
data = default_data
schema = self.stub()
self.expect(mock.Schema()).result(schema).count(0, None)
for fieldname, value in data.items():
self.expect(schema.getField(fieldname).get(mock)).result(value)
self.expect(mock.getPhysicalPath()).result(['', 'path', 'to', 'obj'])
return schema
def test_not_injected_without_interface(self):
obj = self.mocker.mock()
self.expect(obj.Schema()).count(0)
self.replay()
self.assertEqual(self.layout.render_latex_for(obj), '')
def test_injected_with_interface(self):
latex_pre_code = 'INJECTED PRE LATEX CODE'
latex_post_code = 'INJECTED POST LATEX CODE'
obj = self.providing_stub(ILaTeXCodeInjectionEnabled)
self.mock_extender_values(obj,
preLatexCode=latex_pre_code,
postLatexCode=latex_post_code)
self.replay()
latex = self.layout.render_latex_for(obj)
self.assertIn(latex_pre_code, latex)
self.assertIn(latex_post_code, latex)
self.assertIn('/'.join(obj.getPhysicalPath()), latex)
def test_bad_schemaextender_state(self):
# sometimes the field can not be retrieved. We do nothing and we
# don't fail in this case.
obj_dummy = self.create_dummy()
directlyProvides(obj_dummy, ILaTeXCodeInjectionEnabled)
obj = self.mocker.proxy(obj_dummy, spec=None)
self.mock_extender_values(obj, preLatexCode=None)
self.replay()
latex = self.layout.render_latex_for(obj)
self.assertEqual(latex.strip(), r'\label{path:/path/to/obj}')
def test_column_layout_injected(self):
obj1 = self.providing_stub(ILaTeXCodeInjectionEnabled)
self.mock_extender_values(obj1,
preferredColumnLayout=NO_PREFERRED_LAYOUT)
obj1a = self.providing_stub(ILaTeXCodeInjectionEnabled)
self.mock_extender_values(obj1a,
preferredColumnLayout=TWOCOLUMN_LAYOUT)
obj1b = self.providing_stub(ILaTeXCodeInjectionEnabled)
self.mock_extender_values(obj1b,
preferredColumnLayout=ONECOLUMN_LAYOUT)
obj1c = self.providing_stub(ILaTeXCodeInjectionEnabled)
self.mock_extender_values(obj1c,
preferredColumnLayout=NO_PREFERRED_LAYOUT)
obj2 = self.providing_stub(ILaTeXCodeInjectionEnabled)
self.mock_extender_values(obj2, preferredColumnLayout=TWOCOLUMN_LAYOUT)
self.replay()
latex_obj1 = self.layout.render_latex_for(obj1)
latex_obj1a = self.layout.render_latex_for(obj1a)
latex_obj1b = self.layout.render_latex_for(obj1b)
latex_obj1c = self.layout.render_latex_for(obj1c)
latex_obj2 = self.layout.render_latex_for(obj2)
self.assertNotIn('column', latex_obj1)
self.assertIn(r'\twocolumn', latex_obj1a)
self.assertIn(r'\onecolumn', latex_obj1b)
self.assertNotIn('column', latex_obj1c)
self.assertIn(r'\twocolumn', latex_obj2)
def test_latex_clearpage_injected(self):
normal_obj = self.providing_stub(ILaTeXCodeInjectionEnabled)
self.mock_extender_values(normal_obj)
pre_clearpage_obj = self.providing_stub(ILaTeXCodeInjectionEnabled)
self.mock_extender_values(pre_clearpage_obj, preLatexClearpage=True)
post_clearpage_obj = self.providing_stub(ILaTeXCodeInjectionEnabled)
self.mock_extender_values(post_clearpage_obj, postLatexClearpage=True)
for obj in [normal_obj, pre_clearpage_obj, post_clearpage_obj]:
self.expect(obj.getPhysicalPath()).result(['', 'myobj'])
self.replay()
self.assertNotIn(r'\clearpage',
self.layout.render_latex_for(normal_obj))
self.assertIn(r'\clearpage',
self.layout.render_latex_for(pre_clearpage_obj))
self.assertIn(r'\clearpage',
self.layout.render_latex_for(post_clearpage_obj))
def test_latex_newpage_injected(self):
normal_obj = self.providing_stub(ILaTeXCodeInjectionEnabled)
self.mock_extender_values(normal_obj)
pre_newpage_obj = self.providing_stub(ILaTeXCodeInjectionEnabled)
self.mock_extender_values(pre_newpage_obj, preLatexNewpage=True)
for obj in [normal_obj, pre_newpage_obj]:
self.expect(obj.getPhysicalPath()).result(['', 'myobj'])
self.replay()
self.assertNotIn(r'\newpage', self.layout.render_latex_for(normal_obj))
self.assertIn(r'\newpage',
self.layout.render_latex_for(pre_newpage_obj))
def test_landscape_mode(self):
obj1 = self.providing_stub(ILaTeXCodeInjectionEnabled)
self.mock_extender_values(obj1, latexLandscape=False)
obj2 = self.providing_stub(ILaTeXCodeInjectionEnabled)
self.mock_extender_values(obj2, latexLandscape=True)
self.replay()
latex_obj1 = self.layout.render_latex_for(obj1)
latex_obj2 = self.layout.render_latex_for(obj2)
self.assertNotIn(r'landscape', latex_obj1)
self.assertIn(r'landscape', latex_obj2)
self.assertIn(r'\begin{landscape}', latex_obj2)
self.assertIn(r'\end{landscape}', latex_obj2)
def test_landscape_nested(self):
foo = self.providing_stub([ILaTeXCodeInjectionEnabled, IFoo])
self.mock_extender_values(foo, latexLandscape=True)
bar = self.providing_stub(ILaTeXCodeInjectionEnabled)
self.mock_extender_values(bar, latexLandscape=False)
baz = self.providing_stub(ILaTeXCodeInjectionEnabled)
self.mock_extender_values(baz, latexLandscape=True)
class FooLaTeXView(object):
def __init__(self, context, request, layout):
self.layout = layout
def render(self):
return '\n'.join((
'Bar: %s' % self.layout.render_latex_for(bar).strip(),
'Baz: %s' % self.layout.render_latex_for(baz).strip(),
))
self.mock_adapter(FooLaTeXView, ILaTeXView,
(IFoo, Interface, Interface))
self.replay()
self.assertEqual(
'\n'.join((r'\label{path:/path/to/obj}', r'', r'\begin{landscape}',
r'Bar: \label{path:/path/to/obj}',
r'Baz: \label{path:/path/to/obj}', r'\end{landscape}')),
self.layout.render_latex_for(foo))
def test_use_babel_passes_keyword_args(self):
layout = BaseLayout(self.create_dummy(), self.create_dummy(),
self.builder)
self.assertEqual(layout.get_packages_latex(), '')
layout.use_package('babel', options='foo')
self.assertEqual(layout.get_packages_latex(),
'\\usepackage[foo]{babel}\n')
layout.use_babel('bar')
self.assertEqual(layout.get_packages_latex(),
'\\usepackage[bar]{babel}\n')
layout.use_babel('baz', append_options=True)
self.assertEqual(layout.get_packages_latex(),
'\\usepackage[bar, baz]{babel}\n')
class TestInjectionAwareConvertObject(MockTestCase):
layer = LATEX_ZCML_LAYER
def setUp(self):
super(TestInjectionAwareConvertObject, self).setUp()
context = self.create_dummy()
request = self.providing_stub(IWithinBookLayer)
builder = self.providing_stub(IBuilder)
self.layout = BaseLayout(context, request, builder)
def mock_extender_values(self, mock, **data):
default_data = {'preLatexCode': '',
'postLatexCode': '',
'preferredColumnLayout': NO_PREFERRED_LAYOUT,
'latexLandscape': False,
'preLatexClearpage': False,
'postLatexClearpage': False,
'preLatexNewpage': False}
default_data.update(data)
data = default_data
schema = self.stub()
self.expect(mock.Schema()).result(schema).count(0, None)
for fieldname, value in data.items():
self.expect(schema.getField(fieldname).get(mock)).result(value)
self.expect(mock.getPhysicalPath()).result(['', 'path', 'to', 'obj'])
return schema
def test_not_injected_without_interface(self):
obj = self.mocker.mock()
self.expect(obj.Schema()).count(0)
self.replay()
self.assertEqual(self.layout.render_latex_for(obj), '')
def test_injected_with_interface(self):
latex_pre_code = 'INJECTED PRE LATEX CODE'
latex_post_code = 'INJECTED POST LATEX CODE'
obj = self.providing_stub(ILaTeXCodeInjectionEnabled)
self.mock_extender_values(obj, preLatexCode=latex_pre_code,
postLatexCode=latex_post_code)
self.replay()
latex = self.layout.render_latex_for(obj)
self.assertIn(latex_pre_code, latex)
self.assertIn(latex_post_code, latex)
self.assertIn('/'.join(obj.getPhysicalPath()), latex)
def test_bad_schemaextender_state(self):
# sometimes the field can not be retrieved. We do nothing and we
# don't fail in this case.
obj_dummy = self.create_dummy()
directlyProvides(obj_dummy, ILaTeXCodeInjectionEnabled)
obj = self.mocker.proxy(obj_dummy, spec=None)
self.mock_extender_values(obj, preLatexCode=None)
self.replay()
latex = self.layout.render_latex_for(obj)
self.assertEqual(latex.strip(), r'\label{path:/path/to/obj}')
def test_column_layout_injected(self):
obj1 = self.providing_stub(ILaTeXCodeInjectionEnabled)
self.mock_extender_values(
obj1, preferredColumnLayout=NO_PREFERRED_LAYOUT)
obj1a = self.providing_stub(ILaTeXCodeInjectionEnabled)
self.mock_extender_values(
obj1a, preferredColumnLayout=TWOCOLUMN_LAYOUT)
obj1b = self.providing_stub(ILaTeXCodeInjectionEnabled)
self.mock_extender_values(
obj1b, preferredColumnLayout=ONECOLUMN_LAYOUT)
obj1c = self.providing_stub(ILaTeXCodeInjectionEnabled)
self.mock_extender_values(
obj1c, preferredColumnLayout=NO_PREFERRED_LAYOUT)
obj2 = self.providing_stub(ILaTeXCodeInjectionEnabled)
self.mock_extender_values(
obj2, preferredColumnLayout=TWOCOLUMN_LAYOUT)
self.replay()
latex_obj1 = self.layout.render_latex_for(obj1)
latex_obj1a = self.layout.render_latex_for(obj1a)
latex_obj1b = self.layout.render_latex_for(obj1b)
latex_obj1c = self.layout.render_latex_for(obj1c)
latex_obj2 = self.layout.render_latex_for(obj2)
self.assertNotIn('column', latex_obj1)
self.assertIn(r'\twocolumn', latex_obj1a)
self.assertIn(r'\onecolumn', latex_obj1b)
self.assertNotIn('column', latex_obj1c)
self.assertIn(r'\twocolumn', latex_obj2)
def test_latex_clearpage_injected(self):
normal_obj = self.providing_stub(ILaTeXCodeInjectionEnabled)
self.mock_extender_values(normal_obj)
pre_clearpage_obj = self.providing_stub(ILaTeXCodeInjectionEnabled)
self.mock_extender_values(pre_clearpage_obj, preLatexClearpage=True)
post_clearpage_obj = self.providing_stub(ILaTeXCodeInjectionEnabled)
self.mock_extender_values(post_clearpage_obj, postLatexClearpage=True)
for obj in [normal_obj, pre_clearpage_obj, post_clearpage_obj]:
self.expect(obj.getPhysicalPath()).result(['', 'myobj'])
self.replay()
self.assertNotIn(r'\clearpage',
self.layout.render_latex_for(normal_obj))
self.assertIn(r'\clearpage',
self.layout.render_latex_for(pre_clearpage_obj))
self.assertIn(r'\clearpage',
self.layout.render_latex_for(post_clearpage_obj))
def test_latex_newpage_injected(self):
normal_obj = self.providing_stub(ILaTeXCodeInjectionEnabled)
self.mock_extender_values(normal_obj)
pre_newpage_obj = self.providing_stub(ILaTeXCodeInjectionEnabled)
self.mock_extender_values(pre_newpage_obj, preLatexNewpage=True)
for obj in [normal_obj, pre_newpage_obj]:
self.expect(obj.getPhysicalPath()).result(['', 'myobj'])
self.replay()
self.assertNotIn(r'\newpage',
self.layout.render_latex_for(normal_obj))
self.assertIn(r'\newpage',
self.layout.render_latex_for(pre_newpage_obj))
def test_landscape_mode(self):
obj1 = self.providing_stub(ILaTeXCodeInjectionEnabled)
self.mock_extender_values(obj1, latexLandscape=False)
obj2 = self.providing_stub(ILaTeXCodeInjectionEnabled)
self.mock_extender_values(obj2, latexLandscape=True)
self.replay()
latex_obj1 = self.layout.render_latex_for(obj1)
latex_obj2 = self.layout.render_latex_for(obj2)
self.assertNotIn(r'landscape', latex_obj1)
self.assertIn(r'landscape', latex_obj2)
self.assertIn(r'\begin{landscape}', latex_obj2)
self.assertIn(r'\end{landscape}', latex_obj2)
def test_landscape_nested(self):
foo = self.providing_stub([ILaTeXCodeInjectionEnabled, IFoo])
self.mock_extender_values(foo, latexLandscape=True)
bar = self.providing_stub(ILaTeXCodeInjectionEnabled)
self.mock_extender_values(bar, latexLandscape=False)
baz = self.providing_stub(ILaTeXCodeInjectionEnabled)
self.mock_extender_values(baz, latexLandscape=True)
class FooLaTeXView(object):
def __init__(self, context, request, layout):
self.layout = layout
def render(self):
return '\n'.join((
'Bar: %s' % self.layout.render_latex_for(bar).strip(),
'Baz: %s' % self.layout.render_latex_for(baz).strip(),
))
self.mock_adapter(FooLaTeXView, ILaTeXView,
(IFoo, Interface, Interface))
self.replay()
self.assertEqual(
'\n'.join((
r'\label{path:/path/to/obj}',
r'',
r'\begin{landscape}',
r'Bar: \label{path:/path/to/obj}',
r'Baz: \label{path:/path/to/obj}',
r'\end{landscape}')),
self.layout.render_latex_for(foo))
def test_use_package_order(self):
# use_package in combination with insert_after
# should also work when the "other" package is not yet registered.
layout = BaseLayout(self.create_dummy(), self.create_dummy(),
self.builder)
self.assertEqual(layout.get_packages_latex(), '')
# test insert_after
layout.use_package('dcolumn', insert_after='color')
layout.use_package('color')
layout.use_package('colortbl')
self.assertEqual(
layout.get_packages_latex(),
'\\usepackage{color}\n'
'\\usepackage{dcolumn}\n'
'\\usepackage{colortbl}\n')
layout.remove_package('*')
self.assertEqual(layout.get_packages_latex(), '')
def test_remove_package(self):
layout = BaseLayout(self.create_dummy(), self.create_dummy(),
self.builder)
self.assertEqual(layout.get_packages_latex(), '')
layout.use_package('color')
layout.use_package('colortbl')
layout.use_package('dcolumn')
self.assertEqual(
layout.get_packages_latex(),
'\\usepackage{color}\n'
'\\usepackage{colortbl}\n'
'\\usepackage{dcolumn}\n')
layout.remove_package('color')
self.assertEqual(
layout.get_packages_latex(),
'\\usepackage{colortbl}\n'
'\\usepackage{dcolumn}\n')
layout.remove_package('*')
self.assertEqual(layout.get_packages_latex(), '')
class TestInjectionAwareConvertObject(MockTestCase):
layer = LATEX_ZCML_LAYER
def setUp(self):
super(TestInjectionAwareConvertObject, self).setUp()
context = self.create_dummy()
request = self.create_dummy()
directlyProvides(request, IWithinBookLayer)
builder = self.create_dummy()
self.layout = BaseLayout(context, request, builder)
def test_not_injected_without_interface(self):
obj = self.mocker.mock()
self.expect(obj.Schema()).count(0)
self.replay()
self.assertEqual(self.layout.render_latex_for(obj), '')
def test_injected_with_interface(self):
latex_pre_code = 'INJECTED PRE LATEX CODE'
latex_post_code = 'INJECTED POST LATEX CODE'
obj_dummy = self.create_dummy()
directlyProvides(obj_dummy, ILaTeXCodeInjectionEnabled)
obj = self.mocker.proxy(obj_dummy, spec=None)
schema = self.mocker.mock()
self.expect(obj.Schema()).result(schema).count(2)
self.expect(schema.getField('preLatexCode').get(obj)).result(
latex_pre_code)
self.expect(schema.getField('postLatexCode').get(obj)).result(
latex_post_code)
self.expect(obj.getPhysicalPath()).result(
['', 'myobj']).count(3) # 3 = pre + post + assertion below
self.replay()
latex = self.layout.render_latex_for(obj)
self.assertIn(latex_pre_code, latex)
self.assertIn(latex_post_code, latex)
self.assertIn('/'.join(obj.getPhysicalPath()), latex)
def test_bad_schemaextender_state(self):
# sometimes the field can not be retrieved. We do nothing and we
# don't fail in this case.
obj_dummy = self.create_dummy()
directlyProvides(obj_dummy, ILaTeXCodeInjectionEnabled)
obj = self.mocker.proxy(obj_dummy, spec=None)
schema = self.mocker.mock()
self.expect(obj.Schema()).result(schema).count(2)
# pre latex: field not found
self.expect(schema.getField('preLatexCode')).result(None)
# post latex: field value is empty
self.expect(schema.getField('postLatexCode').get(obj)).result('')
self.replay()
latex = self.layout.render_latex_for(obj)
self.assertEqual(latex.strip(), '')
def __init__(self, context, request, builder):
BaseLayout.__init__(self, context, request, builder)
MakoTemplating.__init__(self)
