def test_unproxification():
"""test for unproxified error view publishing.
"""
root = get_structure()
publisher = DawnlightPublisher(
view_lookup=ViewLookup(lookup=wrap_http_renderer))
provideAdapter(
AttributeErrorView, (AttributeError, IRequest), IView)
provideAdapter(
InnocentView, (IModel, IRequest), IView, name="innocent")
req = TestRequest(path="/a/@@innocent")
proxified = wrap_http_renderer(req, root.a, "innocent")
with pytest.raises(AttributeError):
proxified.context
with pytest.raises(AttributeError):
proxified()
assert publisher.publish(req, root) == (
u"AttributeError on <class 'cromlech.dawnlight.tests."
u"test_publish.Container'>")
# we test the error handling deactivation
with pytest.raises(AttributeError):
assert publisher.publish(req, root, handle_errors=False)
def test_item_traversing():
"""test that sub item traversing works.
"""
root = get_structure()
publisher = DawnlightPublisher()
req = TestRequest(path="/b")
assert publisher.publish(req, root) == root['b']
def test_end_with_slash():
root = get_structure()
publisher = DawnlightPublisher()
req = TestRequest(path="/b/")
assert publisher.publish(req, root) == root['b']
req = TestRequest(path="/b///")
assert publisher.publish(req, root) == root['b']
def test_no_view():
"""test for raising ResolveError.
"""
root = get_structure()
publisher = DawnlightPublisher()
req = TestRequest(path="/b/@@unknown")
with pytest.raises(ResolveError):
publisher.publish(req, root)
def test_attribute_masquerade_item():
"""test that attributes takes precedence over sub item.
"""
root = get_structure()
root['a'] = Model()
publisher = DawnlightPublisher()
req = TestRequest(path="/a")
assert publisher.publish(req, root) == root.a
assert publisher.publish(req, root) != root['a']
def __call__(self, request):
publisher = DawnlightPublisher(
request, self, view_lookup=view_lookup)
notify(PublicationBeginsEvent(self.site, request))
result = publisher.publish(self.site, handle_errors=True)
notify(PublicationEndsEvent(request, result))
return result
def publisher(environ, start_response):
request = Request(environ)
site = Site(name)
setSite(site)
notify(PublicationBeginsEvent(site, request))
publisher = DawnlightPublisher(view_lookup=view_lookup)
response = publisher.publish(request, site, handle_errors=True)
notify(PublicationEndsEvent(request, response))
setSite()
return response(environ, start_response)
def test_attribute_traversing():
"""test that attributes traversing works"""
root = get_structure()
publisher = DawnlightPublisher()
req = TestRequest(path="/a")
assert publisher.publish(req, root) == root.a
req = TestRequest(path="/_b")
assert publisher.publish(req, root) == root._b
def test_private_attribute_not_traversing():
"""test that traversing on private attributes does not works"""
root = get_structure()
publisher = DawnlightPublisher()
req = TestRequest(path="/c")
with pytest.raises(ResolveError):
publisher.publish(req, root)
req = TestRequest(path="/not_existing")
with pytest.raises(ResolveError):
publisher.publish(req, root)
def test_urlencoded_path():
"""test urlencoded path
"""
root = Container()
setattr(root, "à", Model())
root[u"â ñ"] = Model()
publisher = DawnlightPublisher()
req = TestRequest(path="/%C3%A0")
assert publisher.publish(req, root) == getattr(root, 'à')
req = TestRequest(path="/%C3%A2%20%C3%B1")
assert publisher.publish(req, root) == root[u"â ñ"]
def test_uncomplete_publication():
"""test for raising PublicationError.
"""
# no more default publisher
def no_lookup(request, result, crumbs):
return None
root = get_structure()
publisher = DawnlightPublisher(view_lookup=no_lookup)
req = TestRequest(path="/a")
with pytest.raises(PublicationError):
publisher.publish(req, root)
def test_traverser_traversing():
root = get_structure()
publisher = DawnlightPublisher()
# register traverser for namespace spam
crom.implicit.registry.register(
(Container, IRequest), ITraverser, 'spam', SpamTraverser)
req = Request(path="/++spam++foo")
assert publisher.publish(req, root) == root._spam_foo
req = Request(path="/++spam++bar")
with pytest.raises(AttributeError):
publisher.publish(req, root)
def test_faulty_resolution():
root = get_structure()
publisher = DawnlightPublisher()
# Fail on the renderer init
crom.implicit.registry.register(
(IModel, IRequest), IView, 'faulty_init', FaultyInit)
req = Request(path="/a/faulty_init")
with pytest.raises(NotImplementedError) as e:
publisher.publish(req, root)
assert e.value == 'init failed'
# Fail in the renderer call
crom.implicit.registry.register(
(IModel, IRequest), IView, 'faulty_caller', FaultyCaller)
req = Request(path="/a/faulty_caller")
with pytest.raises(NotImplementedError) as e:
publisher.publish(req, root)
# We can render errors
crom.implicit.registry.register(
(NotImplementedError, IRequest), IView, '', NotImplementedView)
req = Request(path="/a/faulty_caller")
assert publisher.publish(req, root) == 'Not implemented: call failed'
# Simulation of a component lookup error
crom.implicit.registry.register(
(IModel, IRequest), IView, 'fail_lookup', LookupFailure)
req = Request(path="/a/fail_lookup")
with pytest.raises(ComponentLookupError) as e:
publisher.publish(req, root)
def test_faulty_resolution():
root = get_structure()
publisher = DawnlightPublisher()
# Fail on the renderer init
provideAdapter(FaultyInit, (IModel, IRequest),
IView, name=u'faulty_init')
req = TestRequest(path="/a/faulty_init")
with pytest.raises(NotImplementedError) as e:
publisher.publish(req, root)
assert e.value == 'init failed'
# Fail in the renderer call
provideAdapter(FaultyCaller, (IModel, IRequest),
IView, name=u'faulty_caller')
req = TestRequest(path="/a/faulty_caller")
with pytest.raises(NotImplementedError) as e:
publisher.publish(req, root)
# We can render errors
provideAdapter(
NotImplementedView, (NotImplementedError, IRequest), IView)
req = TestRequest(path="/a/faulty_caller")
assert publisher.publish(req, root) == u'Not implemented: call failed'
# Simulation of a component lookup error
provideAdapter(LookupFailure, (IModel, IRequest),
IView, name=u'fail_lookup')
req = TestRequest(path="/a/fail_lookup")
with pytest.raises(ComponentLookupError) as e:
publisher.publish(req, root)
def test_script_name():
"""test that request.script_name is taken into account"""
root = get_structure()
publisher = DawnlightPublisher()
req = TestRequest(path="/foo/a", script_name="/foo")
assert publisher.publish(req, root) == root.a
req = TestRequest(path="/foo/a", script_name="/bar")
with pytest.raises(ResolveError):
publisher.publish(req, root)
req = TestRequest(path="/a", script_name="/foo")
assert publisher.publish(req, root) == root.a
def test_traverser_traversing():
root = get_structure()
publisher = DawnlightPublisher()
# register traverser for namespace spam
provideAdapter(
SpamTraverser, (Container, IRequest), ITraverser, name=u'spam')
req = TestRequest(path="/++spam++foo")
assert publisher.publish(req, root) == root._spam_foo
req = TestRequest(path="/++spam++bar")
with pytest.raises(AttributeError):
publisher.publish(req, root)
class TrajectApplication(object):
def __init__(self, name, engine):
self.name = name
self.engine = engine
self.site = Site(name)
self.publisher = DawnlightPublisher(view_lookup=view_lookup)
def add_object(self, obj, session=None):
if session is None:
session = get_session(self.name)
session.add(obj)
@wsgify(RequestClass=request.Request)
def __call__(self, request):
with SQLAlchemySession(self.engine):
with transaction.manager:
with Interaction():
setSite(self.site)
# Publication is about to begin
notify(PublicationBeginsEvent(self.site, request))
# publish
result = self.publisher.publish(
request, self.site, handle_errors=True)
# Publication ends
notify(PublicationEndsEvent(request, result))
setSite()
return removeSecurityProxy(result)
def test_consumer_returning_view():
class ViewReturningConsumer:
def __init__(self, context):
self.context = context
def __call__(self, request, obj, stack):
view = RawView(obj, request)
return True, view, deque()
dawnlight_components.subscribe(
(Interface,), IConsumer, ViewReturningConsumer)
root = get_structure()
publisher = DawnlightPublisher()
req = Request(path="/it_will_return_a_view")
assert publisher.publish(req, root) == root
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
class WSGIApplication(object):
def __init__(self, name):
self.name = name
self.publisher = DawnlightPublisher(view_lookup=view_lookup)
@wsgify(RequestClass=Request)
def __call__(self, request):
conn = request.environment[KEY]
site = get_site(conn, self.name)
with Site(site) as site:
response = self.publisher.publish(
request,
site,
handle_errors=True
)
return response
class Application(object):
def __init__(self, engine):
self.engine = engine
self.publisher = DawnlightPublisher(view_lookup=view_lookup)
def __call__(self, environ, start_response):
request = Request(environ)
with transaction.manager as tm:
with Interaction():
with Site(ROOT) as root:
with SQLAlchemySession(self.engine, transaction_manager=tm):
notify(PublicationBeginsEvent(root, request))
response = self.publisher.publish(
request, root, handle_errors=True)
result = response(environ, start_response)
return result
def __init__(self, name):
self.name = name
self.publisher = DawnlightPublisher(view_lookup=view_lookup)
# used by the form.
auth = Auth({
'demo': 'demo',
'admin': 'admin',
'grok': 'grok',
})
# The publisher is a 2 times component that is in charge of looking up
# the model and the view, given an URL.
# It relies on traversers to handle the publishing.
# Here, we provide a custom way to retrieve views, using a security-aware
# function.
# See `dawnlight` and `cromlech.dawnlight` for more information.
publisher = DawnlightPublisher(
view_lookup=ViewLookup(view_locator(secure_query_view)),
).publish
class Session(object):
def __init__(self, session):
self.session = session
def __enter__(self):
setSession(self.session)
return self.session
def __exit__(self, type, value, traceback):
# Traceback or not, we reset the session thread-local.
# Exiting the block, we don't want the session set.
def test_unicode_script_name():
root = get_structure()
publisher = DawnlightPublisher()
req = TestRequest(path=u"/éléonore", script_name=u'/')
assert publisher.publish(req, root) == root[u"éléonore"]
def test_path_parsing():
root = get_structure()
publisher = DawnlightPublisher()
req = TestRequest(path=u"/éléonore")
assert publisher.publish(req, root) == root[u"éléonore"]
def __init__(self, name, engine):
self.name = name
self.engine = engine
self.site = Site(name)
self.publisher = DawnlightPublisher(view_lookup=view_lookup)
def __init__(self, engine):
self.engine = engine
self.publisher = DawnlightPublisher(view_lookup=view_lookup)
def get_publisher(self,
view_lookup=secured_view,
model_lookup=base_model_lookup):
publisher = DawnlightPublisher(model_lookup, view_lookup)
return publisher.publish
# We init it here, just to have the view lookup working.
from crom import monkey, implicit
monkey.incompat() # incompat means it changes the behavior of the iface
implicit.initialize() # we create a new registry and make it the default
# we define our publisher
from cromlech.dawnlight import DawnlightPublisher
from cromlech.browser.interfaces import IView
from cromlech.dawnlight import ViewLookup, view_locator
from cromlech.webob.request import Request
def query_view(request, context, name=""):
return IView.component(context, request, name=name)
view_lookup = ViewLookup(view_locator(query_view))
Publisher = DawnlightPublisher(view_lookup=view_lookup)
# We read the zodb conf and initialize it
from cromlech.zodb import init_db_from_file
with open(config['zodb']['config'], 'r') as fd:
db = init_db_from_file(fd)
# We create our ZODB connection manager
import transaction
from cromlech.zodb.controlled import Connection
class ZODBApplication(object):
def __init__(self, db):
self.db = db
async def handle(self, request):
def test_empty():
root = get_structure()
publisher = DawnlightPublisher()
req = Request(path="/")
assert publisher.publish(req, root) == root
