def app(global_config, **settings):
""" This function returns a WSGI application.
It is usually called by the PasteDeploy framework during
``paster serve``.
"""
db_string = settings.get("db_string")
if db_string is None:
raise ValueError("No 'db_string' value in application configuration.")
db_echo = settings.get("db_echo", "false")
initialize_sql(db_string, asbool(db_echo))
config = Configurator(settings=settings)
config.begin()
config.add_static_view("static", "tutorial:static")
config.add_route("home", "/", view="tutorial.views.view_wiki")
config.add_route(
"view_page", "/:pagename", view="tutorial.views.view_page", view_renderer="tutorial:templates/view.pt"
)
config.add_route(
"add_page", "/add_page/:pagename", view="tutorial.views.add_page", view_renderer="tutorial:templates/view.pt"
)
config.add_route(
"edit_page", "/:pagename/edit_page", view="tutorial.views.edit_page", view_renderer="tutorial:templates/edit.pt"
)
config.end()
return config.make_wsgi_app()
class TestIntegration(unittest.TestCase):
def setUp(self):
import pyramid.mako_templating
from pyramid.configuration import Configurator
self.config = Configurator()
self.config.begin()
self.config.add_settings({'mako.directories':
'pyramid.tests:fixtures'})
self.config.add_renderer('.mak',
pyramid.mako_templating.renderer_factory)
def tearDown(self):
self.config.end()
def test_render(self):
from pyramid.renderers import render
result = render('helloworld.mak', {'a':1})
self.assertEqual(result, u'\nHello föö\n')
def test_render_to_response(self):
from pyramid.renderers import render_to_response
result = render_to_response('helloworld.mak', {'a':1})
self.assertEqual(result.ubody, u'\nHello föö\n')
def test_get_renderer(self):
from pyramid.renderers import get_renderer
result = get_renderer('helloworld.mak')
self.assertEqual(result.implementation().render_unicode(),
u'\nHello föö\n')
def app(global_config, **settings):
""" This function returns a WSGI application.
It is usually called by the PasteDeploy framework during
``paster serve``.
"""
config = Configurator(root_factory=get_root, settings=settings)
config.begin()
session_factory = session_factory_from_settings(settings)
config.set_session_factory(session_factory)
tictactroll.gamestate.set_db_path(settings.get('db_path'))
config.add_view("tictactroll.views.game", name="game",
renderer="tictactroll:templates/game.mako")
config.add_view("tictactroll.views.about", name="about",
renderer="tictactroll:templates/about.mako")
config.add_view("tictactroll.views.welcome",
renderer="tictactroll:templates/welcome.mako")
config.add_view("tictactroll.views.enter_game", name="enter_game")
config.add_view("tictactroll.views.new_game", name="new_game")
config.add_view("tictactroll.views.add_grid", name="add_grid",
renderer="json")
config.add_view("tictactroll.views.next_troll_grid",
name="next_troll_grid", renderer="json")
config.add_view("tictactroll.views.gameover_html", name="gameover",
renderer="tictactroll:templates/gameover.mako")
config.add_static_view("static", "tictactroll:static")
config.end()
return config.make_wsgi_app()
class TestGetSettings(unittest.TestCase):
def setUp(self):
from pyramid.configuration import Configurator
from pyramid.registry import Registry
registry = Registry('testing')
self.config = Configurator(registry=registry)
self.config.begin()
from zope.deprecation import __show__
__show__.off()
def tearDown(self):
self.config.end()
from zope.deprecation import __show__
__show__.on()
def _callFUT(self):
from pyramid.settings import get_settings
return get_settings()
def test_it_nosettings(self):
self.assertEqual(self._callFUT(), None)
def test_it_withsettings(self):
settings = {'a':1}
self.config.registry.settings = settings
self.assertEqual(self._callFUT(), settings)
class ViewPageTests(unittest.TestCase):
def setUp(self):
self.session = _initTestingDB()
self.config = Configurator()
self.config.begin()
def tearDown(self):
self.session.remove()
self.config.end()
def _callFUT(self, request):
from tutorial.views import view_page
return view_page(request)
def test_it(self):
from tutorial.models import Page
request = testing.DummyRequest()
request.matchdict['pagename'] = 'IDoExist'
page = Page('IDoExist', 'Hello CruelWorld IDoExist')
self.session.add(page)
_registerRoutes(self.config)
info = self._callFUT(request)
self.assertEqual(info['page'], page)
self.assertEqual(
info['content'],
'<div class="document">\n'
'<p>Hello <a href="http://example.com/add_page/CruelWorld">'
'CruelWorld</a> '
'<a href="http://example.com/IDoExist">'
'IDoExist</a>'
'</p>\n</div>\n')
self.assertEqual(info['edit_url'],
'http://example.com/IDoExist/edit_page')
def app(global_config, **settings):
""" This function returns a WSGI application.
It is usually called by the PasteDeploy framework during
``paster serve``.
"""
db_string = settings.get('db_string')
if db_string is None:
raise ValueError("No 'db_string' value in application configuration.")
db_echo = settings.get('db_echo', 'false')
initialize_sql(db_string, asbool(db_echo))
config = Configurator(settings=settings)
config.begin()
config.add_static_view('static', 'tutorial:static')
config.add_route('home', '/', view='tutorial.views.view_wiki')
config.add_route('view_page', '/:pagename',
view='tutorial.views.view_page',
view_renderer='tutorial:templates/view.pt')
config.add_route('add_page', '/add_page/:pagename',
view='tutorial.views.add_page',
view_renderer='tutorial:templates/edit.pt')
config.add_route('edit_page', '/:pagename/edit_page',
view='tutorial.views.edit_page',
view_renderer='tutorial:templates/edit.pt')
config.end()
return config.make_wsgi_app()
class AddPageTests(unittest.TestCase):
def setUp(self):
self.session = _initTestingDB()
self.config = Configurator()
self.config.begin()
def tearDown(self):
self.session.remove()
self.config.end()
def _callFUT(self, request):
from tutorial.views import add_page
return add_page(request)
def test_it_notsubmitted(self):
_registerRoutes(self.config)
request = testing.DummyRequest()
request.matchdict = {'pagename':'AnotherPage'}
info = self._callFUT(request)
self.assertEqual(info['page'].data,'')
self.assertEqual(info['save_url'],
'http://example.com/add_page/AnotherPage')
def test_it_submitted(self):
from tutorial.models import Page
_registerRoutes(self.config)
request = testing.DummyRequest({'form.submitted':True,
'body':'Hello yo!'})
request.matchdict = {'pagename':'AnotherPage'}
self._callFUT(request)
page = self.session.query(Page).filter_by(name='AnotherPage').one()
self.assertEqual(page.data, 'Hello yo!')
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
import logging
logging.basicConfig(level=logging.DEBUG)
config = Configurator(root_factory=get_root, settings=settings)
config.begin()
from pyramid_jinja2 import renderer_factory
config.add_renderer('.jinja2', renderer_factory)
# configure views, templates
configure(config)
# configure session
import pyramid_beaker
session_factory = pyramid_beaker.session_factory_from_settings(settings)
config.set_session_factory(session_factory)
# configure OpenID-specific storage
import stucco_openid.models
from openid.store import filestore
stucco_openid.models.root.store = \
filestore.FileOpenIDStore(settings['openid.store_file_path'])
config.end()
return config.make_wsgi_app()
class TestSubscriber(unittest.TestCase):
def setUp(self):
registry = DummyRegistry()
from pyramid.configuration import Configurator
self.config = Configurator(registry)
self.config.begin()
def tearDown(self):
self.config.end()
def _makeOne(self, *ifaces):
from pyramid.events import subscriber
return subscriber(*ifaces)
def test_register(self):
from zope.interface import Interface
class IFoo(Interface): pass
class IBar(Interface): pass
dec = self._makeOne(IFoo, IBar)
def foo(): pass
config = DummyConfigurator()
scanner = Dummy()
scanner.config = config
dec.register(scanner, None, foo)
self.assertEqual(config.subscribed, [(foo, (IFoo, IBar))])
def test___call__(self):
dec = self._makeOne()
dummy_venusian = DummyVenusian()
dec.venusian = dummy_venusian
def foo(): pass
dec(foo)
self.assertEqual(dummy_venusian.attached, [(foo, dec.register, 'bfg')])
class Base(object):
def setUp(self):
from pyramid.configuration import Configurator
self.config = Configurator()
self.config.begin()
import os
here = os.path.abspath(os.path.dirname(__file__))
self.templates_dir = os.path.join(here, 'fixtures')
def tearDown(self):
self.config.end()
class BaseViewTests(unittest.TestCase):
def setUp(self):
config['io_device'] = {'class': MockDriver, 'kw':{}}
self.config = Configurator()
self.config.begin()
registerSettings(io_dev='')
self.front_page = get_root(None)
def tearDown(self):
self.config.end()
def app(global_config, **settings):
""" This function returns a WSGI application.
It is usually called by the PasteDeploy framework during
``paster serve``.
"""
config = Configurator(root_factory=get_root, settings=settings)
config.begin()
config.load_zcml('configure.zcml')
config.end()
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
config = Configurator(root_factory=get_root, settings=settings)
config.begin()
config.add_view('som.views.my_view',
context='som.models.MyModel',
renderer='som:templates/mytemplate.pt')
config.add_static_view('static', 'som:static')
config.end()
return config.make_wsgi_app()
def app(global_config, **settings):
db_uri = settings.get('db_uri')
db_name = settings.get('db_name')
if db_uri is None or db_name is None:
raise ValueError("db_uri AND db_name must be defined"
" in application initilization configuration file")
zcml_file = settings.get('configure_zcml', 'configure.zcml')
config = Configurator(root_factory=RootFactory, settings=settings)
config.begin()
config.load_zcml(zcml_file)
config.end()
return config.make_wsgi_app()
class ViewTests(unittest.TestCase):
def setUp(self):
self.config = Configurator()
self.config.begin()
def tearDown(self):
self.config.end()
def test_my_view(self):
from pyramidapp.views import my_view
request = testing.DummyRequest()
info = my_view(request)
self.assertEqual(info['project'], 'pyramidapp')
def app(global_config, **settings):
""" This function returns a WSGI application.
It is usually called by the PasteDeploy framework during
``paster serve``.
"""
config = Configurator(root_factory=get_root, settings=settings)
config.begin()
config.add_view('myproject.views.my_view',
context='myproject.models.MyModel',
renderer='myproject:templates/mytemplate.pt')
config.add_static_view('static', 'myproject:static')
config.end()
return config.make_wsgi_app()
class ViewWikiTests(unittest.TestCase):
def setUp(self):
self.config = Configurator()
self.config.begin()
def tearDown(self):
self.config.end()
def test_it(self):
from tutorial.views import view_wiki
self.config.add_route('view_page', '{pagename}')
request = testing.DummyRequest()
response = view_wiki(request)
self.assertEqual(response.location, 'http://example.com/FrontPage')
class ViewTests(unittest.TestCase):
def setUp(self):
self.config = Configurator()
self.config.begin()
def tearDown(self):
self.config.end()
def test_my_view(self):
from tutorial.views import my_view
context = testing.DummyModel()
request = testing.DummyRequest()
info = my_view(context, request)
self.assertEqual(info['project'], 'tutorial')
class ViewTests(unittest.TestCase):
def setUp(self):
self.config = Configurator()
self.config.begin()
def tearDown(self):
self.config.end()
def test_my_view(self):
from academe.views import my_view
request = testing.DummyRequest()
info = my_view(request)
self.assertEqual(info["project"], "academe")
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
db_string = settings.get('db_string')
if db_string is None:
raise ValueError("No 'db_string' value in application configuration.")
db_echo = settings.get('db_echo', 'false')
initialize_sql(db_string, asbool(db_echo))
config = Configurator(settings=settings)
config.begin()
config.add_static_view('static', 'tutorial:static')
config.add_route('home', '/', view='tutorial.views.my_view',
view_renderer='templates/mytemplate.pt')
config.end()
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
zodb_uri = settings.get('zodb_uri')
if zodb_uri is None:
raise ValueError("No 'zodb_uri' in application configuration.")
finder = PersistentApplicationFinder(zodb_uri, appmaker)
def get_root(request):
return finder(request.environ)
config = Configurator(root_factory=get_root, settings=settings)
config.begin()
config.load_zcml('configure.zcml')
config.end()
return config.make_wsgi_app()
class TestMyView(unittest.TestCase):
def setUp(self):
self.config = Configurator()
self.config.begin()
_initTestingDB()
def tearDown(self):
self.config.end()
def test_it(self):
from tutorial.views import my_view
request = testing.DummyRequest()
info = my_view(request)
self.assertEqual(info['root'].name, 'root')
self.assertEqual(info['project'], 'tutorial')
def app(global_config, **settings):
""" This function returns a WSGI application.
It is usually called by the PasteDeploy framework during
``paster serve``.
"""
config = Configurator(settings=settings)
config.begin()
config.add_static_view('static', 'pyramidapp:static')
config.add_route('home', '/',
view='pyramidapp.views.main_view',
view_renderer='pyramidapp:templates/mytemplate.pt')
config.add_route('tab', '/tab/{name}',
view=view_tab)
config.end()
return config.make_wsgi_app()
def app(global_config, **settings):
""" This function returns a WSGI application.
It is usually called by the PasteDeploy framework during
``paster serve``.
"""
zodb_uri = settings.get('zodb_uri')
if zodb_uri is None:
raise ValueError("No 'zodb_uri' in application configuration.")
finder = PersistentApplicationFinder(zodb_uri, appmaker)
def get_root(request):
return finder(request.environ)
config = Configurator(root_factory=get_root, settings=settings)
config.begin()
config.load_zcml('configure.zcml')
config.end()
return config.make_wsgi_app()
class MyControllerTests(unittest.TestCase):
def setUp(self):
self.config = Configurator()
self.config.begin()
def tearDown(self):
self.config.end()
def _makeOne(self, request):
from sparql_shim.handlers import MyHandler
return MyHandler(request)
def test_index(self):
request = DummyRequest()
controller = self._makeOne(request)
info = controller.index()
self.assertEqual(info['project'], 'sparql_shim')
def app(global_config, **settings):
""" This function returns a WSGI application.
It is usually called by the PasteDeploy framework during
``paster serve``.
"""
zcml_file = settings.get('configure_zcml', 'configure.zcml')
db_string = settings.get('db_string')
if db_string is None:
raise ValueError(
"No 'db_string' value in application configuration.")
db_echo = settings.get('db_echo', 'false')
initialize_sql(db_string, asbool(db_echo))
config = Configurator(settings=settings)
config.begin()
config.load_zcml(zcml_file)
config.end()
return config.make_wsgi_app()
class ViewTests(unittest.TestCase):
def setUp(self):
self.config = Configurator()
self.config.begin()
def tearDown(self):
self.config.end()
def _make_root_with_results(self):
root = testing.DummyModel()
results = testing.DummyModel(__name__='results',
__parent__=root)
root['results'] = results
return root
def test_home_view(self):
from bucket.views import home_view
request = testing.DummyRequest()
context = self._make_root_with_results()
info = home_view(context, request)
self.assertEqual('http://example.com/results/', info['results_url'])
self.assertEqual('http://example.com/results/query.json',
info['all_json_url'])
self.assertEqual('http://example.com/results/query.json'
'?category=People',
info['people_json_url'])
def test_results_view(self):
from bucket.views import results_view
request = testing.DummyRequest()
root = self._make_root_with_results()
context = root['results']
sample_result = testing.DummyModel(__name__='sample',
__parent__=context)
context['sample_result'] = sample_result
info = results_view(context, request)
info_results = info['results']
self.assertEqual(1, len(info_results))
result = info_results[0]
self.assertEqual('http://example.com/results/sample_result/',
result['url'])
self.failIf(result['item'] is None)
def app(global_config, **settings):
""" This function returns a WSGI application.
It is usually called by the PasteDeploy framework during
``paster serve``.
"""
db_string = settings.get('db_string')
if db_string is None:
raise ValueError("No 'db_string' value in application configuration.")
db_echo = settings.get('db_echo', 'false')
initialize_sql(db_string, asbool(db_echo))
authn_policy = AuthTktAuthenticationPolicy(
'sosecret', callback=groupfinder)
authz_policy = ACLAuthorizationPolicy()
config = Configurator(settings=settings,
root_factory='tutorial.models.RootFactory',
authentication_policy=authn_policy,
authorization_policy=authz_policy)
config.begin()
config.add_static_view('static', 'tutorial:static')
config.add_route('view_wiki', '/', view='tutorial.views.view_wiki')
config.add_route('login', '/login',
view='tutorial.login.login',
view_renderer='tutorial:templates/login.pt')
config.add_route('logout', '/logout',
view='tutorial.login.logout')
config.add_route('view_page', '/:pagename',
view='tutorial.views.view_page',
view_renderer='tutorial:templates/view.pt')
config.add_route('add_page', '/add_page/:pagename',
view='tutorial.views.add_page',
view_renderer='tutorial:templates/edit.pt',
view_permission='edit')
config.add_route('edit_page', '/:pagename/edit_page',
view='tutorial.views.edit_page',
view_renderer='tutorial:templates/edit.pt',
view_permission='edit')
config.add_view('tutorial.login.login',
renderer='tutorial:templates/login.pt',
context='pyramid.exceptions.Forbidden')
config.end()
return config.make_wsgi_app()
class MyHandlerTests(unittest.TestCase):
def setUp(self):
from pyramid.configuration import Configurator
from pylonshq.models import initialize_sql
self.session = initialize_sql('sqlite://')
self.config = Configurator()
self.config.begin()
def tearDown(self):
self.config.end()
def _makeOne(self, request):
from pylonshq.handlers import MyHandler
return MyHandler(request)
def test_index(self):
request = DummyRequest()
handler = self._makeOne(request)
info = handler.index()
self.assertEqual(info['project'], 'pylonshq')
self.assertEqual(info['root'].name, 'root')
def mailin_monitor_view(context, request):
"""
Dispatches to a subapp from repoze.mailin.monitor. I know this looks kind
of horrible, but this is the best way I know how to mount another object
graph onto the root object graph in BFG 1.2. BFG 1.3 will theoretically
allow SCRIPT_NAME/PATH_INFO rewriting for routes of the form
'/some/path/*traverse', making it easier to do this with just a route,
rather than actually constituting a whole new bfg app just to serve this
subtree.
"""
global _mailin_monitor_app
if _mailin_monitor_app is None:
# Keep imports local in hopes that this can be removed when BFG 1.3
# comes out.
from pyramid.authorization import ACLAuthorizationPolicy
from pyramid.configuration import Configurator
from karl.models.mailin_monitor import KarlMailInMonitor
from karl.security.policy import get_groups
from pyramid.authentication import RepozeWho1AuthenticationPolicy
authentication_policy = RepozeWho1AuthenticationPolicy(
callback=get_groups
)
authorization_policy = ACLAuthorizationPolicy()
config = Configurator(root_factory=KarlMailInMonitor(),
authentication_policy=authentication_policy,
authorization_policy=authorization_policy)
config.begin()
config.load_zcml('repoze.mailin.monitor:configure.zcml')
config.end()
_mailin_monitor_app = config.make_wsgi_app()
# Dispatch to subapp
from pyramid.request import Request
sub_environ = request.environ.copy()
sub_environ['SCRIPT_NAME'] = '/%s/%s' % (resource_path(context),
request.view_name)
sub_environ['PATH_INFO'] = '/' + '/'.join(request.subpath)
sub_request = Request(sub_environ)
return sub_request.get_response(_mailin_monitor_app)
def app(global_config, **settings):
""" This function returns a WSGI application.
It is usually called by the PasteDeploy framework during
``paster serve``.
"""
zcml_file = settings.get('configure_zcml', 'configure.zcml')
auth = RepozeWho1AuthenticationPolicy(identifier_name='basicauth')
acl = ACLAuthorizationPolicy()
config = Configurator(
root_factory=get_root,
settings=settings,
authorization_policy = acl,
authentication_policy = auth,
)
config.begin()
config.load_zcml(zcml_file)
config.end()
return config.make_wsgi_app()
try:
form.validate(request)
except formish.FormError, e:
log.debug(e)
except Exception, e:
log.debug(e)
return {'form':form, 'form2':form}
def goodbye_world(request):
return Response('Goodbye world!')
class QuietHandler(simple_server.WSGIRequestHandler):
def log_message(self, format, *args): pass
if __name__ == '__main__':
import logging
logging.basicConfig(level=logging.DEBUG)
config = Configurator(settings={'reload_templates':True})
config.begin()
sm = zope.component.getSiteManager()
sm.registerUtility([resource_filename('pyramid_uniform', 'templates/zpt')],
pyramid_formish.IFormishSearchPath)
config.add_static_view('static', 'pyramid_uniform:templates/static')
config.add_view(sample_form, renderer="pyramid_uniform:templates/index.pt")
config.end()
app = config.make_wsgi_app()
simple_server.make_server('', 9876, app, handler_class=QuietHandler).serve_forever()
