.
# All Rights Reserved.
#
# This software is subject to the provisions of the BSD-like license at
# http://www.repoze.org/LICENSE.txt. A copy of the license should accompany
# this distribution. THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL
# EXPRESS OR IMPLIED WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO,
# THE IMPLIED WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND
# FITNESS FOR A PARTICULAR PURPOSE.
#
##############################################################################
from nose.tools import raises
from webtest import TestApp
from tg._compat import u_, unicode_text
from tg import predicates, TGController, expose, config
from tg.configuration import AppConfig
class BasePredicateTester(object):
"""Base test case for predicates."""
def assertEqual(self, val1, val2):
assert val1 == val2, (val1, val2)
def eval_met_predicate(self, p, environ):
"""Evaluate a predicate that should be met"""
self.assertEqual(p.check_authorization(environ), None)
self.assertEqual(p.is_met(environ), True)
def eval_unmet_predicate(self, p, environ, expected_error):
"""Evaluate a predicate that should not be met"""
credentials = environ.get('repoze.what.credentials')
# Testing check_authorization
try:
p.evaluate(environ, credentials)
self.fail('Predicate must not be met; expected error: %s' %
expected_error)
except predicates.NotAuthorizedError as error:
self.assertEqual(unicode_text(error), expected_error)
# Testing is_met:
self.assertEqual(p.is_met(environ), False)
#{ The test suite itself
class TestPredicate(BasePredicateTester):
@raises(NotImplementedError)
def test_evaluate_isnt_implemented(self):
p = MockPredicate()
p.evaluate(None, None)
def test_message_is_changeable(self):
previous_msg = EqualsTwo.message
new_msg = 'It does not equal two!'
p = EqualsTwo(msg=new_msg)
self.assertEqual(new_msg, p.message)
def test_message_isnt_changed_unless_required(self):
previous_msg = EqualsTwo.message
p = EqualsTwo()
self.assertEqual(previous_msg, p.message)
def test_unicode_messages(self):
unicode_msg = u_('请登陆')
p = EqualsTwo(msg=unicode_msg)
environ = {'test_number': 3}
self.eval_unmet_predicate(p, environ, unicode_msg)
def test_authorized(self):
environ = {'test_number': 4}
p = EqualsFour()
p.check_authorization(environ)
def test_unauthorized(self):
environ = {'test_number': 3}
p = EqualsFour(msg="Go away!")
try:
p.check_authorization(environ)
self.fail('Authorization must have been rejected')
except predicates.NotAuthorizedError as e:
self.assertEqual(str(e), "Go away!")
def test_unauthorized_with_unicode_message(self):
# This test is broken on Python 2.4 and 2.5 because the unicode()
# function doesn't work when converting an exception into an unicode
# string (this is, to extract its message).
unicode_msg = u_('请登陆')
environ = {'test_number': 3}
p = EqualsFour(msg=unicode_msg)
try:
p.check_authorization(environ)
self.fail('Authorization must have been rejected')
except predicates.NotAuthorizedError as e:
self.assertEqual(unicode_text(e), unicode_msg)
def test_custom_failure_message(self):
message = u_('This is a custom message whose id is: %(id_number)s')
id_number = 23
p = EqualsFour(msg=message)
try:
p.unmet(message, id_number=id_number)
self.fail('An exception must have been raised')
except predicates.NotAuthorizedError as e:
self.assertEqual(unicode_text(e), message % dict(id_number=id_number))
def test_credentials_dict_when_anonymous(self):
"""The credentials must be a dict even if the user is anonymous"""
class CredentialsPredicate(predicates.Predicate):
message = "Some text"
def evaluate(self, environ, credentials):
if 'something' in credentials:
self.unmet()
# --- Setting the environ up
environ = {}
# --- Testing it:
p = CredentialsPredicate()
self.eval_met_predicate(p, environ)
self.assertEqual(True, p.is_met(environ))
class TestContextRelatedBoolPredicate(BasePredicateTester):
def setup(self):
class RootController(TGController):
@expose()
def test(self):
return str(bool(EqualsTwo()))
conf = AppConfig(minimal=True, root_controller=RootController())
app = conf.make_wsgi_app()
self.app = TestApp(app)
def teardown(self):
config.pop('tg.root_controller', None)
def test_success(self):
ans = self.app.get('/test', extra_environ={'test_number':'2'})
assert 'True' in ans, ans
def test_faillure(self):
ans = self.app.get('/test', extra_environ={'test_number':'4'})
assert 'False' in ans, ans
class TestCompoundPredicate(BasePredicateTester):
def test_one_predicate_works(self):
p = EqualsTwo()
cp = predicates.CompoundPredicate(p)
self.assertEqual(cp.predicates, (p,))
def test_two_predicates_work(self):
p1 = EqualsTwo()
p2 = MockPredicate()
cp = predicates.CompoundPredicate(p1, p2)
self.assertEqual(cp.predicates, (p1, p2))
class TestNotPredicate(BasePredicateTester):
def test_failure(self):
environ = {'test_number': 4}
# It must NOT equal 4
p = predicates.Not(EqualsFour())
# It equals 4!
self.eval_unmet_predicate(p, environ, 'The condition must not be met')
def test_failure_with_custom_message(self):
environ = {'test_number': 4}
# It must not equal 4
p = predicates.Not(EqualsFour(), msg='It must not equal four')
# It equals 4!
self.eval_unmet_predicate(p, environ, 'It must not equal four')
def test_success(self):
environ = {'test_number': 5}
# It must not equal 4
p = predicates.Not(EqualsFour())
# It doesn't equal 4!
self.eval_met_predicate(p, environ)
class TestAllPredicate(BasePredicateTester):
def test_one_true(self):
environ = {'test_number': 2}
p = predicates.All(EqualsTwo())
self.eval_met_predicate(p, environ)
def test_one_false(self):
environ = {'test_number': 3}
p = predicates.All(EqualsTwo())
self.eval_unmet_predicate(p, environ, "Number 3 doesn't equal 2")
def test_two_true(self):
environ = {'test_number': 4}
p = predicates.All(EqualsFour(), GreaterThan(3))
self.eval_met_predicate(p, environ)
def test_two_false(self):
environ = {'test_number': 1}
p = predicates.All(EqualsFour(), GreaterThan(3))
self.eval_unmet_predicate(p, environ, "Number 1 doesn't equal 4")
def test_two_mixed(self):
environ = {'test_number': 5}
p = predicates.All(EqualsFour(), GreaterThan(3))
self.eval_unmet_predicate(p, environ, "Number 5 doesn't equal 4")
class TestAnyPredicate(BasePredicateTester):
def test_one_true(self):
environ = {'test_number': 2}
p = predicates.Any(EqualsTwo())
self.eval_met_predicate(p, environ)
def test_one_false(self):
environ = {'test_number': 3}
p = predicates.Any(EqualsTwo())
self.eval_unmet_predicate(p, environ,
"At least one of the following predicates must be "
"met: Number 3 doesn't equal 2")
def test_two_true(self):
environ = {'test_number': 4}
p = predicates.Any(EqualsFour(), GreaterThan(3))
self.eval_met_predicate(p, environ)
def test_two_false(self):
environ = {'test_number': 1}
p = predicates.Any(EqualsFour(), GreaterThan(3))
self.eval_unmet_predicate(p, environ,
"At least one of the following predicates must be "
"met: Number 1 doesn't equal 4, 1 is not greater "
"than 3")
def test_two_mixed(self):
environ = {'test_number': 5}
p = predicates.Any(EqualsFour(), GreaterThan(3))
self.eval_met_predicate(p, environ)
class TestIsUserPredicate(BasePredicateTester):
def test_user_without_credentials(self):
environ = {}
p = predicates.is_user('gustavo')
self.eval_unmet_predicate(p, environ,
'The current user must be "gustavo"')
def test_user_without_userid(self):
environ = {'repoze.what.credentials': {}}
p = predicates.is_user('gustavo')
self.eval_unmet_predicate(p, environ,
'The current user must be "gustavo"')
def test_right_user(self):
environ = make_environ('gustavo')
p = predicates.is_user('gustavo')
self.eval_met_predicate(p, environ)
def test_wrong_user(self):
environ = make_environ('andreina')
p = predicates.is_user('gustavo')
self.eval_unmet_predicate(p, environ,
'The current user must be "gustavo"')
class TestInGroupPredicate(BasePredicateTester):
def test_user_belongs_to_group(self):
environ = make_environ('gustavo', ['developers'])
p = predicates.in_group('developers')
self.eval_met_predicate(p, environ)
def test_user_doesnt_belong_to_group(self):
environ = make_environ('gustavo', ['developers', 'admins'])
p = predicates.in_group('designers')
self.eval_unmet_predicate(p, environ,
'The current user must belong to the group "designers"')
class TestInAllGroupsPredicate(BasePredicateTester):
def test_user_belongs_to_groups(self):
environ = make_environ('gustavo', ['developers', 'admins'])
p = predicates.in_all_groups('developers', 'admins')
self.eval_met_predicate(p, environ)
def test_user_doesnt_belong_to_groups(self):
environ = make_environ('gustavo', ['users', 'admins'])
p = predicates.in_all_groups('developers', 'designers')
self.eval_unmet_predicate(p, environ,
'The current user must belong to the group "developers"')
def test_user_doesnt_belong_to_one_group(self):
environ = make_environ('gustavo', ['developers'])
p = predicates.in_all_groups('developers', 'designers')
self.eval_unmet_predicate(p, environ,
'The current user must belong to the group "designers"')
class TestInAnyGroupsPredicate(BasePredicateTester):
def test_user_belongs_to_groups(self):
environ = make_environ('gustavo', ['developers',' admins'])
p = predicates.in_any_group('developers', 'admins')
self.eval_met_predicate(p, environ)
def test_user_doesnt_belong_to_groups(self):
environ = make_environ('gustavo', ['users', 'admins'])
p = predicates.in_any_group('developers', 'designers')
self.eval_unmet_predicate(p, environ,
'The member must belong to at least one of the '
'following groups: developers, designers')
def test_user_doesnt_belong_to_one_group(self):
environ = make_environ('gustavo', ['designers'])
p = predicates.in_any_group('developers', 'designers')
self.eval_met_predicate(p, environ)
class TestIsAnonymousPredicate(BasePredicateTester):
def test_authenticated_user(self):
environ = make_environ('gustavo')
p = predicates.is_anonymous()
self.eval_unmet_predicate(p, environ,
'The current user must be anonymous')
def test_anonymous_user(self):
environ = {}
p = predicates.is_anonymous()
self.eval_met_predicate(p, environ)
class TestNotAnonymousPredicate(BasePredicateTester):
def test_authenticated_user(self):
environ = make_environ('gustavo')
p = predicates.not_anonymous()
self.eval_met_predicate(p, environ)
def test_anonymous_user(self):
environ = {}
p = predicates.not_anonymous()
self.eval_unmet_predicate(p, environ,
'The current user must have been authenticated')
class TestHasPermissionPredicate(BasePredicateTester):
def test_user_has_permission(self):
environ = make_environ('gustavo', permissions=['watch-tv'])
p = predicates.has_permission('watch-tv')
self.eval_met_predicate(p, environ)
def test_user_doesnt_have_permission(self):
environ = make_environ('gustavo', permissions=['watch-tv'])
p = predicates.has_permission('eat')
self.eval_unmet_predicate(p, environ,
'The user must have the "eat" permission')
class TestHasAllPermissionsPredicate(BasePredicateTester):
def test_user_has_all_permissions(self):
environ = make_environ('gustavo', permissions=['watch-tv', 'party',
'eat'])
p = predicates.has_all_permissions('watch-tv', 'eat')
self.eval_met_predicate(p, environ)
def test_user_doesnt_have_permissions(self):
environ = make_environ('gustavo', permissions=['watch-tv', 'party',
'eat'])
p = predicates.has_all_permissions('jump', 'scream')
self.eval_unmet_predicate(p, environ,
'The user must have the "jump" permission')
def test_user_has_one_permission(self):
environ = make_environ('gustavo', permissions=['watch-tv', 'party',
'eat'])
p = predicates.has_all_permissions('party', 'scream')
self.eval_unmet_predicate(p, environ,
'The user must have the "scream" permission')
class TestUserHasAnyPermissionsPredicate(BasePredicateTester):
def test_user_has_all_permissions(self):
environ = make_environ('gustavo', permissions=['watch-tv', 'party',
'eat'])
p = predicates.has_any_permission('watch-tv', 'eat')
self.eval_met_predicate(p, environ)
def test_user_doesnt_have_all_permissions(self):
environ = make_environ('gustavo', permissions=['watch-tv', 'party',
'eat'])
p = predicates.has_any_permission('jump', 'scream')
self.eval_unmet_predicate(p, environ,
'The user must have at least one of the following '
'permissions: jump, scream')
def test_user_has_one_permission(self):
environ = make_environ('gustavo', permissions=['watch-tv', 'party',
'eat'])
p = predicates.has_any_permission('party', 'scream')
self.eval_met_predicate(p, environ)
#{ Test utilities
def make_environ(user, groups=None, permissions=None):
"""Make a WSGI enviroment with the credentials dict"""
credentials = {'repoze.what.userid': user}
credentials['groups'] = groups or []
credentials['permissions'] = permissions or []
environ = {'repoze.what.credentials': credentials}
return environ
#{ Mock definitions
class MockPredicate(predicates.Predicate):
message = "I'm a fake predicate"
class EqualsTwo(predicates.Predicate):
message = "Number %(number)s doesn't equal 2"
def evaluate(self, environ, credentials):
number = environ.get('test_number')
if not number or int(number) != 2:
self.unmet(number=number)
class EqualsFour(predicates.Predicate):
message = "Number %(number)s doesn't equal 4"
def evaluate(self, environ, credentials):
number = environ.get('test_number')
if number == 4:
return
self.unmet(number=number)
class GreaterThan(predicates.Predicate):
message = "%(number)s is not greater than %(compared_number)s"
def __init__(self, compared_number, **kwargs):
super(GreaterThan, self).__init__(**kwargs)
self.compared_number = compared_number
def evaluate(self, environ, credentials):
number = environ.get('test_number')
if not number > self.compared_number:
self.unmet(number=number, compared_number=self.compared_number)
class LessThan(predicates.Predicate):
message = "%(number)s must be less than %(compared_number)s"
def __init__(self, compared_number, **kwargs):
super(LessThan, self).__init__(**kwargs)
self.compared_number = compared_number
def evaluate(self, environ, credentials):
number = environ.get('test_number')
if not number < self.compared_number:
self.unmet(number=number, compared_number=self.compared_number)
TurboGears2-2.3.7/tests/test_render.py 0000644 0000765 0000024 00000012412 12555020522 017765 0 ustar amol staff 0000000 0000000 """
Testing for TG2 Configuration
"""
from nose.tools import raises
import tg
from tg.render import MissingRendererError, _get_tg_vars
from tests.base import setup_session_dir, teardown_session_dir
from tg.configuration import AppConfig
from mako.exceptions import TemplateLookupException
from tg.util.webtest import test_context
def setup():
setup_session_dir()
def teardown():
teardown_session_dir()
class FakePackage:
__name__ = 'tests'
__file__ = __file__
class lib:
class app_globals:
class Globals:
pass
@raises(MissingRendererError)
def test_render_missing_renderer():
conf = AppConfig(minimal=True)
app = conf.make_wsgi_app()
tg.render_template({}, 'gensh')
def test_jinja_lookup_nonexisting_template():
conf = AppConfig(minimal=True)
conf.use_dotted_templatenames = True
conf.renderers.append('jinja')
conf.package = FakePackage()
app = conf.make_wsgi_app()
from jinja2 import TemplateNotFound
try:
render_jinja = conf.render_functions['jinja']
render_jinja('tg.this_template_does_not_exists',
{'app_globals':tg.config['tg.app_globals']})
assert False
except TemplateNotFound:
pass
class TestMakoLookup(object):
def setup(self):
conf = AppConfig(minimal=True)
conf.use_dotted_templatenames = True
conf.renderers.append('mako')
conf.package = FakePackage()
self.conf = conf
self.app = conf.make_wsgi_app()
def test_adjust_uri(self):
render_mako = self.conf.render_functions['mako']
mlookup = render_mako.loader
assert mlookup.adjust_uri('this_template_should_pass_unaltered', None) == 'this_template_should_pass_unaltered'
dotted_test = mlookup.adjust_uri('tests.test_stack.rendering.templates.mako_inherits_local', None)
assert dotted_test.endswith('tests/test_stack/rendering/templates/mako_inherits_local.mak')
dotted_test = mlookup.adjust_uri('local:test_stack.rendering.templates.mako_inherits_local', None)
assert dotted_test.endswith('tests/test_stack/rendering/templates/mako_inherits_local.mak')
def test_local_lookup(self):
render_mako = self.conf.render_functions['mako']
res = render_mako('tests.test_stack.rendering.templates.mako_inherits_local',
{'app_globals':tg.config['tg.app_globals']})
assert 'inherited mako page' in res
def test_passthrough_text_literal__check(self):
from mako.template import Template
t = Template('Hi')
render_mako = self.conf.render_functions['mako']
mlookup = render_mako.loader
mlookup.template_cache['hi_template'] = t
assert mlookup.get_template('hi_template') is t
@raises(TemplateLookupException)
def test__check_not_existing_anymore(self):
from mako.template import Template
t = Template('Hi', filename='deleted_template.mak')
render_mako = self.conf.render_functions['mako']
mlookup = render_mako.loader
mlookup.template_cache['deleted_template'] = t
mlookup.get_template('deleted_template')
@raises(IOError)
def test_never_existed(self):
render_mako = self.conf.render_functions['mako']
mlookup = render_mako.loader
mlookup.get_template('deleted_template')
def test__check_should_reload_on_cache_expire(self):
render_mako = self.conf.render_functions['mako']
mlookup = render_mako.loader
template_path = mlookup.adjust_uri('tests.test_stack.rendering.templates.mako_inherits_local', None)
t = mlookup.get_template(template_path) #cache the template
t.output_encoding = 'FAKE_ENCODING'
t = mlookup.get_template(template_path)
assert t.output_encoding == 'FAKE_ENCODING'
import os, stat
def fake_os_stat(o):
return {stat.ST_MTIME:t.module._modified_time+1}
old_stat = os.stat
os.stat = fake_os_stat
try:
t = mlookup.get_template(template_path)
#if the template got reloaded should not have our fake encoding anymore
assert t.output_encoding != 'FAKE_ENCODING'
finally:
os.stat = old_stat
def test__check_should_not_reload_when_disabled(self):
render_mako = self.conf.render_functions['mako']
mlookup = render_mako.loader
mlookup.auto_reload = False
template_path = mlookup.adjust_uri('tests.test_stack.rendering.templates.mako_inherits_local', None)
t = mlookup.get_template(template_path) #cache the template
t.output_encoding = 'FAKE_ENCODING'
t = mlookup.get_template(template_path)
assert t.output_encoding == 'FAKE_ENCODING'
import os, stat
def fake_os_stat(o):
return {stat.ST_MTIME:t.module._modified_time+1}
old_stat = os.stat
os.stat = fake_os_stat
try:
t = mlookup.get_template(template_path)
assert t.output_encoding == 'FAKE_ENCODING'
finally:
os.stat = old_stat
def test_fallback_validation_context_in_templates(self):
with test_context(None, '/'):
vars = _get_tg_vars()
assert vars.tg.errors == {}, vars.tg
assert vars.tg.inputs == {}, vars.tg TurboGears2-2.3.7/tests/test_rest_controller_dispatch.py 0000644 0000765 0000024 00000051376 12413576166 023636 0 ustar amol staff 0000000 0000000 # -*- coding: utf-8 -*-
from webob import Response, Request
from tg.controllers import TGController, RestController
from tg.decorators import expose
from tg.util import no_warn
from tests.base import (
TestWSGIController, make_app, setup_session_dir, teardown_session_dir)
def setup():
setup_session_dir()
def teardown():
teardown_session_dir()
def wsgi_app(environ, start_response):
req = Request(environ)
if req.method == 'POST':
resp = Response(req.POST['data'])
else:
resp = Response("Hello from %s/%s"%(req.script_name, req.path_info))
return resp(environ, start_response)
class LookupHelper:
def __init__(self, var):
self.var = var
@expose()
def index(self):
return self.var
class LookupController(TGController):
@expose()
def _lookup(self, a, *args):
return LookupHelper(a), args
class DeprecatedLookupController(TGController):
@expose()
def _lookup(self, a, *args):
return LookupHelper(a), args
class LookupAlwaysHelper:
"""for testing _dispatch"""
def __init__(self, var):
self.var = var
def _setup_wsgiorg_routing_args(self, url_path, remainder, params):
pass
@expose()
def always(self, *args, **kwargs):
return 'always go here'
def _dispatch(self, state, remainder):
state.add_method(self.always, remainder)
return state
class LookupAlwaysController(TGController):
@expose()
def _lookup(self, a, *args):
return LookupAlwaysHelper(a), args
class CustomDispatchingSubController(TGController):
@expose()
def always(self, *args, **kwargs):
return 'always go here'
def _dispatch(self, state, remainder):
state.add_method(self.always, remainder)
return state
class OptionalArgumentRestController(RestController):
@expose()
def get_one(self, optional=None):
return "SUBREST GET ONE"
@expose()
def put(self, optional=None):
return "subrest put"
@expose()
def post(self, optional=None):
return "subrest post"
@expose()
def edit(self, optional=None):
return "subrest edit"
@expose()
def new(self, optional=None):
return "subrest new"
@expose()
def get_delete(self, optional=None):
return "subrest get delete"
@expose()
def post_delete(self, optional=None):
return "subrest post delete"
class RequiredArgumentRestController(RestController):
@expose()
def get_one(self, something):
return "subrest get one"
@expose()
def put(self, something):
return "subrest put"
@expose()
def post(self, something):
return "subrest post"
@expose()
def edit(self, something):
return "subrest edit"
@expose()
def new(self):
return "subrest new"
@expose()
def get_delete(self, something):
return "subrest get delete"
@expose()
def post_delete(self, something):
return "subrest post delete"
class VariableSubRestController(RestController):
@expose()
def get_one(self, *args):
return "subrest get one"
@expose()
def put(self, *args):
return "subrest put"
@expose()
def edit(self, *args):
return "subrest edit"
@expose()
def new(self, *args):
return "subrest new"
@expose()
def get_delete(self, *args):
return "subrest get delete"
@expose()
def post_delete(self, *args):
return "subrest post delete"
class SubRestController(RestController):
@expose()
def get_all(self):
return "subrest get all"
@expose()
def get_one(self, nr):
return "subrest get one %s" % nr
@expose()
def new(self):
return "subrest new"
@expose()
def edit(self, nr):
return "subrest edit %s" % nr
@expose()
def post(self):
return "subrest post"
@expose()
def put(self, nr):
return "subrest put %s" % nr
@expose()
def fxn(self):
return "subrest fxn"
@expose()
def get_delete(self, nr):
return "subrest get delete %s" % nr
@expose()
def post_delete(self, nr):
return "subrest post delete %s" % nr
class VariableRestController(RestController):
subrest = SubRestController()
vsubrest = VariableSubRestController()
@expose()
def get_all(self):
return "rest get all"
@expose()
def get_one(self, *args):
return "rest get onE"
@expose()
def get_delete(self, *args):
return "rest get delete"
@expose()
def post_delete(self, *args):
return "rest post delete"
class ExtraRestController(RestController):
@expose()
def get_all(self):
return "rest get all"
@expose()
def get_one(self, nr):
return "rest get one %s" % nr
@expose()
def get_delete(self, nr):
return "rest get delete %s" % nr
@expose()
def post_delete(self, nr):
return "rest post delete %s" % nr
class SubClass(TGController):
@expose()
def index(self):
return "rest sub index"
sub = SubClass()
subrest = SubRestController()
optsubrest = OptionalArgumentRestController()
reqsubrest = RequiredArgumentRestController()
@expose()
def post_archive(self):
return 'got to post archive'
@expose()
def get_archive(self):
return 'got to get archive'
class BasicRestController(RestController):
@expose()
def get(self):
return "rest get"
@expose()
def post(self):
return "rest post"
@expose()
def put(self):
return "rest put"
@expose()
def delete(self):
return "rest delete"
@expose()
def new(self):
return "rest new"
@expose()
def edit(self, *args, **kw):
return "rest edit"
@expose()
def other(self):
return "rest other"
@expose()
def archive(self):
return 'got to archive'
class EmptyRestController(RestController):
pass
class SubController(TGController):
rest = BasicRestController()
@expose()
def sub_method(self, arg):
return 'sub %s'%arg
class BasicTGController(TGController):
sub = SubController()
custom_dispatch = CustomDispatchingSubController()
lookup = LookupController()
deprecated_lookup = LookupController()
lookup_dispatch = LookupAlwaysController()
rest = BasicRestController()
rest2 = ExtraRestController()
rest3 = VariableRestController()
empty = EmptyRestController()
@expose()
def index(self, **kwargs):
return 'hello world'
@expose()
def _default(self, *remainder):
return "Main default page called for url /%s" % [str(r) for r in remainder]
@expose()
def hello(self, name, silly=None):
return "Hello %s" % name
class BasicTGControllerNoDefault(TGController):
@expose()
def index(self, **kwargs):
return 'hello world'
class TestTGControllerRoot(TestWSGIController):
def __init__(self, *args, **kargs):
TestWSGIController.__init__(self, *args, **kargs)
self.app = make_app(BasicTGControllerNoDefault)
def test_root_default_dispatch(self):
self.app.get('/i/am/not/a/sub/controller', status=404)
class TestTGController(TestWSGIController):
def __init__(self, *args, **kargs):
TestWSGIController.__init__(self, *args, **kargs)
self.app = make_app(BasicTGController)
def test_lookup(self):
r = self.app.get('/lookup/eye')
msg = 'eye'
assert msg in r, r
def test_deprecated_lookup(self):
r = self.app.get('/deprecated_lookup/eye')
msg = 'eye'
assert msg in r, r
def test_lookup_with_dispatch(self):
r = self.app.get('/lookup_dispatch/eye')
msg = 'always'
assert msg in r, r
def test_root_method_dispatch(self):
resp = self.app.get('/hello/Bob')
assert "Hello Bob" in resp, resp
def test_root_index_dispatch(self):
resp = self.app.get('/')
assert "hello world" in resp, resp
def test_no_sub_index_dispatch(self):
resp = self.app.get('/sub/')
assert "['sub']" in resp, resp
def test_root_default_dispatch(self):
resp = self.app.get('/i/am/not/a/sub/controller')
assert "['i', 'am', 'not', 'a', 'sub', 'controller']" in resp, resp
def test_default_dispatch_not_found_in_sub_controller(self):
resp = self.app.get('/sub/no/default/found')
assert "['sub', 'no', 'default', 'found']" in resp, resp
def test_root_method_dispatch_with_trailing_slash(self):
resp = self.app.get('/hello/Bob/')
assert "Hello Bob" in resp, resp
def test_sub_method_dispatch(self):
resp = self.app.get('/sub/sub_method/army of darkness')
assert "sub army" in resp, resp
def test_custom_dispatch(self):
resp = self.app.get('/custom_dispatch/army of darkness')
assert "always" in resp, resp
class TestRestController(TestWSGIController):
def __init__(self, *args, **kargs):
TestWSGIController.__init__(self, *args, **kargs)
self.app = make_app(BasicTGController)
def test_post(self):
r = self.app.post('/rest/')
assert 'rest post' in r, r
def _test_non_resty(self):
r = self.app.post('/rest/non_resty_thing')
assert 'non_resty' in r, r
def test_custom_action_simple_get(self):
r = self.app.get('/rest/archive')
assert 'got to archive' in r, r
def test_custom_action_simple_post(self):
r = self.app.post('/rest/archive')
assert 'got to archive' in r, r
def test_custom_action_simple_post_args(self):
r = self.app.post('/rest?_method=archive')
assert 'got to archive' in r, r
def test_custom_action_get(self):
r = self.app.get('/rest2/archive')
assert 'got to get archive' in r, r
def test_custom_action_post(self):
r = self.app.post('/rest2?_method=archive')
assert 'got to post archive' in r, r
def test_get(self):
r = self.app.get('/rest/')
assert 'rest get' in r, r
def test_put(self):
r = self.app.put('/rest/')
assert 'rest put' in r, r
def test_put_post(self):
r = self.app.post('/rest?_method=PUT')
assert 'rest put' in r, r
def test_put_post_params(self):
r = self.app.post('/rest', params={'_method':'PUT'})
assert 'rest put' in r, r
def test_put_get(self):
self.app.get('/rest?_method=PUT', status=405)
def test_get_delete_bad(self):
self.app.get('/rest?_method=DELETE', status=405)
def test_delete(self):
r = self.app.delete('/rest/')
assert 'rest delete' in r, r
def test_post_delete(self):
r = self.app.post('/rest/', params={'_method':'DELETE'})
assert 'rest delete' in r, r
def test_get_all(self):
r = self.app.get('/rest2/')
assert 'rest get all' in r, r
def test_get_one(self):
r = self.app.get('/rest2/1')
assert 'rest get one 1' in r, r
def test_get_delete(self):
r = self.app.get('/rest2/1/delete')
assert 'rest get delete' in r, r
def test_post_delete_params(self):
r = self.app.post('/rest2/1', params={'_method':'DELETE'})
assert 'rest post delete' in r, r
def test_post_delete_var(self):
r = self.app.post('/rest3/a/b/c', params={'_method':'DELETE'})
assert 'rest post delete' in r, r
def test_get_delete_var(self):
r = self.app.get('/rest3/a/b/c/delete')
assert 'rest get delete' in r, r
def test_get_method(self):
r = self.app.get('/rest/other')
assert 'rest other' in r, r
@no_warn
def test_get_sub_controller(self):
r = self.app.get('/rest2/sub')
assert 'rest sub index' in r, r
@no_warn
def test_put_sub_controller(self):
r = self.app.put('/rest2/sub')
assert 'rest sub index' in r, r
def test_post_sub_controller(self):
r = self.app.post('/rest2/sub')
assert 'rest sub index' in r, r
def test_post_miss(self):
r = self.app.post('/rest2/something')
assert "/['rest2', 'something']" in r, r
def test_get_empty(self):
r = self.app.get('/empty/')
assert "/['empty']" in r, r
def test_post_empty(self):
r = self.app.post('/empty/')
assert "/['empty']" in r, r
def test_put_empty(self):
r = self.app.put('/empty/')
assert "/['empty']" in r, r
@no_warn
def test_delete_empty(self):
r = self.app.delete('/empty/')
assert "/['empty']" in r, r
def test_put_miss(self):
r = self.app.put('/rest/something')
assert "/['rest', 'something']" in r, r
def test_delete_miss(self):
r = self.app.delete('/rest/something')
assert "/['rest', 'something']" in r, r
def test_get_miss(self):
r = self.app.get('/rest2/something/else')
assert "/['rest2', 'something', 'else']" in r, r
def test_post_method(self):
r = self.app.post('/rest/other')
assert 'rest other' in r, r
def test_new_method(self):
r = self.app.post('/rest/new')
assert 'rest new' in r, r
def test_edit_method(self):
r = self.app.get('/rest/1/edit')
assert 'rest edit' in r, r
def test_delete_method(self):
self.app.delete('/rest/other', status=405)
def test_sub_with_rest_delete(self):
r = self.app.delete('/sub/rest/')
assert 'rest delete' in r, r
def test_put_method(self):
r = self.app.put('/rest/other')
assert 'rest other' in r, r
def test_sub_get_all_method(self):
r = self.app.get('/rest2/1/subrest')
assert 'subrest get all' in r, r
def test_var_sub_get_all_method(self):
r = self.app.get('/rest3/1/3/3/subrest')
assert 'subrest get all' in r, r
r = self.app.get('/rest3/1/3/subrest')
assert 'subrest get all' in r, r
r = self.app.get('/rest3/subrest')
assert 'subrest get all' in r, r
def test_var_sub_get_one_method(self):
r = self.app.get('/rest3/1/3/3/subrest/1')
assert 'subrest get one' in r, r
r = self.app.get('/rest3/1/3/subrest/1')
assert 'subrest get one' in r, r
r = self.app.get('/rest3/subrest/1')
assert 'subrest get one' in r, r
def test_var_sub_edit_method(self):
r = self.app.get('/rest3/1/3/3/subrest/1/edit')
assert 'subrest edit' in r, r
r = self.app.get('/rest3/1/3/subrest/1/edit')
assert 'subrest edit' in r, r
r = self.app.get('/rest3/subrest/1/edit')
assert 'subrest edit' in r, r
def test_var_sub_edit_var_method(self):
r = self.app.get('/rest3/1/3/3/vsubrest/1/edit')
assert 'subrest edit' in r, r
r = self.app.get('/rest3/1/3/vsubrest/1/a/edit')
assert 'subrest edit' in r, r
r = self.app.get('/rest3/vsubrest/edit')
assert 'subrest edit' in r, r
def test_var_sub_delete_method(self):
r = self.app.get('/rest3/1/3/3/subrest/1/delete')
assert 'subrest get delete' in r, r
r = self.app.get('/rest3/1/3/subrest/1/delete')
assert 'subrest get delete' in r, r
r = self.app.get('/rest3/subrest/1/delete')
assert 'subrest get delete' in r, r
def test_var_sub_new_method(self):
r = self.app.get('/rest3/1/3/3/subrest/new')
assert 'subrest new' in r, r
r = self.app.get('/rest3/1/3/subrest/new')
assert 'subrest new' in r, r
r = self.app.get('/rest3/subrest/new')
assert 'subrest new' in r, r
def test_var_sub_var_get_one_method(self):
r = self.app.get('/rest3/1/3/3/vsubrest/1')
assert 'subrest get one' in r, r
r = self.app.get('/rest3/1/3/vsubrest/1/a')
assert 'subrest get one' in r, r
r = self.app.get('/rest3/vsubrest/')
assert 'subrest get one' in r, r
def test_var_sub_var_put_method(self):
r = self.app.put('/rest3/1/3/3/vsubrest/1')
assert 'subrest put' in r, r
r = self.app.put('/rest3/1/3/vsubrest/1/asdf')
assert 'subrest put' in r, r
r = self.app.put('/rest3/vsubrest/')
assert 'subrest put' in r, r
def test_var_sub_post_method(self):
r = self.app.post('/rest3/1/3/3/subrest/')
assert 'subrest post' in r, r
r = self.app.post('/rest3/1/3/subrest/')
assert 'subrest post' in r, r
r = self.app.post('/rest3/subrest/')
assert 'subrest post' in r, r
def test_var_sub_post_delete_method(self):
r = self.app.delete('/rest3/1/3/3/subrest/1')
assert 'subrest post delete' in r, r
r = self.app.delete('/rest3/1/3/subrest/1')
assert 'subrest post delete' in r, r
def test_var_sub_put_method(self):
r = self.app.put('/rest3/1/3/3/subrest/1')
assert 'subrest put' in r, r
r = self.app.put('/rest3/1/3/subrest/1')
assert 'subrest put' in r, r
r = self.app.put('/rest3/subrest/1')
assert 'subrest put' in r, r
def test_var_sub_put_hack_method(self):
r = self.app.post('/rest3/1/3/3/subrest/1?_method=PUT')
assert 'subrest put' in r, r
r = self.app.post('/rest3/1/3/subrest/1?_method=put')
assert 'subrest put' in r, r
r = self.app.post('/rest3/subrest/1?_method=put')
assert 'subrest put' in r, r
def test_var_sub_var_delete_method(self):
r = self.app.delete('/rest3/1/3/3/vsubrest/1')
assert 'subrest post delete' in r, r
r = self.app.delete('/rest3/1/3/vsubrest/1')
assert 'subrest post delete' in r, r
r = self.app.delete('/rest3/vsubrest/')
assert 'subrest post delete' in r, r
def test_var_sub_delete_var_hack_method(self):
r = self.app.post('/rest3/1/3/3/vsubrest/1?_method=DELETE')
assert 'subrest post delete' in r, r
r = self.app.post('/rest3/1/3/vsubrest/1?_method=delete')
assert 'subrest post delete' in r, r
r = self.app.post('/rest3/vsubrest?_method=delete')
assert 'subrest post delete' in r, r
def test_var_sub_var_put_hack_method(self):
r = self.app.post('/rest3/1/3/3/vsubrest/1?_method=PUT')
assert 'subrest put' in r, r
r = self.app.post('/rest3/1/3/vsubrest/1/a?_method=put')
assert 'subrest put' in r, r
r = self.app.post('/rest3/vsubrest/?_method=put')
assert 'subrest put' in r, r
def test_var_sub_delete_hack_method(self):
r = self.app.post('/rest3/1/3/3/subrest/1?_method=DELETE')
assert 'subrest post delete' in r, r
r = self.app.post('/rest3/1/3/subrest/1?_method=delete')
assert 'subrest post delete' in r, r
r = self.app.post('/rest3/subrest/1?_method=delete')
assert 'subrest post delete' in r, r
def test_sub_new(self):
r = self.app.get('/rest2/1/subrest/new')
assert 'subrest new' in r, r
def test_sub_edit(self):
r = self.app.get('/rest2/1/subrest/1/edit')
assert 'subrest edit' in r, r
def test_sub_post(self):
r = self.app.post('/rest2/1/subrest/')
assert 'subrest post' in r, r
def test_sub_put(self):
r = self.app.put('/rest2/1/subrest/2')
assert 'subrest put' in r, r
def test_sub_post_opt(self):
r = self.app.post('/rest2/1/optsubrest/1')
assert 'subrest post' in r, r
def test_sub_put_opt(self):
r = self.app.put('/rest2/1/optsubrest/1')
assert 'subrest put' in r, r
def test_sub_put_opt_hack(self):
r = self.app.post('/rest2/1/optsubrest/1?_method=PUT')
assert 'subrest put' in r, r
def test_sub_delete_opt_hack(self):
r = self.app.post('/rest2/1/optsubrest/1?_method=DELETE')
assert 'subrest ' in r, r
def test_put_post_req(self):
r = self.app.post('/rest2/reqsubrest', params={'something':'required'})
assert 'subrest post' in r, r
def test_sub_put_req(self):
r = self.app.post('/rest2/reqsubrest', params={'_method':'PUT', 'something':'required'})
assert 'subrest put' in r, r
def test_sub_post_req_bad(self):
r = self.app.post('/rest2/reqsubrest',)
assert "['rest2', 'reqsubrest']" in r, r
def test_sub_delete_hack(self):
r = self.app.post('/rest2/1/subrest/2?_method=DELETE')
assert 'subrest post delete' in r, r
def test_sub_get_delete(self):
r = self.app.get('/rest2/1/subrest/2/delete')
assert 'subrest get delete' in r, r
def test_sub_post_delete(self):
r = self.app.delete('/rest2/1/subrest/2')
assert 'subrest post delete' in r, r
def test_sub_get_fxn(self):
r = self.app.get('/rest2/1/subrest/fxn')
assert 'subrest fxn' in r, r
def test_sub_post_fxn(self):
r = self.app.post('/rest2/1/subrest/fxn')
assert 'subrest fxn' in r, r
TurboGears2-2.3.7/tests/test_stack/ 0000755 0000765 0000024 00000000000 12607177763 017263 5 ustar amol staff 0000000 0000000 TurboGears2-2.3.7/tests/test_stack/__init__.py 0000644 0000765 0000024 00000004431 12607177564 021375 0 ustar amol staff 0000000 0000000 import os
from webtest import TestApp
import tg
import tests
from tg.util import DottedFileNameFinder
from tg.configuration import AppConfig
from tg.configuration import milestones
from tg._compat import PY3
class TestConfig(AppConfig):
__test__ = False
def __init__(self, folder, values=None):
if values is None:
values = {}
AppConfig.__init__(self)
# First we setup some base values that we know will work
self.renderers = ['genshi', 'mako', 'jinja','json', 'jsonp', 'kajiki']
self.render_functions = tg.util.Bunch()
self.package = tests.test_stack
self.default_renderer = 'genshi'
self.globals = self
self.auth_backend = None
self.auto_reload_templates = False
self.use_legacy_renderer = False
self.use_dotted_templatenames = False
self.serve_static = False
self['errorpage.enabled'] = False
root = os.path.dirname(os.path.dirname(tests.__file__))
test_base_path = os.path.join(root,'tests', 'test_stack',)
test_config_path = os.path.join(test_base_path, folder)
self.paths = tg.util.Bunch(
root=test_base_path,
controllers=os.path.join(test_config_path, 'controllers'),
static_files=os.path.join(test_config_path, 'public'),
templates=[os.path.join(test_config_path, 'templates')],
i18n=os.path.join(test_config_path, 'i18n')
)
# then we override those values with what was passed in
for key, value in values.items():
setattr(self, key, value)
def add_debugger_middleware(self, global_conf, app):
return app
def app_from_config(base_config, deployment_config=None, reset_milestones=True):
if not deployment_config:
deployment_config = {'debug': 'false',
'error_email_from': 'paste@localhost',
'smtp_server': 'localhost'}
# Reset milestones so that they can be reached again
# on next configuration initialization
if reset_milestones:
milestones._reset_all()
env_loader = base_config.make_load_environment()
app_maker = base_config.setup_tg_wsgi_app(env_loader)
app = TestApp(app_maker(deployment_config, full_stack=False))
return app
TurboGears2-2.3.7/tests/test_stack/baseutils.py 0000644 0000765 0000024 00000002621 12517763457 021632 0 ustar amol staff 0000000 0000000 import tg
class FakePackage(object):
pass
default_config = {
'debug': False,
'package': FakePackage,
'package_name' : 'FakePackage',
'paths': {'root': None,
'controllers': None,
'templates': [],
'static_files': None},
'db_engines': {},
'tg.strict_tmpl_context':False,
'use_dotted_templatenames':True,
'buffet.template_engines': [],
'buffet.template_options': {},
'default_renderer':'json',
'renderers': ['json'],
'render_functions': {'json': tg.renderers.json.JSONRenderer.render_json},
'rendering_engines_options': {'json': {'content_type': 'application/json'}},
'rendering_engines_without_vars': set(('json',)),
'use_legacy_renderers': False,
'use_sqlalchemy': False,
'i18n.lang': None
}
class FakeRoutes(object):
def __init__(self, app):
self.app = app
def __call__(self, environ, start_response):
environ['wsgiorg.routing_args'] = [None, {'controller':'root'}]
environ['routes.url'] = None
return self.app(environ, start_response)
class ControllerWrap(object):
def __init__(self, controller):
self.controller = controller
def __call__(self, environ, start_response):
app = self.controller()
return app(environ, start_response)
TurboGears2-2.3.7/tests/test_stack/config/ 0000755 0000765 0000024 00000000000 12607177763 020530 5 ustar amol staff 0000000 0000000 TurboGears2-2.3.7/tests/test_stack/config/__init__.py 0000644 0000765 0000024 00000000000 12413576166 022622 0 ustar amol staff 0000000 0000000 TurboGears2-2.3.7/tests/test_stack/config/controllers/ 0000755 0000765 0000024 00000000000 12607177763 023076 5 ustar amol staff 0000000 0000000 TurboGears2-2.3.7/tests/test_stack/config/controllers/__init__.py 0000644 0000765 0000024 00000000000 12413576166 025170 0 ustar amol staff 0000000 0000000 TurboGears2-2.3.7/tests/test_stack/config/controllers/root.py 0000644 0000765 0000024 00000001451 12413576166 024427 0 ustar amol staff 0000000 0000000 """Main Controller"""
from tg import expose, redirect, config
from tg.controllers import TGController
class RootController(TGController):
@expose()
def index(self):
return "my foo"
@expose()
def config_test(self):
return str(config)
@expose()
def config_attr_lookup(self):
return str(config.render_functions)
@expose()
def config_dotted_values(self):
return str(config.paths)
@expose()
def config_attr_set(self, foo):
config.test_value = foo
return str(config.test_value)
@expose()
def config_set_method(self):
return str(config.get('pylons'))
@expose()
def config_dict_set(self, foo):
config['test_value'] = foo
return str(config.test_value)
TurboGears2-2.3.7/tests/test_stack/config/test_config.py 0000644 0000765 0000024 00000002342 12413576166 023402 0 ustar amol staff 0000000 0000000 from tests.test_stack import TestConfig, app_from_config
def setup_noDB():
base_config = TestConfig(folder = 'config',
values = {'use_sqlalchemy': False,
'use_toscawidgets': False,
'use_toscawidgets2':False}
)
return app_from_config(base_config)
def test_basic_stack():
app = setup_noDB()
resp = app.get('/')
assert resp.body.decode('ascii') == "my foo"
def test_config_reading():
"""Ensure that the config object can be read via dict and attr access"""
app = setup_noDB()
resp = app.get('/config_test')
resp_body = resp.body.decode('ascii')
assert "default_renderer" in resp_body
resp = app.get('/config_attr_lookup')
assert "genshi" in resp_body
resp = app.get('/config_dotted_values')
assert "root" in resp_body
def test_config_writing():
"""Ensure that new values can be added to the config object"""
app = setup_noDB()
value = "gooberblue"
resp = app.get('/config_attr_set/'+value)
resp_body = resp.body.decode('ascii')
assert value in resp_body
resp = app.get('/config_dict_set/'+value)
assert value in resp_body
TurboGears2-2.3.7/tests/test_stack/dispatch/ 0000755 0000765 0000024 00000000000 12607177763 021062 5 ustar amol staff 0000000 0000000 TurboGears2-2.3.7/tests/test_stack/dispatch/__init__.py 0000644 0000765 0000024 00000000000 12413576166 023154 0 ustar amol staff 0000000 0000000 TurboGears2-2.3.7/tests/test_stack/dispatch/controllers/ 0000755 0000765 0000024 00000000000 12607177763 023430 5 ustar amol staff 0000000 0000000 TurboGears2-2.3.7/tests/test_stack/dispatch/controllers/__init__.py 0000644 0000765 0000024 00000000000 12413576166 025522 0 ustar amol staff 0000000 0000000 TurboGears2-2.3.7/tests/test_stack/dispatch/controllers/root.py 0000644 0000765 0000024 00000014012 12607177564 024762 0 ustar amol staff 0000000 0000000 # -*- coding: utf-8 -*-
from __future__ import unicode_literals
import tg
from tg.controllers import TGController
from tg.decorators import expose, validate, https, variable_decode, with_trailing_slash, \
without_trailing_slash, with_engine
from tg import expose, redirect, config
from tg.controllers import TGController
from tg import dispatched_controller
from nose.tools import eq_
from tests.test_validation import validators
from tg._compat import unicode_text
from paste.deploy.converters import asbool
class NestedSubController(TGController):
@expose()
def index(self):
return '-'.join((self.mount_point, dispatched_controller().mount_point))
@expose()
def hitme(self):
return '*'.join((self.mount_point, dispatched_controller().mount_point))
@expose()
def _lookup(self, *args):
lookup = LookupController()
return lookup, args
class SubController(TGController):
nested = NestedSubController()
@expose()
def foo(self,):
return 'sub_foo'
@expose()
def index(self):
return 'sub index'
@expose()
def _default(self, *args):
return ("recieved the following args (from the url): %s" %list(args))
@expose()
def redirect_me(self, target, **kw):
tg.redirect(target, **kw)
@expose()
def redirect_sub(self):
tg.redirect('index')
@expose()
def redirect_list(self):
tg.redirect(["/sub2", "list"])
@expose()
def hello(self, name):
return "Why HELLO! " + name
@expose()
def hitme(self):
return '@'.join((self.mount_point, dispatched_controller().mount_point))
class LookupController(TGController):
nested = NestedSubController()
@expose()
def findme(self, *args, **kw):
return 'got to lookup'
@expose()
def hiddenhitme(self, *args, **kw):
return ' '.join((self.mount_point, dispatched_controller().mount_point))
class SubController2(object):
@expose()
def index(self):
tg.redirect('list')
@expose()
def list(self, **kw):
return "hello list"
@expose()
def _lookup(self, *args):
lookup = LookupController()
return lookup, args
class RootController(TGController):
@expose()
def index(self, **kwargs):
return 'hello world'
@expose()
def _default(self, remainder):
return "Main Default Page called for url /%s"%remainder
@expose()
def feed(self, feed=None):
return feed
sub = SubController()
sub2 = SubController2()
@expose()
def redirect_me(self, target, **kw):
tg.redirect(target, kw)
@expose()
def hello(self, name, silly=None):
return "Hello " + name
@expose()
def redirect_cookie(self, name):
tg.response.set_cookie('name', name)
tg.redirect('/hello_cookie')
@expose()
def hello_cookie(self):
return "Hello " + tg.request.cookies['name']
@expose()
def flash_redirect(self):
tg.flash("Wow,
flash!")
tg.redirect("/flash_after_redirect")
@expose()
def flash_render(self, using_js=False, with_message=True):
if asbool(with_message):
tg.flash('JS
Flash')
return tg.flash.render('flash', asbool(using_js))
@expose()
def bigflash_redirect(self):
tg.flash('x' * 5000)
tg.redirect('/flash_after_redirect')
@expose()
def flash_unicode(self):
tg.flash("Привет, мир!")
tg.redirect("/flash_after_redirect")
@expose()
def flash_after_redirect(self):
return tg.get_flash()
@expose()
def flash_status(self):
return tg.get_status()
@expose()
def flash_no_redirect(self):
tg.flash("Wow, flash!")
return tg.get_flash()
@expose('json')
@validate(validators={"some_int": validators.Int()})
def validated_int(self, some_int):
assert isinstance(some_int, int)
return dict(response=some_int)
@expose('json')
@validate(validators={"a":validators.Int()})
def validated_and_unvalidated(self, a, b):
assert isinstance(a, int)
assert isinstance(b, unicode_text)
return dict(int=a,str=b)
@expose()
@expose('json')
def stacked_expose(self, tg_format=None):
return dict(got_json=True)
@expose('json')
def json_return_list(self):
return [1,2,3]
@expose(content_type='image/png')
def custom_content_type(self):
return b'PNG'
@expose()
def custom_content_type2(self):
tg.response.content_type = 'image/png'
return b'PNG2'
@expose(content_type='text/plain')
def custom_content_text_plain_type(self):
return 'a
bx'
@expose()
def check_params(self, *args, **kwargs):
if not args and not kwargs:
return "None recieved"
else:
return "Controler recieved: %s, %s" %(args, kwargs)
@expose()
def test_url_sop(self):
from tg import url
eq_('/foo', url('/foo'))
u = url("/foo", params=dict(bar=1, baz=2))
assert u in \
["/foo?bar=1&baz=2", "/foo?baz=2&bar=1"], u
@https
@expose()
def test_https(self, **kw):
return ''
@expose('json')
@variable_decode
def test_vardec(self, **kw):
return kw
@expose('mako:echo.mak')
def echo(self):
return dict()
@expose()
@with_trailing_slash
def with_tslash(self):
return 'HI'
@expose()
@without_trailing_slash
def without_tslash(self):
return 'HI'
@expose()
@with_engine('mainslave')
def onmaster_without_params(self, **kw):
return '%s-%s' % (tg.request._tg_force_sqla_engine, kw)
@expose()
@with_engine('mainslave', master_params=['first'])
def onmaster_withlist(self, **kw):
return '%s-%s' % (tg.request._tg_force_sqla_engine, kw)
@expose()
@with_engine('mainslave', master_params={'first':True, 'second':False})
def onmaster(self, **kw):
return '%s-%s' % (tg.request._tg_force_sqla_engine, kw) TurboGears2-2.3.7/tests/test_stack/dispatch/test_config.py 0000644 0000765 0000024 00000003006 12413576166 023732 0 ustar amol staff 0000000 0000000 import os
from tests.test_stack import TestConfig
from webtest import TestApp
def setup_noDB():
global_config = {'debug': 'true',
'error_email_from': 'paste@localhost',
'smtp_server': 'localhost'}
base_config = TestConfig(folder = 'config',
values = {'use_sqlalchemy': False,
'use_toscawidgets':False,
'use_toscawidgets2':False}
)
env_loader = base_config.make_load_environment()
app_maker = base_config.setup_tg_wsgi_app(env_loader)
app = TestApp(app_maker(global_config, full_stack=True))
return app
def test_basic_stack():
app = setup_noDB()
resp = app.get('/')
assert resp.body.decode('ascii') == "my foo"
def test_config_reading():
"""Ensure that the config object can be read via dict and attr access"""
app = setup_noDB()
resp = app.get('/config_test')
assert "default_renderer" in str(resp.body)
resp = app.get('/config_attr_lookup')
assert "genshi" in str(resp.body)
resp = app.get('/config_dotted_values')
assert "root" in str(resp.body)
def test_config_writing():
"""Ensure that new values can be added to the config object"""
app = setup_noDB()
value = "gooberblue"
resp = app.get('/config_attr_set/'+value)
assert value in str(resp.body)
resp = app.get('/config_dict_set/'+value)
assert value in str(resp.body)
TurboGears2-2.3.7/tests/test_stack/dispatch/test_decorated_controller.py 0000644 0000765 0000024 00000015515 12607177564 026676 0 ustar amol staff 0000000 0000000 # -*- coding: utf-8 -*-
from nose.tools import raises
import os, tg
from tests.test_stack import TestConfig, app_from_config
from tg.configuration.hooks import _TGGlobalHooksNamespace
from tg.decorators import Decoration
from tg.configuration import milestones
from tg.util import Bunch
class TestHooks(object):
def setUp(self):
milestones._reset_all()
tg.hooks = _TGGlobalHooksNamespace()
def tearDown(self):
milestones._reset_all()
tg.hooks = _TGGlobalHooksNamespace()
def test_hooks_syswide(self):
base_config = TestConfig(folder = 'dispatch',
values = {'use_sqlalchemy': False,
'use_toscawidgets': False,
'use_toscawidgets2': False,
'ignore_parameters': ["ignore", "ignore_me"]
})
def hook(*args, **kw):
tg.tmpl_context.echo = 'WORKED'
base_config.register_hook('before_call', hook)
app = app_from_config(base_config, reset_milestones=False)
ans = app.get('/echo')
assert 'WORKED' in ans
def test_decoration_run_hooks_backward_compatibility(self):
# TODO: Remove test when Decoration.run_hooks gets removed
def func(*args, **kw):
pass
def hook(*args, **kw):
hook.did_run = True
hook.did_run = False
milestones.renderers_ready.reach()
tg.hooks.register('before_call', hook, controller=func)
deco = Decoration.get_decoration(func)
deco.run_hooks(Bunch(config=None), 'before_call')
assert hook.did_run is True
class TestExpose(object):
def setUp(self):
milestones.renderers_ready._reset()
def tearDown(self):
milestones.renderers_ready._reset()
def test_unregisterd_renderers_detection(self):
#If no renderers are available we should just issue a warning
#and avoid crashing. Simply bypass rendering availability check.
base_config = TestConfig(folder = 'dispatch',
values = {'use_sqlalchemy': False,
'use_toscawidgets': False,
'use_toscawidgets2': False,
'ignore_parameters': ["ignore", "ignore_me"]
})
app = app_from_config(base_config)
old_renderers = tg.config['renderers']
tg.config['renderers'] = []
@tg.expose('mako:nonexisting')
def func(*args, **kw):
pass
tg.config['renderers'] = old_renderers
def test_use_default_renderer(self):
base_config = TestConfig(folder = 'dispatch',
values = {'use_sqlalchemy': False,
'use_toscawidgets': False,
'use_toscawidgets2': False,
'ignore_parameters': ["ignore", "ignore_me"]
})
app = app_from_config(base_config)
exposition = tg.expose('nonexisting')
exposition._resolve_options()
assert exposition.engine == tg.config['default_renderer']
assert exposition.template == 'nonexisting'
def test_expose_without_function_does_nothing(self):
base_config = TestConfig(folder = 'dispatch',
values = {'use_sqlalchemy': False,
'use_toscawidgets': False,
'use_toscawidgets2': False,
'ignore_parameters': ["ignore", "ignore_me"]
})
app = app_from_config(base_config)
exposition = tg.expose('nonexisting')
exposition._apply()
assert exposition._func is None
assert exposition.engine is None
def test_expose_idempotent(self):
base_config = TestConfig(folder = 'dispatch',
values = {'use_sqlalchemy': False,
'use_toscawidgets': False,
'use_toscawidgets2': False,
'ignore_parameters': ["ignore", "ignore_me"]
})
app = app_from_config(base_config)
exposition = tg.expose('nonexisting')
@exposition
@exposition
def func(*args, **kw):
pass
milestones.renderers_ready.reach()
deco = Decoration.get_decoration(func)
assert len(deco.engines) == 1, deco.engines
class TestDecorators(object):
def setup(self):
base_config = TestConfig(folder = 'dispatch',
values = {'use_sqlalchemy': False,
'use_toscawidgets': False,
'use_toscawidgets2': False,
'ignore_parameters': ["ignore", "ignore_me"]
})
self.app = app_from_config(base_config)
def test_variabledecode_fail(self):
resp = self.app.get('/test_vardec', params={'test-1': '1',
'test-2': 2,
'test--repetitions': 'hi'})
assert resp.json['test-1'] == '1', resp.json
assert resp.json['test--repetitions'] == 'hi', resp.json
assert 'test' not in resp.json, resp.json
def test_variabledecode_partial_fail(self):
resp = self.app.get('/test_vardec', params={'test-1': '1',
'test-2': 2,
'test-': 4})
assert resp.json['test-1'] == '1'
assert resp.json['test-'] == '4'
assert len(resp.json['test']) == 2
def test_variable_decode(self):
from formencode.variabledecode import variable_encode
obj = dict(a=['1','2','3'], b=dict(c=[dict(d='1')]))
params = variable_encode(dict(obj=obj), add_repetitions=False)
resp = self.app.get('/test_vardec', params=params)
assert resp.json['obj'] == obj, (resp.json['obj'], obj)
def test_without_trailing_slash(self):
resp = self.app.get('/without_tslash/', status=301)
assert resp.headers['Location'].endswith('/without_tslash')
def test_with_trailing_slash(self):
resp = self.app.get('/with_tslash', status=301)
assert resp.headers['Location'].endswith('/with_tslash/')
def test_with_engine(self):
resp = self.app.get('/onmaster')
assert 'mainslave' in resp
def test_with_engine_without_params(self):
resp = self.app.get('/onmaster_without_params?first=1&second=1')
assert 'mainslave' in resp
def test_with_engine_nopop(self):
resp = self.app.get('/onmaster?second=1')
assert 'master' in resp
assert 'second' in resp
def test_with_engine_pop(self):
resp = self.app.get('/onmaster?first=1')
assert 'master' in resp
assert 'first' not in resp
def test_with_engine_using_list(self):
resp = self.app.get('/onmaster_withlist?first=1')
assert 'master' in resp
assert 'first' not in resp
TurboGears2-2.3.7/tests/test_stack/dispatch/test_url_dispatch.py 0000644 0000765 0000024 00000015427 12555020522 025143 0 ustar amol staff 0000000 0000000 # -*- coding: utf-8 -*-
from tests.test_stack import TestConfig, app_from_config
from tg.util import no_warn
from tg._compat import u_
def setup_noDB(html_flash=False):
config = {'use_sqlalchemy': False,
'use_toscawidgets': False,
'use_toscawidgets2': False,
'ignore_parameters': ["ignore", "ignore_me"]}
if html_flash:
config['flash.allow_html'] = True
base_config = TestConfig(folder='dispatch',
values=config)
return app_from_config(base_config)
app = None
def setup():
global app
app = setup_noDB()
@no_warn #should be _default now
def test_tg_style_default():
resp = app.get('/sdfaswdfsdfa') #random string should be caught by the default route
assert 'Default' in resp.body.decode('utf-8')
def test_url_encoded_param_passing():
resp = app.get('/feed?feed=http%3A%2F%2Fdeanlandolt.com%2Ffeed%2Fatom%2F')
assert "http://deanlandolt.com/feed/atom/" in resp.body.decode('utf-8')
def test_tg_style_index():
resp = app.get('/index/')
assert 'hello' in resp.body.decode('utf-8'), resp
def test_tg_style_subcontroller_index():
resp = app.get('/sub/index')
assert "sub index" in resp.body.decode('utf-8')
def test_tg_style_subcontroller_default():
resp=app.get('/sub/bob/tim/joe')
assert 'bob' in resp.body.decode('utf-8'), resp
assert 'tim' in resp.body.decode('utf-8'), resp
assert 'joe' in resp.body.decode('utf-8'), resp
def test_redirect_absolute():
resp = app.get('/redirect_me?target=/')
assert resp.status == "302 Found", resp.status
assert 'http://localhost/' in resp.headers['location']
resp = resp.follow()
assert 'hello world' in resp, resp
@no_warn
def test_redirect_relative():
resp = app.get('/redirect_me?target=hello&name=abc')
resp = resp.follow()
assert 'Hello abc' in resp, resp
resp = app.get('/sub/redirect_me?target=hello&name=def')
resp = resp.follow()
assert 'Why HELLO! def' in resp, resp
resp = app.get('/sub/redirect_me?target=../hello&name=ghi')
resp = resp.follow()
assert 'Hello ghi' in resp, resp
def test_redirect_external():
resp = app.get('/redirect_me?target=http://example.com')
assert resp.status == "302 Found" and resp.headers['location'] == 'http://example.com', resp
def test_redirect_param():
resp = app.get('/redirect_me?target=/hello&name=paj')
resp = resp.follow()
assert 'Hello paj' in resp, resp
resp = app.get('/redirect_me?target=/hello&name=pbj')
resp = resp.follow()
assert 'Hello pbj' in resp, resp
resp = app.get('/redirect_me?target=/hello&silly=billy&name=pcj')
resp = resp.follow()
assert 'Hello pcj' in resp, resp
def test_redirect_cookie():
resp = app.get('/redirect_cookie?name=stefanha').follow()
assert 'Hello stefanha' in resp
def test_subcontroller_redirect_subindex():
resp=app.get('/sub/redirect_sub').follow()
assert 'sub index' in resp
def test_subcontroller_redirect_sub2index():
resp=app.get('/sub2/').follow()
assert 'hello list' in resp
#this test does not run because of some bug in nose
def _test_subcontroller_lookup():
resp=app.get('/sub2/findme').follow()
assert 'lookup' in resp, resp
def test_subcontroller_redirect_no_slash_sub2index():
resp=app.get('/sub2/').follow()
assert 'hello list' in resp, resp
def test_redirect_to_list_of_strings():
resp = app.get('/sub/redirect_list').follow()
assert 'hello list' in resp, resp
def test_flash_redirect():
resp = app.get('/flash_redirect').follow()
assert 'Wow,
flash!' in resp, resp
def test_bigflash_redirect():
try:
resp = app.get('/bigflash_redirect')
assert False
except Exception as e:
assert 'Flash value is too long (cookie would be >4k)' in str(e)
def test_flash_no_redirect():
resp = app.get('/flash_no_redirect')
assert 'Wow, flash!' in resp, resp
def test_flash_unicode():
resp = app.get('/flash_unicode').follow()
content = resp.body.decode('utf8')
assert u_('Привет, мир!') in content, content
def test_flash_status():
resp = app.get('/flash_status')
assert 'ok' in resp, resp
def test_flash_javascript():
resp = app.get('/flash_render?using_js=True')
expected = 'webflash({"id": "flash", "name": "webflash"})'
epxected_reverse = 'webflash({"name": "webflash", "id": "flash"})'
assert expected in resp or epxected_reverse in resp, resp
assert 'webflash.render()' in resp, resp
def test_flash_render_plain():
resp = app.get('/flash_render')
assert 'JS <br/>Flash' in resp, resp
def test_flash_render_plain_with_html():
app = setup_noDB(html_flash=True)
resp = app.get('/flash_render')
assert 'JS
Flash' in resp, resp
def test_flash_render_no_message():
resp = app.get('/flash_render?with_message=False')
assert 'flash' not in resp
def test_custom_content_type():
resp = app.get('/custom_content_type')
assert 'image/png' == dict(resp.headers)['Content-Type'], resp
assert resp.body.decode('utf-8') == 'PNG', resp
def test_custom_text_plain_content_type():
resp = app.get('/custom_content_text_plain_type')
assert 'text/plain; charset=utf-8' == dict(resp.headers)['Content-Type'], resp
assert resp.body.decode('utf-8') == """a
bx""", resp
@no_warn
def test_custom_content_type2():
resp = app.get('/custom_content_type2')
assert 'image/png' == dict(resp.headers)['Content-Type'], resp
assert resp.body.decode('utf-8') == 'PNG2', resp
@no_warn
def test_basicurls():
resp = app.get("/test_url_sop")
def test_ignore_parameters():
resp = app.get("/check_params?ignore='bar'&ignore_me='foo'")
assert "None Received"
def test_json_return_list():
try:
resp = app.get("/json_return_list")
assert False
except Exception as e:
assert 'You may not expose with JSON a list' in str(e)
def test_https_redirect():
resp = app.get("/test_https?foo=bar&baz=bat")
assert 'https://' in resp, resp
assert resp.location.endswith("/test_https?foo=bar&baz=bat")
resp = app.post("/test_https?foo=bar&baz=bat", status=405)
class TestVisits(object):
def test_visit_path_sub1(self):
resp = app.get("/sub/hitme")
assert str(resp).endswith('/sub@/sub')
def test_visit_path_nested(self):
resp = app.get("/sub/nested/hitme")
assert str(resp).endswith('/sub/nested*/sub/nested')
def test_visit_path_nested_index(self):
resp = app.get("/sub/nested")
assert str(resp).endswith('/sub/nested-/sub/nested')
def test_runtime_visit_path_subcontroller(self):
resp = app.get("/sub/nested/nested/hitme")
assert str(resp).endswith('*/sub/nested')
def test_runtime_visit_path(self):
resp = app.get("/sub/nested/hiddenhitme")
assert str(resp).endswith(' /sub/nested')
TurboGears2-2.3.7/tests/test_stack/fixture/ 0000755 0000765 0000024 00000000000 12607177763 020751 5 ustar amol staff 0000000 0000000 TurboGears2-2.3.7/tests/test_stack/fixture/__init__.py 0000644 0000765 0000024 00000000000 12413576166 023043 0 ustar amol staff 0000000 0000000 TurboGears2-2.3.7/tests/test_stack/lib/ 0000755 0000765 0000024 00000000000 12607177763 020031 5 ustar amol staff 0000000 0000000 TurboGears2-2.3.7/tests/test_stack/lib/__init__.py 0000644 0000765 0000024 00000000372 12413576166 022137 0 ustar amol staff 0000000 0000000 """Pylons requires that packages have a lib.base and lib.helpers
So we've added on here so we can run tests in the context of the tg
package itself, pylons will likely remove this restriction before
1.0 and this package can then be removed.
""" TurboGears2-2.3.7/tests/test_stack/lib/base.py 0000644 0000765 0000024 00000000372 12413576166 021312 0 ustar amol staff 0000000 0000000 """Pylons requires that packages have a lib.base and lib.helpers
So we've added on here so we can run tests in the context of the tg
package itself, pylons will likely remove this restriction before 1.0
and this module can then be removed.
""" TurboGears2-2.3.7/tests/test_stack/lib/helpers.py 0000644 0000765 0000024 00000000372 12413576166 022042 0 ustar amol staff 0000000 0000000 """Pylons requires that packages have a lib.base and lib.helpers
So we've added on here so we can run tests in the context of the tg
package itself, pylons will likely remove this restriction before 1.0
and this module can then be removed.
""" TurboGears2-2.3.7/tests/test_stack/lib/templatetools/ 0000755 0000765 0000024 00000000000 12607177763 022725 5 ustar amol staff 0000000 0000000 TurboGears2-2.3.7/tests/test_stack/lib/templatetools/__init__.py 0000644 0000765 0000024 00000000033 12413576166 025025 0 ustar amol staff 0000000 0000000 __author__ = 'clsdaniel'
TurboGears2-2.3.7/tests/test_stack/lib/templatetools/jinja_filters.py 0000644 0000765 0000024 00000000507 12413576166 026117 0 ustar amol staff 0000000 0000000 try:
from hashlib import sha1
except ImportError:
from sha1 import sha1
# avoid polluting module namespace
__all__ = ['codify']
def codify(value):
string_hash = sha1(value.encode('ascii'))
return string_hash.hexdigest()
def polluting_function(value):
return "Template filter namespace has been POLLUTED"
TurboGears2-2.3.7/tests/test_stack/rendering/ 0000755 0000765 0000024 00000000000 12607177763 021240 5 ustar amol staff 0000000 0000000 TurboGears2-2.3.7/tests/test_stack/rendering/__init__.py 0000644 0000765 0000024 00000000000 12413576166 023332 0 ustar amol staff 0000000 0000000 TurboGears2-2.3.7/tests/test_stack/rendering/controllers/ 0000755 0000765 0000024 00000000000 12607177763 023606 5 ustar amol staff 0000000 0000000 TurboGears2-2.3.7/tests/test_stack/rendering/controllers/__init__.py 0000644 0000765 0000024 00000000000 12413576166 025700 0 ustar amol staff 0000000 0000000 TurboGears2-2.3.7/tests/test_stack/rendering/controllers/root.py 0000644 0000765 0000024 00000034400 12607177564 025143 0 ustar amol staff 0000000 0000000 """Main Controller"""
import tg
from tg import expose, redirect, config, validate, override_template, response, render_template, tmpl_context
from tg import cache, i18n, request
from tg.decorators import paginate, use_custom_format, with_trailing_slash, Decoration, before_render, decode_params
from tg.controllers import TGController
from tg.validation import TGValidationError
from tg._compat import PY3
from tg.render import _get_tg_vars, cached_template
import datetime
if not PY3:
from tw.forms import TableForm, TextField, CalendarDatePicker, SingleSelectField, TextArea
from tw.api import WidgetsList
class MovieForm(TableForm):
# This WidgetsList is just a container
class fields(WidgetsList):
title = TextField()
year = TextField(size=4, default=1984)
description = TextArea()
#then, we create an instance of this form
base_movie_form = MovieForm("movie_form", action='create')
else:
base_movie_form = None
import tw2.forms as tw2f
import tw2.core as tw2c
class TW2MovieForm(tw2f.TableForm):
title = tw2f.TextField(validator=tw2c.Required)
year = tw2f.TextField(size=4, validator=tw2c.IntValidator)
tw2_movie_form = TW2MovieForm()
class IntValidator(object):
def to_python(self, value):
try:
return int(value)
except:
raise TGValidationError('Not a number')
class GoodJsonObject(object):
def __json__(self):
return {'Json':'Rocks'}
class BadJsonObject(object):
pass
class JsonController(TGController):
@expose('json')
def json(self):
return dict(a='hello world', b=True)
@expose('json', exclude_names=["b"])
def excluded_b(self):
return dict(a="visible", b="invisible")
@expose('json')
@expose('genshi:test', content_type='application/xml')
def xml_or_json(self):
return dict(name="John Carter", title='officer', status='missing')
@expose('json')
def json_with_object(self):
return dict(obj=GoodJsonObject())
@expose('json')
def json_with_bad_object(self):
return dict(obj=BadJsonObject())
class SubClassableController(TGController):
@expose('genshi:index.html')
def index(self):
return {}
@expose('genshi:index.html')
def index_override(self):
return {}
def before_render_data(remainder, params, output):
output['parent_value'] = 'PARENT'
@expose('json')
@before_render(before_render_data)
def data(self):
return {'v':5}
class SubClassingController(SubClassableController):
@expose(inherit=True)
def index(self, *args, **kw):
return super(SubClassingController, self).index(*args, **kw)
@expose('genshi:genshi_doctype.html', inherit=True)
def index_override(self, *args, **kw):
return super(SubClassingController, self).index_override(*args, **kw)
def before_render_data(remainder, params, output):
output['child_value'] = 'CHILD'
@expose(inherit=True)
@before_render(before_render_data)
def data(self, *args, **kw):
return super(SubClassingController, self).data(*args, **kw)
class RootController(TGController):
j = JsonController()
sub1 = SubClassableController()
sub2 = SubClassingController()
@expose('genshi:index.html')
def index(self):
return {}
@expose('genshi:genshi_doctype.html')
def auto_doctype(self):
return {}
@expose('genshi:genshi_doctype.html', content_type='text/html')
def auto_doctype_html(self):
return {}
@expose('genshi:genshi_doctype.html', content_type='application/xhtml+xml')
def auto_doctype_xhtml(self):
return {}
@expose('genshi:genshi_doctype.html', render_params=dict(doctype=None))
def explicit_no_doctype(self):
return {}
@expose('genshi:genshi_doctype.html', render_params=dict(doctype='html'))
def explicit_doctype_html(self):
return {}
@expose('genshi:genshi_doctype.html', render_params=dict(doctype='xhtml'))
def explicit_doctype_xhtml(self):
return {}
@expose('genshi:genshi_form.html')
def form(self):
return dict(form=base_movie_form)
@expose('genshi:genshi_form.html')
def tw2form(self):
return dict(form=tw2_movie_form)
@expose('genshi:genshi_foreign.html')
def foreign(self):
return {}
@expose('json')
@validate(form=base_movie_form)
def process_form_errors(self, **kwargs):
#add error messages to the kwargs dictionary and return it
kwargs['errors'] = request.validation['errors']
return dict(kwargs)
@expose()
@paginate('testdata')
def paginated_text(self):
return '''Some Text'''
@expose('kajiki:kajiki_paginated.xhtml')
@expose('json')
@paginate('testdata', max_items_per_page=20)
def paginated(self, n):
return dict(testdata=range(int(n)))
@expose('kajiki:kajiki_paginated.xhtml')
@paginate('testdata')
def paginate_with_params(self, n):
url_params = dict(param1='hi', param2='man')
return dict(testdata=range(int(n)), url_params=url_params)
@expose('kajiki:kajiki_paginated.xhtml')
@paginate('testdata')
@validate(dict(n=IntValidator()))
def paginated_validated(self, n):
return dict(testdata=range(n))
@expose('kajiki:kajiki_paginated.xhtml')
@validate(dict(n=IntValidator()))
@paginate('testdata')
def validated_paginated(self, n):
return dict(testdata=range(n))
@expose('kajiki:kajiki_paginated.xhtml')
@paginate('testdata', use_prefix=True)
@paginate('testdata2', use_prefix=True)
def multiple_paginators(self, n):
n = int(n)
return dict(testdata=range(n), testdata2=range(n+100, n+100+n))
@expose('genshi:genshi_inherits.html')
def genshi_inherits(self):
return {}
@expose('genshi:genshi_inherits_sub.html')
def genshi_inherits_sub(self):
return {}
@expose('genshi:sub/frombottom.html')
def genshi_inherits_sub_from_bottom(self):
return {}
@expose('jinja:jinja_noop.jinja')
def jinja_index(self):
return {}
@expose('jinja:jinja_autoload.jinja')
def jinja_autoload(self):
return {}
@expose('jinja:jinja_inherits.jinja')
def jinja_inherits(self):
return {}
@expose('jinja:tests.test_stack.rendering.templates.jinja_noop')
def jinja_dotted(self):
return {}
@expose('jinja:tests.test_stack.rendering.templates.jinja_inherits_dotted')
def jinja_inherits_dotted(self):
return {}
@expose('jinja:tests.test_stack.rendering.templates.jinja_inherits')
def jinja_inherits_mixed(self):
return {}
@expose('jinja:jinja_extensions.jinja')
def jinja_extensions(self):
test_autoescape_on = "Test Autoescape On"
test_autoescape_off = "Autoescape Off"
return dict(test_autoescape_off=test_autoescape_off,
test_autoescape_on=test_autoescape_on)
@expose('jinja:jinja_filters.jinja')
def jinja_filters(self):
return {}
@expose('jinja:jinja_buildins.jinja')
def jinja_buildins(self):
return {}
@expose('jinja:jinja_i18n.jinja')
def jinja_i18n(self):
return {}
@expose('jinja:jinja_i18n.jinja')
def jinja_i18n_en(self):
i18n.set_temporary_lang("en")
return {}
@expose('jinja:jinja_i18n.jinja')
def jinja_i18n_de(self):
i18n.set_temporary_lang("de")
return {}
@expose('chameleon_genshi:index.html')
def chameleon_genshi_index(self):
return {}
@expose('chameleon_genshi:genshi_inherits.html')
def chameleon_genshi_inherits(self):
return {}
@expose('mako:mako_noop.mak')
def mako_index(self):
return {}
@expose('mako:mako_inherits.mak')
def mako_inherits(self):
return {}
@expose('chameleon_genshi:tests.test_stack.rendering.templates.index')
def chameleon_index_dotted(self):
return {}
@expose('kajiki:tests.test_stack.rendering.templates.index')
def kajiki_index_dotted(self):
return {}
@expose('kajiki:tests.test_stack.rendering.templates.missing')
def kajiki_missing_template(self):
return {}
@expose('kajiki:tests.test_stack.rendering.templates.kajiki_i18n')
def kajiki_i18n(self):
return {}
@expose('kajiki:tests.test_stack.rendering.templates.kajiki_i18n')
def kajiki_i18n_de(self):
i18n.set_temporary_lang("de")
return {}
@expose('genshi:tests.test_stack.rendering.templates.index')
def index_dotted(self):
return {}
@expose('genshi:tests.test_stack.rendering.templates.genshi_inherits')
def genshi_inherits_dotted(self):
return {}
@expose('genshi:tests.test_stack.rendering.templates.genshi_inherits_sub_dotted')
def genshi_inherits_sub_dotted(self):
return {}
@expose('genshi:tests.test_stack.rendering.templates.sub.frombottom_dotted')
def genshi_inherits_sub_dotted_from_bottom(self):
return {}
@expose('mako:tests.test_stack.rendering.templates.mako_noop')
def mako_index_dotted(self):
return {}
@expose('mako:tests.test_stack.rendering.templates.mako_inherits_dotted')
def mako_inherits_dotted(self):
return {}
@expose('json')
@expose('genshi:index.html')
def html_and_json(self):
return {}
@expose('json', custom_format='json')
@expose('mako:mako_custom_format.mak', content_type='text/xml', custom_format='xml')
@expose('genshi:genshi_custom_format.html', content_type='text/html', custom_format='html')
def custom_format(self, format='default'):
if format != 'default':
use_custom_format(self.custom_format, format)
return dict(format=format, status="ok")
else:
return 'OK'
@expose("genshi:tests.non_overridden")
def template_override(self, override=False):
if override:
override_template(self.template_override, "genshi:tests.overridden")
return dict()
@with_trailing_slash
@expose("genshi:tests.non_overridden")
def template_override_wts(self, override=False):
if override:
override_template(self.template_override_wts, "genshi:tests.overridden")
return dict()
@expose(content_type='text/javascript')
def template_override_content_type(self, override=False):
if override:
override_template(self.template_override_content_type, "mako:tests.overridden_js")
return dict()
else:
return "alert('Not overridden')"
@expose('mako:mako_custom_format.mak', content_type='text/xml')
@expose('genshi:genshi_custom_format.html', content_type='text/html')
def template_override_multiple_content_type(self, override=False):
if override:
override_template(self.template_override_multiple_content_type, "mako:mako_noop.mak")
return dict(format='something', status="ok")
@expose()
def jinja2_manual_rendering(self, frompylons=False):
try:
import pylons
except ImportError:
frompylons = False
if frompylons:
from pylons.templating import render_jinja2
return render_jinja2('jinja_inherits.jinja')
else:
return render_template({}, 'jinja', 'jinja_inherits.jinja')
@expose()
def no_template_generator(self):
def output():
num = 0
while num < 5:
num += 1
yield str(num).encode('ascii')
return output()
@expose()
def genshi_manual_rendering_with_doctype(self, doctype=None):
response.content_type = 'text/html'
response.charset = 'utf-8'
return render_template({}, 'genshi', 'genshi_doctype.html', doctype=doctype)
@expose('mako:mako_custom_format.mak')
@expose('genshi:genshi_custom_format.html')
def multiple_engines(self):
deco = Decoration.get_decoration(self.multiple_engines)
used_engine = deco.engines.get('text/html')[0]
return dict(format=used_engine, status='ok')
@expose('json')
def get_tg_vars(self):
return dict(tg_vars=list(_get_tg_vars().keys()))
@expose('genshi:index.html')
def template_caching(self):
from datetime import datetime
tmpl_context.now = datetime.utcnow
return dict(tg_cache={'key':'TEMPLATE_CACHE_TEST',
'type':'memory',
'expire':'never'})
@expose('genshi:index.html')
def template_caching_default_type(self):
from datetime import datetime
tmpl_context.now = datetime.utcnow
return dict(tg_cache={'key':'TEMPLATE_CACHE_TEST2',
'expire':'never'})
@expose('json')
def template_caching_options(self, **kwargs):
_cache_options = {}
class FakeCache(object):
def get_cache(self, *args, **kwargs):
_cache_options['args'] = args
_cache_options['kwargs'] = kwargs
try:
c = cache.get_cache(*args, **kwargs)
_cache_options['cls'] = c.namespace.__class__.__name__
except TypeError:
_cache_options['cls'] = 'NoImplementation'
c = cache.get_cache(*args, type='memory', **kwargs)
return c
tg.cache.kwargs['type'] = 'NoImplementation'
old_cache = tg.cache
tg.cache = FakeCache()
try:
def render_func(*args, **kw):
return 'OK'
cached_template('index.html', render_func, **kwargs)
return _cache_options
finally:
tg.cache = old_cache
@expose('jsonp', render_params={'callback_param': 'call'})
def get_jsonp(self, **kwargs):
return {'value': 5}
@expose('json')
def get_json_isodates_default(self, **kwargs):
return {'date': datetime.datetime.utcnow()}
@expose('json', render_params={'isodates': True})
def get_json_isodates_on(self, **kwargs):
return {'date': datetime.datetime.utcnow()}
@expose('json', render_params={'isodates': False})
def get_json_isodates_off(self, **kwargs):
return {'date': datetime.datetime.utcnow()}
@expose('json')
@decode_params('json')
def echo_json(self, **kwargs):
return kwargs
TurboGears2-2.3.7/tests/test_stack/rendering/templates/ 0000755 0000765 0000024 00000000000 12607177763 023236 5 ustar amol staff 0000000 0000000 TurboGears2-2.3.7/tests/test_stack/rendering/templates/__init__.py 0000644 0000765 0000024 00000000000 12413576166 025330 0 ustar amol staff 0000000 0000000 TurboGears2-2.3.7/tests/test_stack/rendering/templates/sub/ 0000755 0000765 0000024 00000000000 12607177763 024027 5 ustar amol staff 0000000 0000000 TurboGears2-2.3.7/tests/test_stack/rendering/templates/sub/__init__.py 0000644 0000765 0000024 00000000000 12413576166 026121 0 ustar amol staff 0000000 0000000 TurboGears2-2.3.7/tests/test_stack/rendering/test_decorators.py 0000644 0000765 0000024 00000015315 12517763457 025024 0 ustar amol staff 0000000 0000000 from nose.tools import raises
from tests.test_stack import TestConfig, app_from_config
from tg.util import no_warn
from tg.configuration import config
from tg.configuration import milestones
from tg.decorators import Decoration, decode_params
import tg
import json
def make_app():
base_config = TestConfig(folder = 'rendering',
values = {'use_sqlalchemy': False,
'use_legacy_renderer': False,
# this is specific to mako
# to make sure inheritance works
'use_dotted_templatenames': False,
'use_toscawidgets': False,
'use_toscawidgets2': False
}
)
return app_from_config(base_config)
class TestTGController(object):
def setup(self):
self.app = make_app()
def test_simple_jsonification(self):
resp = self.app.get('/j/json')
expected = {"a": "hello world", "b": True}
assert expected == resp.json_body
def test_multi_dispatch_json(self):
resp = self.app.get('/j/xml_or_json', headers={'accept':'application/json'})
assert '''"status": "missing"''' in resp
assert '''"name": "John Carter"''' in resp
assert '''"title": "officer"''' in resp
def test_json_with_object(self):
resp = self.app.get('/j/json_with_object')
assert '''"Json": "Rocks"''' in str(resp.body)
@no_warn
def test_json_with_bad_object(self):
try:
resp = self.app.get('/j/json_with_bad_object')
assert False
except Exception as e:
assert "is not JSON serializable" in str(e), str(e)
def test_multiple_engines(self):
default_renderer = config['default_renderer']
resp = self.app.get('/multiple_engines')
assert default_renderer in resp, resp
def test_decode_params_json(self):
params = {'name': 'Name', 'surname': 'Surname'}
resp = self.app.post_json('/echo_json', params)
assert resp.json_body == params
@raises(ValueError)
def test_decode_params_notjson(self):
@decode_params('xml')
def _fakefunc():
pass
class TestExposeInheritance(object):
def setup(self):
self.app = make_app()
def test_inherited_expose_template(self):
resp1 = self.app.get('/sub1/index')
resp2 = self.app.get('/sub2/index')
assert resp1.body == resp2.body
def test_inherited_expose_override(self):
resp1 = self.app.get('/sub1/index_override')
resp2 = self.app.get('/sub2/index_override')
assert resp1.body != resp2.body
def test_inherited_expose_hooks(self):
resp1 = self.app.get('/sub1/data')
assert ('"v"' in resp1 and '"parent_value"' in resp1)
resp2 = self.app.get('/sub2/data')
assert ('"v"' in resp2 and '"parent_value"' in resp2 and '"child_value"' in resp2)
class TestExposeLazyInheritance(object):
def test_lazy_inheritance(self):
milestones.renderers_ready._reset()
class BaseController(tg.TGController):
@tg.expose('template.html')
def func(self):
pass
class SubController(BaseController):
@tg.expose(inherit=True)
def func(self):
pass
milestones.renderers_ready.reach()
deco = Decoration.get_decoration(SubController.func)
assert len(deco.engines) == 1, deco.engines
assert deco.engines['text/html'][1] == 'template.html', deco.engines
def test_lazy_inheritance_with_template(self):
milestones.renderers_ready._reset()
class BaseController(tg.TGController):
@tg.expose('template.html')
def func(self):
pass
class SubController(BaseController):
@tg.expose('new_template.html', inherit=True)
def func(self):
pass
milestones.renderers_ready.reach()
deco = Decoration.get_decoration(SubController.func)
assert len(deco.engines) == 1, deco.engines
assert deco.engines['text/html'][1] == 'new_template.html', deco.engines
def test_lazy_inheritance_with_nested_template(self):
milestones.renderers_ready._reset()
class BaseController(tg.TGController):
@tg.expose('template.html')
@tg.expose('template.html', content_type='text/plain')
def func(self):
pass
class SubController(BaseController):
@tg.expose('new_template.html', inherit=True)
@tg.expose('new_template.html', content_type='text/plain')
def func(self):
pass
class SubSubController(SubController):
@tg.expose('new2_template.html', inherit=True)
def func(self):
pass
milestones.renderers_ready.reach()
deco = Decoration.get_decoration(SubSubController.func)
assert len(deco.engines) == 2, deco.engines
assert deco.engines['text/html'][1] == 'new2_template.html', deco.engines
assert deco.engines['text/plain'][1] == 'new_template.html', deco.engines
def test_lazy_inheritance_with_3nested_template(self):
milestones.renderers_ready._reset()
class BaseController(tg.TGController):
@tg.expose('template.html')
@tg.expose('template.html', content_type='text/plain')
@tg.expose('template.html', content_type='text/javascript')
def func(self):
pass
class SubController(BaseController):
@tg.expose('new_template.html', inherit=True)
@tg.expose('new_template.html', content_type='text/plain')
@tg.expose('new_template.html', content_type='text/javascript')
def func(self):
pass
class SubSubController(SubController):
@tg.expose('new2_template.html', inherit=True)
@tg.expose('new2_template.html', content_type='text/javascript')
def func(self):
pass
class SubSubSubController(SubSubController):
@tg.expose('new3_template.html', inherit=True)
def func(self):
pass
milestones.renderers_ready.reach()
deco = Decoration.get_decoration(SubSubSubController.func)
assert len(deco.engines) == 3, deco.engines
assert deco.engines['text/html'][1] == 'new3_template.html', deco.engines
assert deco.engines['text/plain'][1] == 'new_template.html', deco.engines
assert deco.engines['text/javascript'][1] == 'new2_template.html', deco.engines
TurboGears2-2.3.7/tests/test_stack/rendering/test_dotted_rendering.py 0000644 0000765 0000024 00000011352 12607177564 026172 0 ustar amol staff 0000000 0000000 # -*- coding: utf-8 -*-
import sys
from nose import SkipTest
from tests.test_stack import TestConfig, app_from_config
from tg.util import Bunch, no_warn
from webtest import TestApp
from tg._compat import PY3, u_, im_func
from tg.configuration import milestones
from tg import expose
from tg.decorators import Decoration
try:
from tgext.chameleon_genshi import ChameleonGenshiRenderer
except ImportError:
ChameleonGenshiRenderer = None
def setup_noDB(extra_init=None):
base_config = TestConfig(folder = 'rendering',
values = {'use_sqlalchemy': False,
# we want to test the new renderer functions
'use_legacy_renderer': False,
# in this test we want dotted names support
'use_dotted_templatenames': True,
'use_toscawidgets': False,
'use_toscawidgets2': False
}
)
if extra_init is not None:
extra_init(base_config)
return app_from_config(base_config)
def test_default_chameleon_genshi_renderer():
if ChameleonGenshiRenderer is None:
raise SkipTest()
def add_chameleon_renderer(app_config):
app_config.register_rendering_engine(ChameleonGenshiRenderer)
app_config.renderers.append('chameleon_genshi')
app = setup_noDB(add_chameleon_renderer)
# Manually add the exposition again as it was already discarded
# due to chameleon_genshi not being in the available renderes.
milestones.renderers_ready._reset()
from .controllers.root import RootController
controller = im_func(RootController.chameleon_index_dotted)
expose('chameleon_genshi:tests.test_stack.rendering.templates.index')(controller)
milestones.renderers_ready.reach()
resp = app.get('/chameleon_index_dotted')
assert "Welcome" in resp, resp
assert "TurboGears" in resp, resp
def test_default_kajiki_renderer():
app = setup_noDB()
resp = app.get('/kajiki_index_dotted')
assert "Welcome" in resp, resp
assert "TurboGears" in resp, resp
def test_kajiki_i18n():
app = setup_noDB()
resp = app.get('/kajiki_i18n')
assert u_("Your application is now running") in resp
def test_kajiki_i18n_de():
app = setup_noDB()
resp = app.get('/kajiki_i18n_de')
assert u_("Ihre Anwendung läuft jetzt einwandfrei") in resp
def test_kajiki_missing_template():
app = setup_noDB()
try:
resp = app.get('/kajiki_missing_template')
except IOError as e:
assert 'missing.xhtml not found' in str(e)
else:
assert False, 'Should have raised IOError'
def test_jinja_dotted():
app = setup_noDB()
resp = app.get('/jinja_dotted')
assert "move along, nothing to see here" in resp, resp
def test_jinja_inherits_dotted():
app = setup_noDB()
resp = app.get('/jinja_inherits_dotted')
assert "Welcome on my awsome homepage" in resp, resp
def test_jinja_inherits_mixed():
# Mixed notation, dotted and regular
app = setup_noDB()
resp = app.get('/jinja_inherits_mixed')
assert "Welcome on my awsome homepage" in resp, resp
def test_jinja_i18n():
app = setup_noDB()
resp = app.get('/jinja_i18n', status=200)
def test_jinja_i18n_en():
app = setup_noDB()
resp = app.get('/jinja_i18n_en')
assert "Your application is now running" in resp
def test_jinja_i18n_de():
app = setup_noDB()
resp = app.get('/jinja_i18n_de')
assert u_("Ihre Anwendung läuft jetzt einwandfrei") in resp
def test_default_genshi_renderer():
app = setup_noDB()
resp = app.get('/index_dotted')
assert "Welcome" in resp, resp
assert "TurboGears" in resp, resp
def test_genshi_inheritance():
app = setup_noDB()
resp = app.get('/genshi_inherits_dotted')
assert "Inheritance template" in resp, resp
assert "Master template" in resp, resp
def test_genshi_sub_inheritance():
app = setup_noDB()
resp = app.get('/genshi_inherits_sub_dotted')
assert "Inheritance template" in resp, resp
assert "Master template" in resp, resp
assert "from sub-template: sub.tobeincluded" in resp, resp
def test_genshi_sub_inheritance_frombottom():
app = setup_noDB()
resp = app.get('/genshi_inherits_sub_dotted_from_bottom')
assert "Master template" in resp, resp
assert "from sub-template: sub.frombottom_dotted" in resp, resp
def test_mako_renderer():
app = setup_noDB()
resp = app.get('/mako_index_dotted')
assert "This is the mako index page
" in resp, resp
def test_mako_inheritance():
app = setup_noDB()
resp = app.get('/mako_inherits_dotted')
assert "inherited mako page" in resp, resp
assert "Inside parent template" in resp, resp
TurboGears2-2.3.7/tests/test_stack/rendering/test_pagination.py 0000644 0000765 0000024 00000025437 12555020522 024773 0 ustar amol staff 0000000 0000000 import json
from nose import SkipTest
from tests.test_stack import TestConfig, app_from_config
from tg.support.paginate import Page
from tg.controllers.util import _urlencode
from tg import json_encode
from tg.util.webtest import test_context
def setup_noDB():
base_config = TestConfig(folder='rendering',
values={
'use_sqlalchemy': False,
'use_toscawidgets': False,
'use_toscawidgets2': False
})
return app_from_config(base_config)
_pager = ('')
_data = '' % ''.join(
'%d' % i for i in range(10))
class TestPagination:
def setup(self):
self.app = setup_noDB()
def test_basic_pagination(self):
url = '/paginated/42'
page = self.app.get(url)
assert _pager % locals() in page, page
assert _data in page, page
url = '/paginated/42?page=2'
page = self.app.get(url)
assert '0' not in page
assert '10' in page
def test_pagination_negative(self):
url = '/paginated/42?page=-1'
page = self.app.get(url)
assert '0' in page
def test_pagination_items_per_page(self):
url = '/paginated/42?items_per_page=20'
page = self.app.get(url)
assert '0' in page
assert '19' in page
def test_pagination_items_per_page_negative(self):
url = '/paginated/42?items_per_page=-1'
page = self.app.get(url)
assert '0' in page
assert '10' not in page
def test_pagination_non_paginable(self):
url = '/paginated_text'
page = self.app.get(url)
assert 'Some Text' in page
def test_pagination_with_validation(self):
url = '/paginated_validated/42'
page = self.app.get(url)
assert _pager % locals() in page, page
assert _data in page, page
url = '/paginated_validated/42?page=2'
page = self.app.get(url)
assert '0' not in page
assert '10' in page
def test_validation_with_pagination(self):
url = '/validated_paginated/42'
page = self.app.get(url)
assert _pager % locals() in page, page
assert _data in page, page
url = '/validated_paginated/42?page=2'
page = self.app.get(url)
assert '0' not in page
assert '10' in page
def test_pagination_with_link_args(self):
url = '/paginate_with_params/42'
page = self.app.get(url)
assert 'param1=hi' in page
assert 'param2=man' in page
assert 'partial' not in page
assert '/fake_url' in page
url = '/paginate_with_params/42?page=2'
page = self.app.get(url)
assert '0' not in page
assert '10' in page
def test_multiple_paginators(self):
url = '/multiple_paginators/42'
try:
from collections import OrderedDict
params = (('testdata_page', 2), ('testdata2_page', 2))
reverse_params = OrderedDict(reversed(params))
params = OrderedDict(params)
except ImportError:
reverse_params = params = {'testdata2_page': 2, 'testdata_page': 2}
goto_page2_link = url + '?' + _urlencode(params)
goto_page2_reverse_link = url + '?' + _urlencode(reverse_params)
page = self.app.get(url)
assert '/multiple_paginators/42?testdata2_page=2' in page, str(page)
assert '/multiple_paginators/42?testdata_page=2' in page, str(page)
url = '/multiple_paginators/42?testdata_page=2'
page = self.app.get(url)
assert (
goto_page2_link in page or goto_page2_reverse_link in page
), str(page)
assert '/multiple_paginators/42?testdata_page=4' in page, str(page)
assert '0' not in page
assert '10' in page
assert '142' in page
assert '151' in page
url = '/multiple_paginators/42?testdata2_page=2'
page = self.app.get(url)
assert (
goto_page2_link in page or goto_page2_reverse_link in page
), str(page)
assert '/multiple_paginators/42?testdata2_page=4' in page, str(page)
assert '0' in page
assert '9' in page
assert '151' not in page
assert '161' in page
def test_json_pagination(self):
url = '/paginated/42.json'
page = self.app.get(url)
assert '[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]' in page
url = '/paginated/42.json?page=2'
page = self.app.get(url)
assert '[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]' in page
class TestPage(object):
def test_not_a_number_page(self):
p = Page(range(100), items_per_page=10, page='A')
sec = list(p)
assert sec[-1] == 9, sec
def test_empty_list(self):
p = Page([], items_per_page=10, page=1)
assert list(p) == []
def test_page_out_of_bound(self):
p = Page(range(100), items_per_page=10, page=10000)
sec = list(p)
assert sec[-1] == 99, sec
def test_page_out_of_lower_bound(self):
p = Page(range(100), items_per_page=10, page=-5)
sec = list(p)
assert sec[-1] == 9, sec
def test_navigator_one_page(self):
with test_context(None, '/'):
p = Page(range(10), items_per_page=10, page=10)
assert p.pager() == ''
def test_navigator_middle_page(self):
with test_context(None, '/'):
p = Page(range(100), items_per_page=10, page=5)
pager = p.pager()
assert '?page=1' in pager
assert '?page=4' in pager
assert '?page=6' in pager
assert '?page=10' in pager
def test_navigator_ajax(self):
with test_context(None, '/'):
p = Page(range(100), items_per_page=10, page=5)
pager = p.pager(onclick='goto($page)')
assert 'goto(1)' in pager
assert 'goto(4)' in pager
assert 'goto(6)' in pager
assert 'goto(10)' in pager
try:
import sqlite3
except:
import pysqlite2
from sqlalchemy import (MetaData, Table, Column, ForeignKey, Integer, String)
from sqlalchemy.orm import create_session, mapper, relation
metadata = MetaData('sqlite:///:memory:')
test1 = Table('test1', metadata,
Column('id', Integer, primary_key=True),
Column('val', String(8)))
test2 = Table('test2', metadata,
Column('id', Integer, primary_key=True),
Column('test1id', Integer, ForeignKey('test1.id')),
Column('val', String(8)))
test3 = Table('test3', metadata,
Column('id', Integer, primary_key=True),
Column('val', String(8)))
test4 = Table('test4', metadata,
Column('id', Integer, primary_key=True),
Column('val', String(8)))
metadata.create_all()
class Test2(object):
pass
mapper(Test2, test2)
class Test1(object):
pass
mapper(Test1, test1, properties={'test2s': relation(Test2)})
class Test3(object):
pass
mapper(Test3, test3)
class Test4(object):
pass
mapper(Test4, test4)
test1.insert().execute({'id': 1, 'val': 'bob'})
test2.insert().execute({'id': 1, 'test1id': 1, 'val': 'fred'})
test2.insert().execute({'id': 2, 'test1id': 1, 'val': 'alice'})
test3.insert().execute({'id': 1, 'val': 'bob'})
test4.insert().execute({'id': 1, 'val': 'alberto'})
class TestPageSQLA(object):
def setup(self):
self.s = create_session()
def test_relationship(self):
t = self.s.query(Test1).get(1)
p = Page(t.test2s, items_per_page=1, page=1)
assert len(list(p)) == 1
assert list(p)[0].val == 'fred', list(p)
def test_query(self):
q = self.s.query(Test2)
p = Page(q, items_per_page=1, page=1)
assert len(list(p)) == 1
assert list(p)[0].val == 'fred', list(p)
def test_json_query(self):
q = self.s.query(Test2)
p = Page(q, items_per_page=1, page=1)
res = json.loads(json_encode(p))
assert len(res['entries']) == 1
assert res['total'] == 2
assert res['entries'][0]['val'] == 'fred'
try:
import ming
from ming import create_datastore, Session, schema, ASCENDING
from ming.odm import ODMSession, FieldProperty, ForeignIdProperty, RelationProperty, Mapper
from ming.odm.declarative import MappedClass
except ImportError:
ming = None
class TestPageMing(object):
@classmethod
def setupClass(cls):
if ming is None:
raise SkipTest('Ming not available...')
cls.basic_session = Session(create_datastore('mim:///'))
cls.s = ODMSession(cls.basic_session)
class Author(MappedClass):
class __mongometa__:
session = cls.s
name = 'wiki_author'
_id = FieldProperty(schema.ObjectId)
name = FieldProperty(str)
pages = RelationProperty('WikiPage')
class WikiPage(MappedClass):
class __mongometa__:
session = cls.s
name = 'wiki_page'
_id = FieldProperty(schema.ObjectId)
title = FieldProperty(str)
text = FieldProperty(str)
order = FieldProperty(int)
author_id = ForeignIdProperty(Author)
author = RelationProperty(Author)
cls.Author = Author
cls.WikiPage = WikiPage
Mapper.compile_all()
cls.author = Author(name='author1')
author2 = Author(name='author2')
WikiPage(title='Hello', text='Text', order=1, author=cls.author)
WikiPage(title='Another', text='Text', order=2, author=cls.author)
WikiPage(title='ThirdOne', text='Text', order=3, author=author2)
cls.s.flush()
cls.s.clear()
def teardown(self):
self.s.clear()
def test_query(self):
q = self.WikiPage.query.find().sort([('order', ASCENDING)])
p = Page(q, items_per_page=1, page=1)
assert len(list(p)) == 1
assert list(p)[0].title == 'Hello', list(p)
def test_json_query(self):
q = self.WikiPage.query.find().sort([('order', ASCENDING)])
p = Page(q, items_per_page=1, page=1)
res = json.loads(json_encode(p))
assert len(res['entries']) == 1
assert res['total'] == 3
assert res['entries'][0]['title'] == 'Hello', res['entries']
assert res['entries'][0]['author_id'] == str(self.author._id), res['entries']
def test_relation(self):
a = self.Author.query.find({'name': 'author1'}).first()
p = Page(a.pages, items_per_page=1, page=1)
assert len(list(p)) == 1
assert list(p)[0].title in ('Hello', 'Another'), list(p)
TurboGears2-2.3.7/tests/test_stack/rendering/test_rendering.py 0000644 0000765 0000024 00000070735 12607177564 024641 0 ustar amol staff 0000000 0000000 # -*- coding: utf-8 -*-
from nose import SkipTest
import shutil, os
import json
import tg
from tg.configuration import milestones
#tg.configuration.reqlocal_config.push_process_config({})
from tests.test_stack import TestConfig, app_from_config
from tg.configuration.hooks import _TGGlobalHooksNamespace
from tg.util import Bunch
from tg._compat import PY3, im_func
from tg.renderers.genshi import GenshiRenderer
from tg import expose
from tg import TGController, AppConfig
from webtest import TestApp
from datetime import datetime
try:
from tgext.chameleon_genshi import ChameleonGenshiRenderer
except ImportError:
ChameleonGenshiRenderer = None
def setup_noDB(genshi_doctype=None, genshi_method=None, genshi_encoding=None, extra=None,
extra_init=None):
base_config = TestConfig(folder='rendering', values={
'use_sqlalchemy': False,
'use_legacy_renderer': False,
# this is specific to mako to make sure inheritance works
'use_dotted_templatenames': False,
'use_toscawidgets': False,
'use_toscawidgets2': False
})
deployment_config = {}
# remove previous option value to avoid using the old one
tg.config.pop('templating.genshi.doctype', None)
if genshi_doctype:
deployment_config['templating.genshi.doctype'] = genshi_doctype
tg.config.pop('templating.genshi.method', None)
if genshi_method:
deployment_config['templating.genshi.method'] = genshi_method
tg.config.pop('templating.genshi.encoding', None)
if genshi_encoding:
deployment_config['templating.genshi.encoding'] = genshi_encoding
deployment_config.update(extra or {})
if extra_init is not None:
extra_init(base_config)
return app_from_config(base_config, deployment_config)
def test_default_genshi_renderer():
app = setup_noDB()
resp = app.get('/')
assert ('') in resp
assert "Welcome" in resp
assert "TurboGears" in resp
def test_genshi_nameconstant():
from genshi.template.astutil import ASTCodeGenerator, parse
from tg.renderers.genshi import GenshiRenderer
# This checks genshi gets monkeypatched to fix it on Py34 if option is provided
GenshiRenderer.create(Bunch({
'templating.genshi.name_constant_patch': True,
'use_dotted_templatenames': False,
'auto_reload_templates': False,
'paths': Bunch({'templates': '/tmp'})
}), None)
assert hasattr(ASTCodeGenerator, 'visit_NameConstant')
astgen = ASTCodeGenerator(parse('range(10)', mode='eval'))
for n in (False, True, None):
astgen._new_line()
astgen.visit_NameConstant(Bunch(value=n))
line = str(astgen.line)
assert line == str(n), line
astgen._new_line()
try:
astgen.visit_NameConstant(Bunch(value='HELLO_WORLD'))
except Exception as e:
assert 'Unknown NameConstant' in str(e)
else:
assert False
def test_genshi_doctype_html5():
app = setup_noDB(genshi_doctype='html5')
resp = app.get('/')
assert '' in resp
assert "Welcome" in resp
assert "TurboGears" in resp
def test_genshi_auto_doctype():
app = setup_noDB()
resp = app.get('/auto_doctype')
assert ('') in resp
assert 'content="text/html; charset=utf-8"' in resp
assert "doctype generation" in resp
assert "
" in resp
assert "Rendered with Genshi.
" in resp
def test_genshi_method_html():
app = setup_noDB(genshi_method='html')
resp = app.get('/auto_doctype')
assert ('') in resp
assert 'content="text/html; charset=utf-8"' in resp
assert "doctype generation" in resp
assert "
" in resp
assert "Rendered with Genshi.
" in resp
def test_genshi_method_xhtml():
app = setup_noDB(genshi_method='xhtml')
resp = app.get('/auto_doctype')
assert ('') in resp
assert 'content="text/html; charset=utf-8"' in resp
assert "doctype generation" in resp
assert "
" in resp
assert "Rendered with Genshi.
" in resp
def test_genshi_doctype_html():
app = setup_noDB(genshi_doctype='html')
resp = app.get('/auto_doctype')
assert ('') in resp
assert 'content="text/html; charset=utf-8"' in resp
assert "doctype generation" in resp
assert "
" in resp
assert "Rendered with Genshi.
" in resp
def test_genshi_doctype_html5():
app = setup_noDB(genshi_doctype='html5')
resp = app.get('/auto_doctype')
assert '' in resp
assert 'content="text/html; charset=utf-8"' in resp
assert "doctype generation" in resp
assert "
" in resp
assert "Rendered with Genshi.
" in resp
def test_genshi_doctype_xhtml_strict():
app = setup_noDB(genshi_doctype='xhtml-strict')
resp = app.get('/auto_doctype')
assert ('') in resp
assert 'content="text/html; charset=utf-8"' in resp
assert "doctype generation" in resp
assert "
" in resp
assert "Rendered with Genshi.
" in resp
def test_genshi_doctype_html_maps_to_xhtml():
app = setup_noDB(genshi_doctype={'text/html': ('xhtml', 'html')})
resp = app.get('/auto_doctype_html')
assert ('') in resp
assert 'content="text/html; charset=utf-8"' in resp
assert "doctype generation" in resp
assert "
" in resp
assert "Rendered with Genshi.
" in resp
def test_genshi_method_html_maps_to_xhtml():
app = setup_noDB(genshi_method={'text/html': ('xhtml', 'html')})
resp = app.get('/auto_doctype_html')
assert ('') in resp
assert 'content="text/html; charset=utf-8"' in resp
assert "doctype generation" in resp
assert "
" in resp
assert "Rendered with Genshi.
" in resp
def test_genshi_method_xml_overridden_by_content_type_html():
app = setup_noDB(genshi_method='xml')
resp = app.get('/auto_doctype_html')
assert ('') in resp
assert 'content="text/html; charset=utf-8"' in resp
assert "doctype generation" in resp
assert "
" in resp
assert "Rendered with Genshi.
" in resp
def test_genshi_method_xhtml_is_ok_with_content_type_html():
app = setup_noDB(genshi_method='xhtml')
resp = app.get('/auto_doctype_html')
assert ('') in resp
assert 'content="text/html; charset=utf-8"' in resp
assert "doctype generation" in resp
assert "
" in resp
assert "Rendered with Genshi.
" in resp
def test_genshi_doctype_xhtml_maps_to_html():
app = setup_noDB(
genshi_doctype={'application/xhtml+xml': ('html', 'xhtml')})
resp = app.get('/auto_doctype_xhtml')
assert ('') in resp
assert 'content="application/xhtml+xml; charset=utf-8"' in resp
assert "doctype generation" in resp
assert "
" in resp
assert "Rendered with Genshi.
" in resp
def test_genshi_method_xhtml_maps_to_html():
app = setup_noDB(
genshi_doctype={'application/xhtml+xml': ('html', 'xhtml')},
genshi_method={'application/xhtml+xml': ('html', 'xhtml')})
resp = app.get('/auto_doctype_xhtml')
assert ('') in resp
assert 'content="application/xhtml+xml; charset=utf-8"' in resp
assert "doctype generation" in resp
assert "
" in resp
assert "Rendered with Genshi.
" in resp
def test_genshi_method_xml_overridden_by_content_type_xhtml():
app = setup_noDB(genshi_method='xml')
resp = app.get('/auto_doctype_xhtml')
assert ('') in resp
assert 'content="application/xhtml+xml; charset=utf-8"' in resp
assert "doctype generation" in resp
assert "
" in resp
assert "Rendered with Genshi.
" in resp
def test_genshi_method_html_overridden_by_content_type_xhtml():
app = setup_noDB(genshi_method='html')
resp = app.get('/auto_doctype_xhtml')
assert ('') in resp
assert 'content="application/xhtml+xml; charset=utf-8"' in resp
assert "doctype generation" in resp
assert "
" in resp
assert "Rendered with Genshi.
" in resp
def test_genshi_explicit_no_doctype():
app = setup_noDB()
resp = app.get('/explicit_no_doctype')
assert 'DOCTYPE' not in resp
assert 'content="text/html; charset=utf-8"' in resp
assert "doctype generation" in resp
assert "
" in resp
assert "Rendered with Genshi.
" in resp
def test_genshi_explicit_doctype_html():
app = setup_noDB(genshi_doctype='xhtml')
resp = app.get('/explicit_doctype_html')
assert ('') in resp
assert 'content="text/html; charset=utf-8"' in resp
assert "doctype generation" in resp
assert "
" in resp
assert "Rendered with Genshi.
" in resp
def test_genshi_explicit_doctype_xhtml():
app = setup_noDB(genshi_doctype='html')
resp = app.get('/explicit_doctype_xhtml')
assert ('') in resp
assert 'content="text/html; charset=utf-8"' in resp
assert "doctype generation" in resp
assert "
" in resp
assert "Rendered with Genshi.
" in resp
def test_html_priority_for_ie():
app = setup_noDB()
resp = app.get('/html_and_json', headers={'Accept':
'application/x-ms-application, image/jpeg, application/xaml+xml,'
' image/gif, image/pjpeg, application/x-ms-xbap, */*'})
assert 'text/html' in str(resp), resp
def test_genshi_foreign_characters():
app = setup_noDB()
resp = app.get('/foreign')
assert "Foreign Cuisine" in resp
assert "Crème brûlée with Käsebrötchen" in resp
def test_genshi_inheritance():
app = setup_noDB()
resp = app.get('/genshi_inherits')
assert "Inheritance template" in resp
assert "Master template" in resp
def test_genshi_sub_inheritance():
app = setup_noDB()
resp = app.get('/genshi_inherits_sub')
assert "Inheritance template" in resp
assert "Master template" in resp
assert "from sub-template: sub.tobeincluded" in resp
def test_genshi_sub_inheritance_from_bottom():
app = setup_noDB()
resp = app.get('/genshi_inherits_sub_from_bottom')
assert "from sub-template: sub.frombottom" in resp
assert "Master template" in resp
def test_chameleon_genshi_base():
if ChameleonGenshiRenderer is None:
raise SkipTest()
def add_chameleon_renderer(app_config):
app_config.register_rendering_engine(ChameleonGenshiRenderer)
app_config.renderers.append('chameleon_genshi')
app = setup_noDB(extra_init=add_chameleon_renderer)
# Manually add the exposition again as it was already discarded
# due to chameleon_genshi not being in the available renderes.
milestones.renderers_ready._reset()
from .controllers.root import RootController
controller = im_func(RootController.chameleon_genshi_index)
expose('chameleon_genshi:index.html')(controller)
milestones.renderers_ready.reach()
resp = app.get('/chameleon_genshi_index')
assert ("TurboGears 2 is rapid web application development toolkit"
" designed to make your life easier.
") in resp
def test_chameleon_genshi_inheritance():
if ChameleonGenshiRenderer is None:
raise SkipTest()
def add_chameleon_renderer(app_config):
app_config.register_rendering_engine(ChameleonGenshiRenderer)
app_config.renderers.append('chameleon_genshi')
try:
import lxml
except ImportError:
# match templates need lxml, but since they don're really work anyway
# (at least not fully compatible with Genshi), we just skip this test
return
app = setup_noDB(extra_init=add_chameleon_renderer)
milestones.renderers_ready._reset()
from .controllers.root import RootController
controller = im_func(RootController.chameleon_genshi_inherits)
expose('chameleon_genshi:genshi_inherits.html')(controller)
milestones.renderers_ready.reach()
try:
resp = app.get('/chameleon_genshi_inherits')
except NameError as e:
# known issue with chameleon.genshi 1.0
if 'match_templates' not in str(e):
raise
except AttributeError as e:
# known issue with chameleon.genshi 1.3
if 'XPathResult' not in str(e):
raise
else:
assert "Inheritance template" in resp
assert "Master template" in resp
def test_jinja_autoload():
app = setup_noDB()
try:
resp = app.get('/jinja_autoload')
assert False
except Exception as e:
assert "no filter named 'polluting_function'" in str(e)
def _test_jinja_inherits():
app = setup_noDB()
resp = app.get('/jinja_inherits')
assert "Welcome on my awsome homepage" in resp, resp
def test_jinja_extensions():
base_config = TestConfig(folder = 'rendering',
values = {'use_sqlalchemy': False,
'use_legacy_renderer': False,
# this is specific to mako
# to make sure inheritance works
'use_dotted_templatenames': False,
'renderers':['jinja'],
'jinja_extensions': ['jinja2.ext.do', 'jinja2.ext.i18n',
'jinja2.ext.with_', 'jinja2.ext.autoescape'],
'use_toscawidgets': False,
'use_toscawidgets2': False
}
)
app = app_from_config(base_config)
resp = app.get('/jinja_extensions')
assert "Autoescape Off" in resp, resp
assert "<b>Test Autoescape On</b>" in resp, resp
def test_jinja_buildin_filters():
app = setup_noDB()
resp = app.get('/jinja_buildins')
assert 'HELLO JINJA!' in resp, resp
def test_jinja_custom_filters():
# Simple test filter to get a md5 hash of a string
def codify(value):
try:
from hashlib import md5
except ImportError:
from md5 import md5
string_hash = md5(value.encode('ascii'))
return string_hash.hexdigest()
base_config = TestConfig(folder = 'rendering',
values = {'use_sqlalchemy': False,
'use_legacy_renderer': False,
# this is specific to mako
# to make sure inheritance works
'use_dotted_templatenames': False,
'renderers':['jinja'],
'jinja_filters': {'codify': codify},
'use_toscawidgets': False,
'use_toscawidgets2': False
}
)
app = app_from_config(base_config)
try:
resp = app.get('/jinja_filters')
finally:
# Remove filters so we don't mess with other test units
tg.config.pop('jinja_filters')
assert '8bb23e0b574ecb147536efacc864891b' in resp, resp
def test_jinja_autoload_filters():
app = setup_noDB()
resp = app.get('/jinja_filters')
assert '29464d5ffe8f8dba1782fffcd6ed9fca6ceb4742' in resp, resp
def test_mako_renderer():
app = setup_noDB()
resp = app.get('/mako_index')
assert "This is the mako index page
" in resp, resp
def test_mako_renderer_compiled():
app = setup_noDB(extra={
'templating.mako.compiled_templates_dir': '_tg_tests_mako_compiled/dest'
})
resp = app.get('/mako_index')
assert "This is the mako index page
" in resp, resp
assert os.path.exists('_tg_tests_mako_compiled')
shutil.rmtree('_tg_tests_mako_compiled', True)
def test_mako_renderer_compiled_existing():
os.makedirs('_tg_tests_mako_compiled/dest')
test_mako_renderer_compiled()
def test_mako_renderer_compiled_no_access():
os.makedirs('_tg_tests_mako_compiled')
os.makedirs('_tg_tests_mako_compiled/dest', mode=0o400)
test_mako_renderer_compiled()
def test_mako_renderer_compiled_no_access_parent():
os.makedirs('_tg_tests_mako_compiled', mode=0o400)
test_mako_renderer_compiled()
def test_mako_inheritance():
app = setup_noDB()
resp = app.get('/mako_inherits')
assert "inherited mako page" in resp, resp
assert "Inside parent template" in resp, resp
def test_template_override():
# app = setup_noDB()
base_config = TestConfig(folder = 'rendering',
values = {'use_sqlalchemy': False,
'use_legacy_renderer': False,
# this is specific to mako
# to make sure inheritance works
'use_dotted_templatenames': True,
'renderers':['genshi'],
'use_toscawidgets': False,
'use_toscawidgets2': False
}
)
app = app_from_config(base_config)
r =app.get('/template_override')
assert "Not overridden" in r, r
r = app.get('/template_override', params=dict(override=True))
assert "This is overridden." in r, r
# now invoke the controller again without override,
# it should yield the old result
r = app.get('/template_override')
assert "Not overridden" in r, r
def test_template_override_wts():
# app = setup_noDB()
base_config = TestConfig(folder = 'rendering',
values = {'use_sqlalchemy': False,
'use_legacy_renderer': False,
# this is specific to mako
# to make sure inheritance works
'use_dotted_templatenames': True,
'renderers':['genshi'],
'use_toscawidgets': False,
'use_toscawidgets2': False
}
)
app = app_from_config(base_config)
r = app.get('/template_override_wts', status=301) # ensure with_trailing_slash
r =app.get('/template_override_wts/')
assert "Not overridden" in r, r
r = app.get('/template_override_wts/', params=dict(override=True))
assert "This is overridden." in r, r
# now invoke the controller again without override,
# it should yield the old result
r = app.get('/template_override_wts/')
assert "Not overridden" in r, r
def test_template_override_content_type():
base_config = TestConfig(folder = 'rendering',
values = {'use_sqlalchemy': False,
'use_legacy_renderer': False,
# this is specific to mako
# to make sure inheritance works
'use_dotted_templatenames': True,
'renderers':['mako', 'genshi'],
'use_toscawidgets': False,
'use_toscawidgets2': False
}
)
app = app_from_config(base_config)
r =app.get('/template_override_content_type')
assert r.content_type == 'text/javascript'
assert "Not overridden" in r, r
r = app.get('/template_override_content_type', params=dict(override=True))
assert r.content_type == 'text/javascript'
assert "This is overridden." in r, r
# now invoke the controller again without override,
# it should yield the old result
r = app.get('/template_override_content_type')
assert "Not overridden" in r, r
def test_template_custom_format_default():
app = setup_noDB()
resp = app.get('/custom_format')
assert 'OK' in resp
assert resp.content_type == 'text/html'
def test_template_custom_format_xml():
app = setup_noDB()
resp = app.get('/custom_format?format=xml')
assert 'xml' in resp
assert resp.content_type == 'text/xml'
def test_template_custom_format_json():
app = setup_noDB()
resp = app.get('/custom_format?format=json')
assert 'json' in resp
assert resp.content_type == 'application/json'
def test_template_custom_format_html():
app = setup_noDB()
resp = app.get('/custom_format?format=html')
assert 'html' in resp
assert resp.content_type == 'text/html'
def test_template_custom_format_nonexisting():
app = setup_noDB()
try:
resp = app.get('/custom_format?format=csv')
assert False
except Exception as e:
assert 'not a valid custom_format' in str(e)
def test_template_override_multiple_content_type():
app = setup_noDB()
resp = app.get('/template_override_multiple_content_type')
assert 'something' in resp
resp = app.get(
'/template_override_multiple_content_type',
params=dict(override=True))
assert 'This is the mako index page' in resp
def test_override_template_on_noncontroller():
tg.override_template(None, 'this.is.not.a.template')
def test_jinja2_manual_rendering():
app = setup_noDB()
tgresp = app.get('/jinja2_manual_rendering')
pyresp = app.get('/jinja2_manual_rendering?frompylons=1')
assert str(tgresp) == str(pyresp), str(tgresp) + '\n------\n' + str(pyresp)
def test_no_template():
app = setup_noDB()
resp = app.get('/no_template_generator')
assert '1234' in resp, resp
def test_genshi_manual_render_no_doctype():
app = setup_noDB()
resp = app.get('/genshi_manual_rendering_with_doctype')
assert 'DOCTYPE' not in resp, resp
assert "
" in resp
assert 'content="text/html; charset=utf-8"' in resp
assert "Rendered with Genshi.
" in resp
def test_genshi_manual_render_auto_doctype():
app = setup_noDB()
resp = app.get('/genshi_manual_rendering_with_doctype?doctype=auto')
assert ('') in resp
assert 'content="text/html; charset=utf-8"' in resp
assert "
" in resp
assert "Rendered with Genshi.
" in resp
def test_genshi_manual_render_html_doctype():
app = setup_noDB()
resp = app.get('/genshi_manual_rendering_with_doctype?doctype=html')
assert ('') in resp
assert 'content="text/html; charset=utf-8"' in resp
assert "
" in resp
assert "Rendered with Genshi.
" in resp
def test_genshi_manual_render_svg_doctype():
app = setup_noDB()
resp = app.get('/genshi_manual_rendering_with_doctype?doctype=svg')
assert '"
@expose()
def multi_value_kws(sekf, *args, **kw):
assert kw['foo'] == ['1', '2'], kw
@expose()
def with_routing_args(self, **kw):
return str(tg.request._controller_state.routing_args)
@expose('json')
@expose('genshi')
@expose()
def get_response_type(self):
return dict(ctype=tg.request.response_type)
@expose()
def hello_ext(self, *args):
return str(tg.request.response_ext)
class TestNotFoundController(TestWSGIController):
def __init__(self, *args, **kargs):
TestWSGIController.__init__(self, *args, **kargs)
self.app = make_app(NotFoundController)
def test_not_found(self):
r = self.app.get('/something', status=404)
assert '404 Not Found' in r, r
def test_not_found_blank(self):
r = self.app.get('/', status=404)
assert '404 Not Found' in r, r
def test_not_found_unicode(self):
r = self.app.get('/%D0%BF%D1%80%D0%B0%D0%B2%D0%B0', status=404)
assert '404 Not Found' in r, r
class TestNotFoundWithIndexController(TestWSGIController):
def __init__(self, *args, **kargs):
TestWSGIController.__init__(self, *args, **kargs)
self.app = make_app(NotFoundWithIndexController)
def test_not_found(self):
r = self.app.get('/something', status=404)
assert '404 Not Found' in r, r
class TestWSGIAppController(TestWSGIController):
def __init__(self, *args, **kargs):
TestWSGIController.__init__(self, *args, **kargs)
class TestedWSGIAppController(WSGIAppController):
def __init__(self):
def test_app(environ, start_response):
if environ.get('CONTENT_LENGTH', None) in (-1, '-1'):
del environ['CONTENT_LENGTH']
return validator(demo_app)(environ, start_response)
super(TestedWSGIAppController, self).__init__(test_app)
self.app = make_app(TestedWSGIAppController, config_options={
'make_body_seekable': True
})
def test_valid_wsgi(self):
try:
r = self.app.get('/some_url')
except Exception as e:
raise AssertionError(str(e))
assert 'some_url' in r
class TestWSGIAppControllerNotHTML(TestWSGIController):
def __init__(self, *args, **kargs):
TestWSGIController.__init__(self, *args, **kargs)
class TestedWSGIAppController(WSGIAppController):
def __init__(self):
def test_app(environ, start_response):
start_response('200 OK', [('Content-type','text/plain'),
('Content-Length', '5')])
return [b'HELLO']
super(TestedWSGIAppController, self).__init__(test_app)
self.app = make_app(TestedWSGIAppController, config_options={
'make_body_seekable': True
})
def test_right_wsgi_headers(self):
r = self.app.get('/some_url')
assert 'HELLO' in r
assert r.content_length == 5
assert r.content_type == 'text/plain'
class TestTGController(TestWSGIController):
def setUp(self, *args, **kargs):
TestWSGIController.setUp(self, *args, **kargs)
self.app = make_app(BasicTGController, config_options={
'make_body_seekable': True
})
def test_enable_routing_args(self):
self.app = make_app(BasicTGController, config_options={
'enable_routing_args': True
})
r = self.app.get('/with_routing_args?a=1&b=2&c=3')
assert 'a' in str(r)
assert 'b' in str(r)
assert 'c' in str(r)
def test_response_without_charset(self):
r = self.app.get('/index_unicode')
assert 'Hello World' in r, r
assert 'charset=utf-8' in str(r), r
def test_lookup(self):
r = self.app.get('/lookup/EYE')
msg = 'EYE'
assert msg in r, r
def test_lookup_with_sub(self):
r = self.app.get('/lookup_with_sub/EYE')
msg = 'EYE'
assert msg in r, r
def test_lookup_with_args(self):
r = self.app.get('/lookup_with_args/get_here/got_here')
msg = 'got_here'
assert r.body.decode('utf-8')==msg, r
def test_post_with_mixed_args(self):
r = self.app.post('/lookup_with_args/post_with_mixed_args/test', params={'arg2': 'time'})
msg = 'testtime'
assert r.body.decode('utf-8')==msg, r
def test_validated_int(self):
r = self.app.get('/validated_int/1')
assert '{"response": 1}' in r, r
def test_validated_with_error_handler(self):
r = self.app.get('/validated_with_error_handler?a=asdf&b=123')
msg = 'validation error handler'
assert msg in r, r
def test_validated_with_remote_error_handler(self):
r = self.app.get('/validated_with_remote_error_handler?a=asdf&b=123')
msg = 'remote error handler'
assert msg in r, r
def test_unknown_template(self):
r = self.app.get('/sub/unknown_template/')
msg = 'sub unknown template'
assert msg in r, r
def test_mounted_wsgi_app_at_root(self):
r = self.app.get('/mounted_app/')
assert 'Hello from /mounted_app' in r, r
def test_mounted_wsgi_app_at_subcontroller(self):
r = self.app.get('/sub/mounted_app/')
assert 'Hello from /sub/mounted_app/' in r, r
def test_request_for_wsgi_app_with_extension(self):
r = self.app.get('/sub/mounted_app/some_document.pdf')
assert 'Hello from /sub/mounted_app//some_document.pdf' in r, r
def test_posting_to_mounted_app(self):
r = self.app.post('/mounted_app/', params={'data':'Foooo'})
assert 'Foooo' in r, r
def test_use_wsgi_app(self):
r = self.app.get('/use_wsgi_app')
assert '/use_wsgi_app' in r, r
def test_custom_content_type_replace_header(self):
s = '''
textvalue
'''
r = self.app.post('/xml_rpc/', s, [('Content-Type', 'text/xml')])
assert len(r.headers.getall('Content-Type')) == 1, r.headers.getall('Content-Type')
assert r.headers['Content-Type'] == 'text/xml'
def test_response_type(self):
r = self.app.post('/stacked_expose.json')
assert 'got_json' in r.body.decode('utf-8'), r
def test_multi_value_kw(self):
r = self.app.get('/multi_value_kws?foo=1&foo=2')
def test_before_controller(self):
r = self.app.get('/sub/before')
assert '__my_before__' in r, r
def test_new_before_controller(self):
r = self.app.get('/sub/newbefore')
assert '__my_before__' in r, r
def test_visit_entry_point(self):
r = self.app.get('/sub/newbefore/visited')
assert 'visited' in r, r
def test_before_with_args(self):
r = self.app.get('/sub/newbefore/with_args/1/2?x=5')
assert '__my_before__5' in r, r
def test_before_controller_mounted_in_subpath(self):
r = self.app.get('/subpath/sub/before', extra_environ={'SCRIPT_NAME':'/subpath'})
assert '__my_before__' in r, r
def test_empty_path_after_script_name_removal(self):
r = self.app.get('/')
check_again_response = r.text
r = self.app.get('/subpath', extra_environ={'SCRIPT_NAME':'/subpath'})
assert r.text == check_again_response, r
def test_before_controller_without_script_name(self):
req = self.app.RequestClass.blank('/sub/before', {})
req.environ.pop('SCRIPT_NAME')
r = self.app.do_request(req, status=None, expect_errors=False)
assert '__my_before__' in r, r
@no_warn
def test_unicode_default_dispatch(self):
r =self.app.get('/sub/%C3%A4%C3%B6')
assert u_("äö") in r.body.decode('utf-8'), r
def test_default_with_empty_second_arg(self):
r =self.app.get('/sub4/default_with_args/a')
assert "default with args a None" in r.body.decode('utf-8'), r
assert "deprecated" not in r.body.decode('utf-8')
import warnings
warnings.filterwarnings('ignore', category=DeprecationWarning)
r = self.app.get('/sub4/deprecated_default_with_args/a')
warnings.resetwarnings()
assert "deprecated default with args a None" in r.body.decode('utf-8'), r
def test_default_with_args_a_b(self):
r =self.app.get('/sub4/default_with_args/a/b')
assert "default with args a b" in r.body.decode('utf-8'), r
assert "deprecated" not in r.body.decode('utf-8')
import warnings
warnings.filterwarnings('ignore', category=DeprecationWarning)
r = self.app.get('/sub4/deprecated_default_with_args/a/b')
warnings.resetwarnings()
assert "deprecated default with args a b" in r.body.decode('utf-8'), r
def test_default_with_query_arg(self):
r =self.app.get('/sub4/default_with_args?a=a')
assert "default with args a None" in r.body.decode('utf-8'), r
assert "deprecated" not in r.body.decode('utf-8')
import warnings
warnings.filterwarnings('ignore', category=DeprecationWarning)
r = self.app.get('/sub4/deprecated_default_with_args?a=a')
warnings.resetwarnings()
assert "deprecated default with args a None" in r.body.decode('utf-8'), r
def test_default_with_validator_fail(self):
r =self.app.get('/sub5/default_with_args?a=True')
assert "failure" in r.body.decode('utf-8'), r
def test_default_with_validator_pass(self):
r =self.app.get('/sub5/default_with_args?a=66')
assert "default with args and validators 66 None" in r.body.decode('utf-8'), r
def test_default_with_validator_pass2(self):
r =self.app.get('/sub5/default_with_args/66')
assert "default with args and validators 66 None" in r.body.decode('utf-8'), r
def test_default_with_validator_fail2(self):
r =self.app.get('/sub5/default_with_args/True/more')
assert "failure" in r.body.decode('utf-8'), r
def test_custom_content_type_in_controller(self):
resp = self.app.get('/custom_content_type_in_controller')
assert 'PNG' in resp, resp
assert resp.headers['Content-Type'] == 'image/png', resp
def test_custom_content_type_in_controller_charset(self):
resp = self.app.get('/custom_content_type_in_controller_charset')
assert 'TXT' in resp, resp
assert resp.headers['Content-Type'] == 'application/json; charset=utf-8', resp
def test_custom_content_type_in_decorator(self):
resp = self.app.get('/custom_content_type_in_decorator')
assert 'PNG' in resp, resp
assert resp.headers['Content-Type'] == 'image/png', resp
def test_removed_spurious_content_type(self):
r = self.app.get('/test_204')
assert r.headers.get('Content-Type', 'MISSING') == 'MISSING'
def test_optional_and_req_args(self):
resp = self.app.get('/optional_and_req_args/test/one')
assert "name=test, one=one, two=2, three=3" in resp.body.decode('utf-8'), resp
def test_optional_and_req_args_at_root(self):
resp = self.app.get('/test_args/test/one')
assert "name=test, one=one, two=2, three=3" in resp.body.decode('utf-8'), resp
def test_no_args(self):
resp = self.app.get('/test_args/test/')
assert "name=test, one=None, two=2, three=3" in resp.body.decode('utf-8'), resp
def test_one_extra_arg(self):
resp = self.app.get('/test_args/test/1')
assert "name=test, one=1, two=2, three=3" in resp.body.decode('utf-8'), resp
def test_two_extra_args(self):
resp = self.app.get('/test_args/test/1/2')
assert "name=test, one=1, two=2, three=3" in resp.body.decode('utf-8'), resp
def test_three_extra_args(self):
resp = self.app.get('/test_args/test/1/2/3')
assert "name=test, one=1, two=2, three=3" in resp.body.decode('utf-8'), resp
def test_extra_args_forces_default_lookup(self):
resp = self.app.get('/test_args/test/1/2/3/4')
assert resp.body.decode('utf-8') == """Main default page called for url /['test_args', 'test', '1', '2', '3', '4']""", resp
def test_not_enough_args(self):
resp = self.app.get('/test_args/test/1')
assert "name=test, one=1, two=2, three=3" in resp.body.decode('utf-8'), resp
def test_ticket_2412_with_ordered_arg(self):
resp = self.app.get('/ticket2412/Abip%C3%B3n')
assert u_("""Abipón""") in resp.body.decode('utf-8'), resp
def test_ticket_2412_with_named_arg(self):
resp = self.app.get('/ticket2412?arg1=Abip%C3%B3n')
assert u_("""Abipón""") in resp.body.decode('utf-8'), resp
def test_ticket_2351_bad_content_type(self):
resp = self.app.get('/ticket2351', headers={'Accept':'text/html'})
assert 'test' in resp.body.decode('utf-8'), resp
def test_embedded_lookup_with_index_first(self):
resp = self.app.get('/embedded_lookup_with_index/')
assert 'first controller with index' in resp.body.decode('utf-8'), resp
def test_embedded_lookup_with_index_second(self):
resp = self.app.get('/embedded_lookup_with_index/a')
assert 'second controller with index' in resp.body.decode('utf-8'), resp
def test_embedded_lookup_with_index_helper(self):
resp = self.app.get('/embedded_lookup_with_index/a/b')
assert 'helper index' in resp.body.decode('utf-8'), resp
def test_embedded_lookup_with_index_method(self):
resp = self.app.get('/embedded_lookup_with_index/a/b/method')
assert 'helper method' in resp.body.decode('utf-8'), resp
def test_self_calling_lookup_simple_index(self):
resp = self.app.get('/self_calling')
assert '((), {})' in resp.body.decode('utf-8'), resp
def test_self_calling_lookup_method(self):
resp = self.app.get('/self_calling/a/method/a/b')
assert "('a', 'b', {})" in resp.body.decode('utf-8'), resp
def test_self_calling_lookup_multiple_calls_method(self):
resp = self.app.get('/self_calling/a/b/c/method/a/b')
assert "('a', 'b', {})" in resp.body.decode('utf-8'), resp
def test_controller_state(self):
resp = self.app.get('/sub/get_controller_state')
assert '/sub' in resp
def test_response_type_json(self):
resp = self.app.get('/get_response_type.json')
assert 'json' in resp
def test_response_type_html(self):
resp = self.app.get('/get_response_type.html')
assert 'html' in resp
def test_extensions_single(self):
resp = self.app.get('/hello_ext.html')
assert resp.body.decode('ascii') == '.html', resp.body
def test_extensions_missing(self):
resp = self.app.get('/hello_ext')
assert resp.body.decode('ascii') == 'None', resp.body
def test_extensions_two(self):
resp = self.app.get('/hello_ext.json.html')
assert 'Main default page' in resp, resp
assert 'hello_ext.json' in resp, resp
def test_extensions_three(self):
resp = self.app.get('/hello_ext.jpg.json.html')
assert 'Main default page' in resp, resp
assert 'hello_ext.jpg.json' in resp, resp
def test_controller_url(self):
resp = self.app.get('/sub3/controller_url/false/a/b/c')
assert resp.text == 'sub3/controller_url', resp.text
def test_controller_url_backward_compatibility(self):
resp = self.app.get('/sub3/controller_url/true/a/b/c')
assert resp.text == 'sub3/controller_url', resp.text
class TestNestedWSGIAppWithoutSeekable(TestWSGIController):
def setUp(self, *args, **kargs):
TestWSGIController.setUp(self, *args, **kargs)
self.app = make_app(BasicTGController, config_options={
'make_body_seekable': False
})
@raises(RuntimeError)
def test_missing_body_seekable_trapped(self):
self.app.get('/mounted_app')
TurboGears2-2.3.7/tests/test_util.py 0000644 0000765 0000024 00000022114 12607177564 017504 0 ustar amol staff 0000000 0000000 # -*- coding: utf-8 -*-
from datetime import datetime, timedelta
import tg
from tg.util import *
from tg.configuration.utils import get_partial_dict
from nose.tools import eq_, raises
import os
from tg.controllers.util import *
from tg.util.dates import get_fixed_timezone, utctz, parse_datetime
from tg.util.files import safe_filename
from tg.util.html import script_json_encode
from tg.util.webtest import test_context
from tg.wsgiapp import TemplateContext, AttribSafeTemplateContext
import tg._compat
from tg._compat import u_
path = None
def setup():
global path
path = os.curdir
os.chdir(os.path.abspath(os.path.dirname(os.path.dirname(tg.__file__))))
def teardown():
global path
os.chdir(path)
def test_get_partial_dict():
eq_(get_partial_dict('prefix', {'prefix.xyz':1, 'prefix.zyx':2, 'xy':3}),
{'xyz':1,'zyx':2})
def test_compat_im_class():
class FakeClass(object):
def method(self):
pass
def func():
pass
o = FakeClass()
assert tg._compat.im_class(o.method) == FakeClass
assert tg._compat.im_class(func) == None
class TestUrlMethod(object):
def test_url_unicode(self):
with test_context(None, '/'):
res = url('.', {'p1':u_('v1')})
assert res == '.?p1=v1'
def test_url_unicode_nonascii(self):
with test_context(None, '/'):
res = url('.', {'p1':u_('àèìòù')})
assert res == '.?p1=%C3%A0%C3%A8%C3%AC%C3%B2%C3%B9'
def test_url_nonstring(self):
with test_context(None, '/'):
res = url('.', {'p1':1})
assert res == '.?p1=1'
def test_url_object(self):
class Object(object):
def __str__(self):
return 'aeiou'
with test_context(None, '/'):
res = url('.', {'p1': Object()})
assert res == '.?p1=aeiou'
def test_url_object_unicodeerror(self):
class Object(object):
def __str__(self):
return u_('àèìòù')
with test_context(None, '/'):
res = url('.', {'p1': Object()})
assert res == '.?p1=%C3%A0%C3%A8%C3%AC%C3%B2%C3%B9'
def test_url_object_exception(self):
class SubException(Exception):
def __str__(self):
return u_('àèìòù')
with test_context(None, '/'):
res = url('.', {'p1': SubException('a', 'b', 'c')})
assert res == '.?p1=a+b+c', res
class TestBunch(object):
def test_add_entry(self):
d = Bunch()
d['test.value'] = 5
assert d.test.value == 5
def test_del_entry(self):
d = Bunch()
d['test_value'] = 5
del d.test_value
assert not list(d.keys())
@raises(AttributeError)
def test_del_entry_fail(self):
d = Bunch()
del d.not_existing
class TestDottedNameFinder(object):
@raises(DottedFileLocatorError)
def test_non_python_package(self):
DottedFileNameFinder().get_dotted_filename('this.is.not.a.python.package')
def test_local_file(self):
abspath = os.path.abspath('this_should_be_my_template')
assert DottedFileNameFinder().get_dotted_filename('this_should_be_my_template') == abspath
def test_local_file_utility_method(self):
abspath = os.path.abspath('this_should_be_my_template')
assert DottedFileNameFinder.lookup('this_should_be_my_template') == abspath
def test_local_file_returns_absolute_path(self):
assert os.path.isabs(DottedFileNameFinder.lookup('this_should_be_my_template'))
class TestLazyString(object):
def test_lazy_string_to_str(self):
l = LazyString(lambda: 'HI')
assert str(l) == 'HI'
def test_lazy_string_to_mod(self):
l = LazyString(lambda: '%s')
assert (l % 'HI') == 'HI'
def test_lazy_string_format(self):
l = LazyString(lambda: '{0}')
lf = l.format('HI')
assert lf == 'HI', lf
class TestAttribSafeContextObj(object):
def setup(self):
self.c = AttribSafeTemplateContext()
def test_attribute_default_value(self):
assert self.c.something == ''
self.c.something = 'HELLO'
assert self.c.something == 'HELLO'
assert self.c.more == ''
def test_tmpl_context_long_entry():
c = TemplateContext()
c.something = '3'*300
assert len(str(c)) < 300
class TestDatesUtils(object):
def test_get_fixed_timezone_seconds(self):
delta = get_fixed_timezone(0.5).utcoffset(None)
assert delta.seconds == 0
def test_get_fixed_timezone_minutes(self):
delta = get_fixed_timezone(1).utcoffset(None)
assert delta.seconds == 60
def test_get_fixed_timezone_hours(self):
delta = get_fixed_timezone(60).utcoffset(None)
assert delta.seconds == 3600
def test_get_fixed_timezone_seconds_td(self):
delta = get_fixed_timezone(timedelta(seconds=30)).utcoffset(None)
assert delta.seconds == 0
def test_get_fixed_timezone_minutes_td(self):
delta = get_fixed_timezone(timedelta(minutes=1)).utcoffset(None)
assert delta.seconds == 60
def test_get_fixed_timezone_hours_td(self):
delta = get_fixed_timezone(timedelta(hours=1)).utcoffset(None)
assert delta.seconds == 3600
def test_get_fixed_timezone_usage(self):
utcnow = datetime.utcnow()
uktz = get_fixed_timezone(60)
uknow = (utcnow + timedelta(hours=1)).replace(tzinfo=uktz)
naiveuk = uknow.astimezone(utctz).replace(tzinfo=None)
assert utcnow == naiveuk, (utcnow, naiveuk)
def test_get_fixed_timezone_name(self):
uktz = get_fixed_timezone(60)
uktz_name = uktz.tzname(None)
assert uktz_name == '+0100', uktz_name
assert repr(uktz) == '<+0100>', repr(uktz)
assert utctz.tzname(None) == 'UTC', utctz.tzname(None)
assert repr(utctz) == '', repr(utctz)
def test_get_fixed_timezone_unknowndst(self):
uktz = get_fixed_timezone(60)
assert uktz.dst(None).seconds == 0
def test_parse_datetime_tz(self):
dt = parse_datetime('1997-07-16T19:20:30.45+01:00')
assert dt.tzname() == '+0100', dt
expected_dt = datetime(1997, 7, 16, 19, 20, 30, 450000)
naive_dt = dt.replace(tzinfo=None)
assert naive_dt == expected_dt, naive_dt
def test_parse_datetime_utc(self):
dt = parse_datetime('1997-07-16T19:20:30.45Z')
assert dt.tzname() == 'UTC', dt
expected_dt = datetime(1997, 7, 16, 19, 20, 30, 450000).replace(tzinfo=utctz)
assert dt == expected_dt, dt
def test_parse_datetime_negativetz(self):
dt = parse_datetime('1997-07-16T19:20:30.45-01:00')
assert dt.tzname() == '-0100', dt
expected_dt = datetime(1997, 7, 16, 19, 20, 30, 450000)
naive_dt = dt.replace(tzinfo=None)
assert naive_dt == expected_dt, naive_dt
@raises(ValueError)
def test_parse_datetime_invalid_format(self):
parse_datetime('1997@07@16T19:20:30.45+01:00')
class TestHtmlUtils(object):
def test_script_json_encode(self):
rv = script_json_encode('')
assert rv == u_('"\\u003c/script\\u003e"')
rv = script_json_encode("<\0/script>")
assert rv == '"\\u003c\\u0000/script\\u003e"'
rv = script_json_encode("