def test_create_file(self):
grok_component('ITest2', ITest2)
# mock stuf
mock_context = self.providing_stub([
ITabbedviewUploadable,
])
named_file = NamedFile('bla bla', filename=u'test.txt')
obj = self.providing_stub([ITest1, ITest2])
request = self.stub()
self.expect(obj.REQUEST).result(request)
iterSchemata = self.mocker.replace(
'plone.dexterity.utils.iterSchemata')
self.expect(iterSchemata(obj)).result([ITest1, ITest2])
self.replay()
# test if it's sets the default value and
# also if it add the created file to the primary field
adapter = IQuickUploadFileFactory(mock_context)
named_file = adapter.create_file(u'hugo.jpeg', u'data data', obj)
self.assertEquals(named_file.data, u'data data')
def test_full_init_persistent(self):
class MyTile(tiles.PersistentTile):
grok.context(IDummyContext)
grok.require('dummy.ViewPermission')
grok.name('my.tile')
grok.title(u"My title")
grok.description(u"My description")
tiles.add_permission(DummyAddPermission)
tiles.schema(IDummySchema)
grok_component('MyTile', MyTile)
# Check for view
context = DummyContext()
request = TestRequest()
tileView = getMultiAdapter((context, request,), name='my.tile')
tileType = getUtility(ITileType, name='my.tile')
self.failUnless(isinstance(tileView, MyTile))
self.assertEquals(u"My title", tileType.title)
self.assertEquals(u"My description", tileType.description)
self.assertEquals(IDummySchema, tileType.schema)
self.assertEquals('dummy.AddPermission', tileType.add_permission)
def test_inherited_schema_still_has_tagged_value(self):
"""An inherited schema should still have the tagged value information
inherited from its superclass.
"""
class IFoo(form.Schema):
"""Class with a searchable field
"""
searchable('baz')
baz = schema.TextLine(title=u'baz')
class IBar(IFoo):
"""Schema class which inherits a field from IFoo.
"""
self.assertEquals([], mergedTaggedValueList(IFoo, SEARCHABLE_KEY))
self.assertEquals([], mergedTaggedValueList(IBar, SEARCHABLE_KEY))
grok_component('IFoo', IFoo)
grok_component('IBar', IBar)
self.assertEquals([(Interface, 'baz', 'true')],
mergedTaggedValueList(IFoo, SEARCHABLE_KEY))
self.assertEquals([(Interface, 'baz', 'true')],
mergedTaggedValueList(IBar, SEARCHABLE_KEY))
def test_inject():
foo = Library('foo', '')
x1 = Resource(foo, 'a.js')
x2 = Resource(foo, 'b.css')
class MyResources(ResourceViewlet):
view(MyView)
slot(Resources)
resources = [x1, x2]
expected = '''
<html>
<head>
<link rel="stylesheet" type="text/css"
href="/fanstatic/foo/b.css" />
<script type="text/javascript"
src="/fanstatic/foo/a.js"></script>
</head>
<body>A view</body>
</html>
'''
testing.grok_component('myresources', MyResources)
app = TestApp(Injector(MyApp(object(), MyView)))
res = app.get('/')
assert XMLDiff(res.body, expected) is None
app = TestApp(Injector(MyApp(object(), AnotherView)))
res = app.get('/')
assert res.body == '<html><head></head><body>A view</body></html>'
def test_no_name():
"""A role has to have a name to be defined.
"""
class MissingName(components.Role):
pass
with pytest.raises(martian.error.GrokError):
testing.grok_component('fail', MissingName)
def test_url(self):
class MyOtherTile(tiles.Tile):
grok.context(IDummyContext)
grok.require('dummy.ViewPermission')
grok.name('my.tile')
grok.title(u"My title")
tiles.add_permission('dummy.AddPermission')
def render(self):
return '<html><body><b>Good bye %s</b></body></html>' % self.id
class DummyAbsoluteURL(grok.MultiAdapter):
grok.provides(IAbsoluteURL)
grok.adapts(IDummyContext, Interface)
def __init__(self, context, request):
self.context = context
self.request = request
def __unicode__(self):
return u"http://example.com/context"
def __str__(self):
return u"http://example.com/context"
def __call__(self):
return self.__str__()
def breadcrumbs(self):
return ({'name': u'context',
'url': 'http://example.com/context'},)
grok_component('MyOtherTile', MyOtherTile)
grok_component('DummyAbsoluteURL', DummyAbsoluteURL)
from plone.tiles.absoluteurl import TransientTileAbsoluteURL
provideAdapter(TransientTileAbsoluteURL, adapts=(ITile, Interface,),
provides=IAbsoluteURL)
from plone.tiles.data import TransientTileDataManager
provideAdapter(TransientTileDataManager)
context = DummyContext()
request = TestRequest()
tileView = getMultiAdapter((context, request,), name='my.tile')
self.assertEquals(None, tileView.id)
self.assertEquals('http://example.com/context/@@my.tile', tileView.url)
tileView = tileView['tile1']
self.assertEquals('tile1', tileView.id)
self.assertEquals('http://example.com/context/@@my.tile/tile1',
tileView.url)
def test_class_security_initialised(self):
class Content(Item):
pass
InitializeClass_mock = self.mocker.replace(
'App.class_init.InitializeClass')
self.expect(InitializeClass_mock(Content))
self.replay()
grok_component('Content', Content)
def test_editform_with_defaults(self):
class IDummyContent(Interface):
pass
class EditForm(form.EditForm):
five.grok.context(IDummyContent)
if DEFAULT_WRAP: # Plone < 4
wrapped = self.create_dummy()
wrap_form_mock = self.mocker.replace(
'plone.z3cform.layout.wrap_form')
self.expect(wrap_form_mock(EditForm)).result(wrapped)
factory = wrapped
else: # Plone >= 4
factory = EditForm
page_mock = self.mocker.replace(
'Products.Five.browser.metaconfigure.page')
self.expect(
page_mock(mocker.ANY,
name='edit',
permission='cmf.ModifyPortalContent',
for_=IDummyContent,
layer=IDefaultBrowserLayer,
class_=factory))
self.replay()
self.assertEquals(True, grok_component('EditForm', EditForm))
def test_addform_registered_with_factory_layer_and_permission(self):
class ITestLayer(Interface):
pass
class AddForm(form.AddForm):
five.grok.name('my.type')
five.grok.layer(ITestLayer)
five.grok.require('my.permission')
def match_addview():
return mocker.MATCH(lambda x: issubclass(x, add.DefaultAddView))
protectClass_mock = self.mocker.replace(protectClass_method)
self.expect(protectClass_mock(match_addview(), "my.permission"))
protectName_mock = self.mocker.replace(protectName_method)
self.expect(
protectName_mock(match_addview(), '__call__', "my.permission"))
self.expect(
protectName_mock(match_addview(), self.match_type(basestring),
'zope2.Private')).count(1, None)
self.replay()
self.assertEquals(True, grok_component('AddForm', AddForm))
# Find the adapter that was registered
view = getMultiAdapter(
(TestContext(), TestRequest(ITestLayer), DexterityFTI(u"my.type")),
name=u"my.type")
self.failUnless(isinstance(view, add.DefaultAddView))
self.assertEquals(AddForm, view.form)
def test_addform_registered_with_factory_layer_and_permission(self):
class ITestLayer(Interface):
pass
class AddForm(form.AddForm):
five.grok.name('my.type')
five.grok.layer(ITestLayer)
five.grok.require('my.permission')
def match_addview():
return mocker.MATCH(lambda x: issubclass(x, add.DefaultAddView))
protectClass_mock = self.mocker.replace(protectClass_method)
self.expect(protectClass_mock(match_addview(), "my.permission"))
protectName_mock = self.mocker.replace(protectName_method)
self.expect(protectName_mock(match_addview(), '__call__',
"my.permission"))
self.expect(protectName_mock(
match_addview(), self.match_type(basestring), 'zope2.Private')
).count(1, None)
self.replay()
self.assertEquals(True, grok_component('AddForm', AddForm))
# Find the adapter that was registered
view = getMultiAdapter((TestContext(), TestRequest(ITestLayer),
DexterityFTI(u"my.type")), name=u"my.type")
self.failUnless(isinstance(view, add.DefaultAddView))
self.assertEquals(AddForm, view.form)
def test_editform_with_defaults(self):
class IDummyContent(Interface):
pass
class EditForm(form.EditForm):
five.grok.context(IDummyContent)
if DEFAULT_WRAP: # Plone < 4
wrapped = self.create_dummy()
wrap_form_mock = self.mocker.replace(
'plone.z3cform.layout.wrap_form')
self.expect(wrap_form_mock(EditForm)).result(wrapped)
factory = wrapped
else: # Plone >= 4
factory = EditForm
page_mock = self.mocker.replace(
'Products.Five.browser.metaconfigure.page')
self.expect(page_mock(mocker.ANY,
name='edit',
permission='cmf.ModifyPortalContent',
for_=IDummyContent,
layer=IDefaultBrowserLayer,
class_=factory))
self.replay()
self.assertEquals(True, grok_component('EditForm', EditForm))
def test_schema_directives_store_tagged_values(self):
"""Test, if the schema directive values are stored as tagged
values.
"""
class IDummy(form.Schema):
"""Dummy schema class.
"""
searchable('foo')
foo = schema.TextLine(title=u'Foo')
self.assertEquals([], mergedTaggedValueList(IDummy, SEARCHABLE_KEY))
grok_component('IDummy', IDummy)
self.assertEquals([(Interface, 'foo', 'true')],
mergedTaggedValueList(IDummy, SEARCHABLE_KEY))
def test_name_registers_factory(self):
class Content(Item):
five.grok.name('my.type')
provideUtility_mock = self.mocker.replace(
'zope.component.provideUtility')
self.expect(provideUtility_mock(self.match_provides(IFactory),
IFactory, 'my.type'))
InitializeClass_mock = self.mocker.replace(
'App.class_init.InitializeClass')
self.expect(InitializeClass_mock(Content))
self.replay()
grok_component('Content', Content)
def test_schema_directives_store_tagged_values(self):
"""Test, if the schema directive values are stored as tagged
values.
"""
class IDummy(form.Schema):
"""Dummy schema class.
"""
searchable('foo')
foo = schema.TextLine(title=u'Foo')
self.assertEquals([], mergedTaggedValueList(IDummy, SEARCHABLE_KEY))
grok_component('IDummy', IDummy)
self.assertEquals([(Interface, 'foo', 'true')],
mergedTaggedValueList(IDummy, SEARCHABLE_KEY))
def test_registration():
class MyRole(components.Role):
components.name('SomeSillyRole')
assert testing.grok_component('myrole', MyRole) == True
role = getUtility(IRole, name='SomeSillyRole')
assert isinstance(role, MyRole) is True
def test_template_association(self):
class MyTile(tiles.Tile):
grok.context(IDummyContext)
grok.require('dummy.ViewPermission')
grok.name('my.tile')
grok.title(u"My title")
tiles.add_permission('dummy.AddPermission')
grok_component('MyTile', MyTile)
# Check for view
context = DummyContext()
request = TestRequest()
tileView = getMultiAdapter((context, request,), name='my.tile')
self.assertEquals('<html><body><b>Hello</b></body></html>',
tileView().strip())
def test_edit_form_bails_without_interface_as_context(self):
class Foo(object):
pass
class EditForm(form.EditForm):
five.grok.context(Foo)
self.replay()
self.assertEquals(False, grok_component('EditForm', EditForm))
def test_edit_form_bails_without_interface_as_context(self):
class Foo(object):
pass
class EditForm(form.EditForm):
five.grok.context(Foo)
self.replay()
self.assertEquals(False, grok_component('EditForm', EditForm))
def test_name_does_not_overwrite_factory(self):
class Content(Item):
five.grok.name('my.type')
factory_dummy = self.create_dummy()
self.mock_utility(factory_dummy, IFactory, 'my.type')
provideUtility_mock = self.mocker.replace(
'zope.component.provideUtility')
self.expect(provideUtility_mock(mocker.ANY, IFactory, 'my.type')
).count(0)
InitializeClass_mock = self.mocker.replace(
'App.class_init.InitializeClass')
self.expect(InitializeClass_mock(Content))
self.replay()
grok_component('Content', Content)
def test_complete_creation(self):
grok_component('ITest2', ITest2)
# mock stuf
mock_context = self.providing_stub([
ITabbedviewUploadable,
])
obj = self.providing_stub([ITest1, ITest2])
request = self.stub()
self.expect(obj.REQUEST).result(request)
self.expect(obj.reindexObject()).result(None)
self.expect(obj.__parent__).result(mock_context)
self.expect(obj.__name__).result('test_context')
iterSchemata = self.mocker.replace(
'plone.dexterity.utils.iterSchemata')
self.expect(iterSchemata(obj)).result([ITest1, ITest2]).count(0, None)
createContentInContainer = self.mocker.replace(
'plone.dexterity.utils.createContentInContainer')
self.expect(
createContentInContainer(
mock_context, 'opengever.document.document')).result(obj)
# filedata
filename = u'hugo.doc'
title = None
description = None
content_type = None
data = u'Data data'
portal_type = None
self.replay()
adapter = IQuickUploadFileFactory(mock_context)
result = adapter(filename, title, description, content_type, data,
portal_type)
obj = result.get('success')
self.assertEquals(obj.description, 'hanspeter')
self.assertEquals(obj.file.data, u'Data data')
def test_no_register_class_without_add_permission(self):
class Content(Item):
meta_type = "ContentMT"
try:
from OFS.metaconfigure import registerClass
registerClass_mock = self.mocker.replace(
'OFS.metaconfigure.registerClass')
except ImportError:
# BBB
registerClass_mock = self.mocker.replace(
'Products.Five.fiveconfigure.registerClass')
self.expect(registerClass_mock(mocker.ANY, Content, mocker.ANY,
mocker.ANY)).count(0)
InitializeClass_mock = self.mocker.replace(
'App.class_init.InitializeClass')
self.expect(InitializeClass_mock(Content))
self.replay()
grok_component('Content', Content)
def test_render_function(self):
class MyOtherTile(tiles.Tile):
grok.context(IDummyContext)
grok.require('dummy.ViewPermission')
grok.name('my.tile')
grok.title(u"My title")
tiles.add_permission('dummy.AddPermission')
def render(self):
return '<html><body><b>Good bye</b></body></html>'
grok_component('MyOtherTile', MyOtherTile)
# Check for view
context = DummyContext()
request = TestRequest()
tileView = getMultiAdapter((context, request,), name='my.tile')
self.assertEquals('<html><body><b>Good bye</b></body></html>',
tileView())
def test_complete_creation(self):
grok_component('ITest2', ITest2)
# mock stuf
mock_context = self.providing_stub([ITabbedviewUploadable, ])
obj = self.providing_stub([ITest1, ITest2])
request = self.stub()
self.expect(obj.REQUEST).result(request)
self.expect(obj.reindexObject()).result(None)
self.expect(obj.__parent__).result(mock_context)
self.expect(obj.__name__).result('test_context')
iterSchemata = self.mocker.replace(
'plone.dexterity.utils.iterSchemata')
self.expect(iterSchemata(obj)).result([ITest1, ITest2]).count(0, None)
createContentInContainer = self.mocker.replace(
'plone.dexterity.utils.createContentInContainer')
self.expect(createContentInContainer(
mock_context, 'opengever.document.document')).result(obj)
# filedata
filename = u'hugo.doc'
title = None
description = None
content_type = None
data = u'Data data'
portal_type = None
self.replay()
adapter = IQuickUploadFileFactory(mock_context)
result = adapter(filename, title, description,
content_type, data, portal_type)
obj = result.get('success')
self.assertEquals(obj.description, 'hanspeter')
self.assertEquals(obj.file.data, u'Data data')
def test_consumer_returning_view():
class ViewReturningConsumer(grok.Subscription):
grok.implements(IConsumer)
grok.context(Interface)
def __call__(self, request, obj, stack):
view = RawView(obj, request)
return True, view, []
grok_component('consumer', ViewReturningConsumer)
root = get_structure()
publisher = DawnlightPublisher()
req = TestRequest(path="/it_will_return_a_view")
assert publisher.publish(req, root) == root
# The same test fail if we don't use the provided ViewLookup
publisher = DawnlightPublisher(
view_lookup=ViewLookup(lookup=wrap_http_renderer))
with pytest.raises(ResolveError) as e:
publisher.publish(req, root) == root
def test_set_default_value(self):
grok_component('ITest2', ITest2)
# mock stuf
mock_context = self.providing_stub([ITabbedviewUploadable, ])
named_file = NamedFile('bla bla', filename=u'test.txt')
obj = self.providing_stub([ITest1, ITest2])
request = self.stub()
self.expect(obj.REQUEST).result(request)
iterSchemata = self.mocker.replace(
'plone.dexterity.utils.iterSchemata')
self.expect(iterSchemata(obj)).result([ITest1, ITest2])
self.replay()
# test if it's sets the default value and
# also if it add the created file to the primary field
adapter = IQuickUploadFileFactory(mock_context)
adapter.set_default_values(obj, named_file)
self.assertEquals(obj.description, 'hanspeter')
self.assertEquals(obj.file, named_file)
def test_getitem(self):
class MyOtherTile(tiles.Tile):
grok.context(IDummyContext)
grok.require('dummy.ViewPermission')
grok.name('my.tile')
grok.title(u"My title")
tiles.add_permission('dummy.AddPermission')
def render(self):
return '<html><body><b>Good bye %s</b></body></html>' % self.id
class ViewOnTile(grok.View):
grok.context(MyOtherTile)
grok.require('dummy.ViewPermission')
grok.name('view-on-tile')
def render(self):
return 'Dummy view'
grok_component('MyOtherTile', MyOtherTile)
grok_component('ViewOnTile', ViewOnTile)
context = DummyContext()
request = TestRequest()
tileView = getMultiAdapter((context, request,), name='my.tile')
self.assertEquals(None, tileView.id)
tileView = tileView['tile1']
self.assertEquals('tile1', tileView.id)
self.assertEquals('<html><body><b>Good bye tile1</b></body></html>',
tileView())
viewOnTile = tileView['view-on-tile']
self.assertEquals('Dummy view', viewOnTile())
def test_register_class_with_meta_type_and_add_permission(self):
class Content(Item):
meta_type = "ContentMT"
add_permission(u"mock.AddPermission")
try:
from OFS.metaconfigure import registerClass
registerClass_mock = self.mocker.replace(
'OFS.metaconfigure.registerClass')
except ImportError:
# BBB
registerClass_mock = self.mocker.replace(
'Products.Five.fiveconfigure.registerClass')
self.expect(registerClass_mock(
self.match_provides(IConfigurationContext),
Content, "ContentMT", u"mock.AddPermission"))
InitializeClass_mock = self.mocker.replace(
'App.class_init.InitializeClass')
self.expect(InitializeClass_mock(Content))
self.replay()
grok_component('Content', Content)
def test_inherited_schema_still_has_tagged_value(self):
"""An inherited schema should still have the tagged value information
inherited from its superclass.
"""
class IFoo(form.Schema):
"""Class with a searchable field
"""
searchable('baz')
baz = schema.TextLine(title=u'baz')
class IBar(IFoo):
"""Schema class which inherits a field from IFoo.
"""
self.assertEquals([], mergedTaggedValueList(IFoo, SEARCHABLE_KEY))
self.assertEquals([], mergedTaggedValueList(IBar, SEARCHABLE_KEY))
grok_component('IFoo', IFoo)
grok_component('IBar', IBar)
self.assertEquals([(Interface, 'baz', 'true')],
mergedTaggedValueList(IFoo, SEARCHABLE_KEY))
self.assertEquals([(Interface, 'baz', 'true')],
mergedTaggedValueList(IBar, SEARCHABLE_KEY))
def setUp(self):
grok('uvcsite.tests.fixtures.usermanagement')
grok_component('Index', fixtures.views.MinimalAppIndex)
def test_manager_viewlet():
"""The manager is a location (a slot) where viewlet will display.
It supervises the rendering of each viewlet and merged the output.
"""
# We define the actors
mammoth = object()
request = TestRequest()
view = TestView(mammoth, request)
generic_template = Template()
class LeftColumn(dolmen.viewlet.ViewletManager):
pass
assert not getattr(LeftColumn, '__component_name__', None)
assert grok_component('left', LeftColumn) is True
assert getattr(LeftColumn, '__component_name__') == 'leftcolumn'
# We instanciate, verify and try to render
left = LeftColumn(mammoth, request, view)
assert verifyObject(dolmen.viewlet.IViewletManager, left)
left.update()
assert left.render() == u''
manager = getMultiAdapter((mammoth, request, view),
IViewSlot, name='leftcolumn')
assert manager.__class__ == LeftColumn
manager = dolmen.viewlet.query_viewlet_manager(view, name='leftcolumn')
assert manager.__class__ == LeftColumn
left.template = generic_template
left.update()
assert left.render() == 'A simple template for LeftColumn.'
# We now assign a viewlet to our manager
class WeatherBlock(dolmen.viewlet.Viewlet):
require('zope.Public')
dolmen.viewlet.slot(LeftColumn)
assert dolmen.viewlet.IViewlet.implementedBy(WeatherBlock) is True
assert grok_component('weather', WeatherBlock) is True
newInteraction(Participation(Principal('User')))
left.template = None
left.update()
assert len(list(dolmen.viewlet.query_components(
mammoth, request, view, left))) == 1
assert manager.__class__ == LeftColumn
assert len(left.viewlets) == 1
# A manager should be a valid ILocation
assert ILocation.providedBy(manager)
assert manager.__parent__ == view
assert manager.__name__ == 'leftcolumn'
# We need a template defined or it fails.
with pytest.raises(NotImplementedError) as e:
left.update()
left.render()
assert str(e.value) == (
"<class 'dolmen.viewlet.tests.test_package.WeatherBlock'> : "
"Provide a template or override the render method")
# We now define a template
WeatherBlock.template = generic_template
left.update()
assert left.render() == u'A simple template for WeatherBlock.'
# Let's register another viewlet
class AnotherBlock(dolmen.viewlet.Viewlet):
require('zope.ManageContent')
dolmen.viewlet.slot(LeftColumn)
template = generic_template
assert grok_component('another', AnotherBlock)
left.update()
assert left.render() == u'A simple template for WeatherBlock.'
# A viewlet should be a valid ILocation
viewlet = left.viewlets[0]
assert ILocation.providedBy(viewlet)
assert viewlet.__parent__.__class__ == LeftColumn
assert viewlet.__name__ == 'weatherblock'
endInteraction()
newInteraction(Participation(Principal('Master')))
left.update()
assert left.render() == (u'A simple template for AnotherBlock.\n'
u'A simple template for WeatherBlock.')
# We should be able to set an order
dolmen.viewlet.order.set(AnotherBlock, (10, 10))
left.update()
assert left.render() == (u'A simple template for WeatherBlock.\n'
u'A simple template for AnotherBlock.')
endInteraction()
# Let's register a secured viewlet manage
class Secured(dolmen.viewlet.ViewletManager):
require('zope.ManageContent')
assert grok_component('secured', Secured) is True
newInteraction(Participation(Principal('User')))
# We instanciate, verify and try to render
secured = ProxyFactory(Secured(mammoth, request, view))
with pytest.raises(Unauthorized):
secured.update()
endInteraction()
newInteraction(Participation(Principal('Master')))
# We instanciate, verify and try to render
secured.update()
assert secured.render() == u''
endInteraction()
def setup_function(module):
grok("dolmen.forms.viewlet")
testing.grok_component('index', Index)
testing.grok_component('manager', Manager)
testing.grok_component('form', Form)
def setUp(self):
self.app = self.layer.create_application('app')
grok_component('Mockup',
uvcsite.plugins.tests.fixtures.plugins.MockPlugin)
def setUp(self):
grok_component('AddressBook', fixtures.addressbook.AddressBook)
