def test_subdomain(self): '''Subdomain filter''' def handler(env, data): self.assertEqual(env.request.path, '/') return Response() def handler_with_prefix(env, data): self.assertEqual(env.request.path, '/j') return Response() app = web.subdomain('host') | web.cases( web.subdomain('') | web.match('/', 'index') | handler, web.subdomain('k') | web.cases( web.subdomain('l') | web.cases(web.match('/', 'l') | handler, ), web.subdomain('') | web.match('/', 'k') | handler), web.subdomain('j') | web.match('/', 'j1') | handler, web.subdomain('j') | web.match('/j', 'j2') | handler_with_prefix) self.assertEqual(web.ask(app, 'http://host/').status_int, 200) self.assertEqual(web.ask(app, 'http://k.host/').status_int, 200) self.assertEqual(web.ask(app, 'http://l.k.host/').status_int, 200) self.assertEqual(web.ask(app, 'http://x.l.k.host/').status_int, 200) self.assertEqual(web.ask(app, 'http://j.host/').status_int, 200) # Test if subdomains in routing are cleaned properly self.assertEqual(web.ask(app, 'http://j.host/j').status_int, 200) self.assert_(web.ask(app, 'http://x.k.host/') is None) self.assert_(web.ask(app, 'http://lk.host/') is None) self.assert_(web.ask(app, 'http://mhost/') is None)
def test_nested_cases(self): 'Locations of nested web.cases' chain = web.cases( web.match('/', 'index'), web.cases( web.match('/docs', 'docs'))) self.assert_(location_keys(chain), ['index', 'docs'])
def setUp(self): class Storage(object): def set(self, *args, **kwargs): return False def delete(self, *args, **kwargs): return False auth = self.auth = CookieAuth(get_user_identity, identify_user, storage=Storage()) def anonymouse(env, data): self.assertTrue(hasattr(env, 'user')) self.assertEqual(env.user, None) return web.Response('ok') def no_anonymouse(env, data): self.assertTrue(hasattr(env, 'user')) self.assertEqual(env.user, MockUser(name='user name')) return web.Response('ok') self.app = web.cases( auth.login(), auth.logout(), auth | web.cases( web.match('/a', 'a') | anonymouse, web.match('/b', 'b') | auth_required | no_anonymouse, ), )
def test_url_building_errors(self): 'UrlBuildingError' app = web.namespace('news') | web.cases( web.match('/', 'index'), web.match('/<int:id>', 'item'), web.match('/', 'anchor', fragment='<int:id>'), ) r = web.Reverse.from_handler(app) self.assertRaises(UrlBuildingError, r.build_url, '') self.assertRaises(UrlBuildingError, lambda: r.as_url) self.assertRaises(UrlBuildingError, r.build_url, 'main') self.assertRaises(UrlBuildingError, lambda: r.main) self.assertRaises(UrlBuildingError, r.build_url, 'news.item') self.assertRaises(UrlBuildingError, lambda: r.news.item.as_url) self.assertRaises(UrlBuildingError, r.build_url, 'news.item', uid=3) self.assertRaises(UrlBuildingError, lambda: r.news.item(uid=3)) self.assertRaises(UrlBuildingError, r.build_url, 'news.item', id=3, uid=3) self.assertRaises(UrlBuildingError, r.build_url, 'news') self.assertRaises(UrlBuildingError, lambda: r.news.as_url) self.assertRaises(UrlBuildingError, r.build_url, 'news.hash') self.assertRaises(UrlBuildingError, lambda: r.news.anchor.as_url) self.assertRaises(UrlBuildingError, r.build_url, 'news.hash', uid=3) self.assertRaises(UrlBuildingError, lambda: r.news.anchor(uid=3).as_url) self.assertRaises(UrlBuildingError, r.build_url, 'news.hash', id=3, uid=3)
def app(self): prepare = self.PrepareItemHandler(self) return web.cases( web.match('', '') | prepare | self, web.match('/autosave', 'autosave') | \ web.method('POST', strict=True) | prepare | self.autosave )
def test_aliases(self): def handler(env, data): return Response(env.current_location + ' ' + env.root.domain1.as_url + ' ' + env.root.domain1.as_url.with_host() + ' ' + env.root.domain2.as_url + ' ' + env.root.domain2.as_url.with_host()) www = web.subdomain('', 'www') app = web.subdomain('example.com', 'example.ru', 'example.com.ua') | web.cases( web.subdomain('ru', None, primary=None) | web.cases( web.subdomain('moscow') | www | web.match('/', 'domain3'), www | web.match('/', 'domain1') ), web.subdomain('en', 'eng') | www | web.match('/', 'domain2'), ) app = app | handler # XXX As for now .with_host() return primary domain, not the current one # It is easy to change the behaviour, but which behaviour is # correct? self.assertEqual(web.ask(app, 'http://ru.example.com/').body, 'domain1 / http://example.com/ ' 'http://en.example.com/ http://en.example.com/') self.assertEqual(web.ask(app, 'http://www.ru.example.ru/').body, 'domain1 / http://example.com/ ' 'http://en.example.com/ http://en.example.com/') self.assertEqual(web.ask(app, 'http://www.example.ru/').body, 'domain1 / http://example.com/ ' 'http://en.example.com/ http://en.example.com/') self.assertEqual(web.ask(app, 'http://moscow.example.ru/').body, 'domain3 http://example.com/ http://example.com/ ' 'http://en.example.com/ http://en.example.com/')
def test_external_urls(self): 'External URL reverse' def host1(env, data): self.assertEqual(env.root.host1.as_url.with_host(), 'http://host1.example.com/url') self.assertEqual(env.root.host2.as_url, 'http://host2.example.com/url') self.assertEqual(env.root.host1.as_url, '/url') self.host1_called = True return Response() def host2(env, data): self.assertEqual(env.root.host2.as_url.with_host(), 'https://host2.example.com/url') self.assertEqual(env.root.host1.as_url, 'https://host1.example.com/url') self.assertEqual(env.root.host2.as_url, '/url') self.host2_called = True return Response() app = web.subdomain('example.com') | web.cases ( web.subdomain('host1') | web.match('/url', 'host1') | host1, web.subdomain('host2') | web.match('/url', 'host2') | host2, ) assert web.ask(app, 'http://host1.example.com/url') assert web.ask(app, 'https://host2.example.com/url') assert self.host1_called and self.host2_called
def test_prefix_and_cases(self): "Locations of web.cases with prefix" chain = web.prefix("/news") | web.cases(web.match("/", "index"), web.match("/docs", "docs")) for k in ("index", "docs"): self.assert_(web.locations(chain).keys(), [k]) self.assert_(web.locations(chain)[k][0].builders) self.assertEqual(len(web.locations(chain)[k][0].builders), 2)
def test_subdomains_and_cases(self): "Locations of web.cases with subdomains" chain = web.subdomain("news") | web.cases(web.match("/", "index"), web.match("/docs", "docs")) for k in ("index", "docs"): self.assert_(web.locations(chain).keys(), [k]) self.assert_(web.locations(chain)[k][0].subdomains) self.assertEqual(web.locations(chain)[k][0].subdomains, ["news"])
def test_external_urls(self): "External URL reverse" def host1(env, data): self.assertEqual(env.root.host1.as_url.with_host(), "http://host1.example.com/url") self.assertEqual(env.root.host2.as_url, "http://host2.example.com/url") self.assertEqual(env.root.host1.as_url, "/url") self.host1_called = True return Response() def host2(env, data): self.assertEqual(env.root.host2.as_url.with_host(), "https://host2.example.com/url") self.assertEqual(env.root.host1.as_url, "https://host1.example.com/url") self.assertEqual(env.root.host2.as_url, "/url") self.host2_called = True return Response() app = web.subdomain("example.com") | web.cases( web.subdomain("host1") | web.match("/url", "host1") | host1, web.subdomain("host2") | web.match("/url", "host2") | host2, ) assert web.ask(app, "http://host1.example.com/url") assert web.ask(app, "https://host2.example.com/url") assert self.host1_called and self.host2_called
def test_nested_prefixes(self): "Reverse with nested prefexes" app = ( web.prefix("/news/<section>") | web.namespace("news") | web.cases( web.match(), web.prefix("/<int:id>") | web.namespace("item") | web.cases( web.match(), web.prefix("/docs") | web.namespace("docs") | web.cases(web.match(), web.match("/<int:id>", "item")), ), ) ) r = web.Reverse.from_handler(app) # Normal behavior self.assertEqual(r.news(section="top").as_url, "/news/top") self.assertEqual(r.news(section="top").item(id=1).as_url, "/news/top/1") self.assertEqual(r.news(section="top").item(id=1).docs.as_url, "/news/top/1/docs") self.assertEqual(r.news(section="top").item(id=1).docs.item(id=2).as_url, "/news/top/1/docs/2") # Exceptional behavior self.assertRaises(UrlBuildingError, lambda: r.news.as_url) # XXX this one raises KeyError, not UrlBuildingError self.assertRaises(UrlBuildingError, lambda: r.news(foo="top").as_url) self.assertRaises(UrlBuildingError, lambda: r.news(section="top").item.as_url) self.assertRaises(UrlBuildingError, lambda: r.news(section="top").item(id=1).docs()) self.assertRaises(UrlBuildingError, lambda: r.news(section="top")()) self.assertRaises(UrlBuildingError, lambda: r.news.item)
def test_few_handlers(self): "Reverse a few handlers" chain = web.cases(web.match("/", "index"), web.match("/docs", "docs"), web.match("/news", "news")) r = web.Reverse.from_handler(chain) self.assertEqual(r.index.as_url, "/") self.assertEqual(r.docs.as_url, "/docs") self.assertEqual(r.news.as_url, "/news")
def test_namespace_and_cases(self): 'Locations namespace with web.cases' chain = web.namespace('news') | web.cases( web.match('/', 'index'), web.match('/docs', 'docs')) self.assertEqual(location_keys(chain), ['news']) self.assertEqual(set(locations(chain)['news'][1].keys()), {'index', 'docs'})
def test_external_urls_no_subdomain(self): 'External URL reverse with no subdomains provided in location' def config(env, data, nxt): env.root = root.bind_to_env(env) return nxt(env, data) called_urls = [] def get_handler(num, result): def handler(env, data): self.assertEqual(env.root.url1.as_url.with_host(), result) called_urls.append(num) return Response() return handler url1 = get_handler(1, 'http://example.com/url') url2 = get_handler(2, 'http://example.com:8000/url') url3 = get_handler(3, 'https://example.com:80/url') app = web.request_filter(config) | web.cases( web.match('/url', 'url1') | url1, web.match('/url2', 'url2') | url2, web.match('/url3', 'url3') | url3, ) root = web.Reverse.from_handler(app) assert web.ask(app, 'http://example.com/url') assert web.ask(app, 'http://example.com:8000/url2') assert web.ask(app, 'https://example.com:80/url3') assert called_urls == [1,2,3]
def test_nested_prefixes(self): 'Reverse with nested prefexes' app = web.prefix('/news/<section>', name='news') | web.cases( web.match(), web.prefix('/<int:id>', name='item') | web.cases( web.match(), web.prefix('/docs', name='docs') | web.cases( web.match(), web.match('/<int:id>', 'item')))) r = web.Reverse.from_handler(app) # Normal behavior self.assertEqual(r.news(section='top').as_url, '/news/top') self.assertEqual(r.news(section='top').item(id=1).as_url, '/news/top/1') self.assertEqual(r.news(section='top').item(id=1).docs.as_url, '/news/top/1/docs') self.assertEqual(r.news(section='top').item(id=1).docs.item(id=2).as_url, '/news/top/1/docs/2') # Exceptional behavior self.assertRaises(UrlBuildingError, lambda: r.news.as_url) # XXX this one raises KeyError, not UrlBuildingError self.assertRaises(UrlBuildingError, lambda: r.news(foo='top').as_url) self.assertRaises(UrlBuildingError, lambda: r.news(section='top').item.as_url) self.assertRaises(UrlBuildingError, lambda: r.news(section='top').item(id=1).docs()) self.assertRaises(UrlBuildingError, lambda: r.news(section='top')()) self.assertRaises(UrlBuildingError, lambda: r.news.item)
def test_subdomain(self): '''Subdomain filter''' def handler(env, data): self.assertEqual(env.request.path, '/') return Response() def handler_with_prefix(env, data): self.assertEqual(env.request.path, '/j') return Response() app = web.subdomain('host') | web.cases( web.subdomain('') | web.match('/', 'index') | handler, web.subdomain('k') | web.cases( web.subdomain('l') | web.cases( web.match('/', 'l') | handler, ), web.subdomain('') | web.match('/', 'k') | handler), web.subdomain('j') | web.match('/', 'j1') | handler, web.subdomain('j') | web.match('/j', 'j2') | handler_with_prefix) self.assertEqual(web.ask(app, 'http://host/').status_int, 200) self.assertEqual(web.ask(app, 'http://k.host/').status_int, 200) self.assertEqual(web.ask(app, 'http://l.k.host/').status_int, 200) self.assertEqual(web.ask(app, 'http://x.l.k.host/').status_int, 200) self.assertEqual(web.ask(app, 'http://j.host/').status_int, 200) # Test if subdomains in routing are cleaned properly self.assertEqual(web.ask(app, 'http://j.host/j').status_int, 200) self.assert_(web.ask(app, 'http://x.k.host/') is None) self.assert_(web.ask(app, 'http://lk.host/') is None) self.assert_(web.ask(app, 'http://mhost/') is None)
def app(self): # Be careful, put prepare handler only after match! Otherwise it brakes # file upload (yes, its not obvious!) prepare = self.PrepareItemHandler(self) return self.app_prefix | web.cases( web.match("", "") | prepare | self, web.match("/autosave", "autosave") | web.method("POST", strict=True) | prepare | self.autosave, )
def app(self): # Be careful, put prepare handler only after match! Otherwise it brakes # file upload (yes, its not obvious!) prepare = self.PrepareItemHandler(self) return self.app_prefix | web.cases( web.match('', '') | prepare | self, web.match('/autosave', 'autosave') | \ web.method('POST', strict=True) | prepare | self.autosave )
def test_subreverse(self): chain = web.cases( web.prefix('/docs', name='docs') | web.cases( web.match('/<int:id>', 'doc'), web.match('/list', 'docs'))) r = web.Reverse.from_handler(chain) self.assertEqual(r.build_subreverse('docs.doc', id=1).as_url, '/docs/1') self.assertEqual(r.build_subreverse('docs').doc(id=1).as_url, '/docs/1')
def app(self): prefix = web.prefix('/<noneint:item>/' + self.action + '/<field_name>', name=self.action, convs={'noneint': NoneIntConv}) prepare = PrepareItemHandler(self) return prefix | web.cases( web.match() | prepare | self, web.match('/crop', 'crop') | prepare | self.crop, )
def app(self): def exc(env, data): raise HTTPMethodNotAllowed return web.cases( web.match("/", "index") | (lambda e, d: Response(body="index")), web.match("/500", "err500") | (lambda e, d: 1 + ""), web.match("/403", "err403") | exc, )
def app(self): return web.cases( web.match('/doc-link-block/<int:id>', 'doc_link_block') | self.doc_link_item, web.match('/files-block/<int:id>', 'files_block') | self.files_item, web.match('/media-link-block/<int:id>', 'media_block') | self.media_item, )
def app(self): prefix = web.prefix('/<noneint:item>/'+self.action+'/<field_name>', name=self.action, convs={'noneint': NoneIntConv}) prepare = PrepareItemHandler(self) return prefix | web.cases( web.match() | prepare | self, web.match('/crop', 'crop') | prepare | self.crop, )
def app(self): # Be careful, put prepare handler only after match! Otherwise it brakes # file upload (yes, its not obvious!) prepare = self.PrepareItemHandler(self) return self.app_prefix | web.cases( web.match('', '') | prepare | self, web.match('/autosave', 'autosave') | \ web.method('POST', strict=True) | prepare |self.autosave )
def test_double_call(self): app = web.prefix('/news', name='news') | web.cases( web.match('/<sort>'), web.match('/<sort>/page/<int:page>', name='page'), web.match('/feed', name='feed'), ) r = web.Reverse.from_handler(app) self.assertRaises(UrlBuildingError, lambda: r.news(sort='desc')())
def test_deafult_name(self): 'Reverse default name' app = web.cases( web.match('/'), web.match('/index', 'index'), ) r = web.Reverse.from_handler(app) self.assertEqual(r.as_url, '/') self.assertEqual(r.index.as_url, '/index')
def test_prefix_and_cases(self): 'Locations of web.cases with prefix' chain = web.prefix('/news') | web.cases( web.match('/', 'index'), web.match('/docs', 'docs')) for k in ('index', 'docs'): self.assert_(location_keys(chain), [k]) self.assert_(locations(chain)[k][0].builders) self.assertEqual(len(locations(chain)[k][0].builders), 2)
def test_subdomain_after_namespace(self): app = web.subdomain('news', name='news') | web.subdomain('eng') | web.cases( web.match('/'), web.match('/<int:id>', 'item'), ) r = web.Reverse.from_handler(app) self.assertEqual(r.build_url('news.item', id=1), 'http://eng.news/1') self.assertEqual(r.build_url('news'), 'http://eng.news/') self.assertEqual(r.news.item(id=1).as_url, 'http://eng.news/1') self.assertEqual(r.news.as_url, 'http://eng.news/')
def app(self): def exc(env, data): raise HTTPMethodNotAllowed return web.cases( web.match('/', 'index') | (lambda e,d: Response(body='index')), web.match('/500', 'err500') | (lambda e,d: 1+''), web.match('/403', 'err403') | exc, web.match('/broken_response', 'broken_response') | \ (lambda e,d: 0), )
def test_not_found(self): """Check int converter with handler which accepts params""" def handler(env, data): return Response() app = web.cases(web.match("/first", "first") | handler, web.match("/second/<int:id>", "second") | handler) self.assert_(web.ask(app, "/second/42/") is None) self.assert_(web.ask(app, "/second/42s") is None)
def app(self): if isinstance(self.stream, Loner): prefix = web.prefix('/log', name=self.action) else: prefix = web.prefix('/<idconv:item>/log', name=self.action, convs={'idconv': self.stream.id_converter}) return prefix | self.PrepareItemHandler(self) | web.cases( web.match('') | self, web.match('/<int:log_id>', 'entry') | self.log_entry, )
def test_prefix_after_namespace(self): app = web.prefix('/news', name='news') | web.prefix('/<section>') | web.cases( web.match(), web.match('/<int:id>', 'item'), ) r = web.Reverse.from_handler(app) self.assertEqual(r.build_url('news.item', section='top', id=1), '/news/top/1') self.assertEqual(r.build_url('news', section='top'), '/news/top') self.assertEqual(r.news(section='top').item(id=1).as_url, '/news/top/1') self.assertEqual(r.news(section='top').as_url, '/news/top')
def test_int_converter(self): """Check int converter""" def handler(env, data): self.assertEqual(data.id, 42) return Response() app = web.cases(web.match("/first", "first") | handler, web.match("/second/<int:id>", "second") | handler) web.ask(app, "/second/42")
def test_int_converter(self): '''Check int converter''' def handler(env, data): self.assertEqual(data.id, 42) return Response() app = web.cases( web.match('/first', 'first') | handler, web.match('/second/<int:id>', 'second') | handler) web.ask(app, '/second/42')
def test_not_found(self): '''Check int converter with handler which accepts params''' def handler(env, data): return Response() app = web.cases( web.match('/first', 'first') | handler, web.match('/second/<int:id>', 'second') | handler) self.assert_(web.ask(app, '/second/42/') is None) self.assert_(web.ask(app, '/second/42s') is None)
def setUp(self): from sqlalchemy import Column, Integer, String, create_engine, orm from sqlalchemy.schema import MetaData from sqlalchemy.ext.declarative import declarative_base metadata = MetaData() Model = declarative_base(metadata=metadata) class User(Model): __tablename__ = 'users' id = Column(Integer, primary_key=True) login = Column(String(255), nullable=False, unique=True) password = Column(String(255), nullable=False) auth = SqlaModelAuth(User) class Env(web.AppEnvironment): @cached_property def db(self): return orm.sessionmaker(bind=create_engine('sqlite://'))() @cached_property def template(self): return MockTemplateManager() @web.request_filter def make_env(env, data, nxt): metadata.create_all(env.db.bind) user = User(login='******', password=encrypt_password('123')) env.db.add(user) env.db.commit() try: return nxt(env, data) finally: env.db.close() def anonymouse(env, data): self.assertTrue(hasattr(env, 'user')) self.assertEqual(env.user, None) return web.Response('ok') def no_anonymouse(env, data): self.assertTrue(hasattr(env, 'user')) self.assertEqual(env.user.login, 'user name') return web.Response('ok') app = make_env | web.cases( auth.login(), auth.logout(), auth | web.cases( web.match('/a', 'a') | anonymouse, web.match('/b', 'b') | auth_required | no_anonymouse, ), ) self.app = web.Application(app, Env)
def test_multiple_int_convs(self): '''Check multiple int converters''' def handler(env, data): self.assertEqual(data.id, 42) self.assertEqual(data.param, 23) return Response() app = web.cases( web.match('/first', 'first') | handler, web.match('/second/<int:id>/<int:param>', 'second') | handler) web.ask(app, '/second/42/23')
def test_handler_after_case(self): '''Test if the handler next to cases is called''' r = Response() def handler(env, data): return r app = web.cases(web.match('/first', 'first'), web.match('/second/<int:id>', 'second')) | handler self.assertEqual(web.ask(app, '/first'), r) self.assertEqual(web.ask(app, '/second/2'), r)
def test_current_location(self): def test_ns(env, data): return env.current_location app = web.cases( web.match('/', 'm1'), web.prefix('/ns', name="ns1.ns2") | web.cases( web.match(''), web.match('/m2', 'm2'), )) | test_ns self.assertEqual(web.ask(app, '/'), 'm1') self.assertEqual(web.ask(app, '/ns'), 'ns1.ns2') self.assertEqual(web.ask(app, '/ns/m2'), 'ns1.ns2.m2')
def test_prefix_with_zeros_in_int(self): '''Simple prefix''' from iktomi.web.url_converters import Converter, ConvertError def handler(env, data): return Response() class ZeroInt(Converter): def to_python(self, value, env=None): try: value = int(value) except ValueError: raise ConvertError(self.name, value) else: return value def to_url(self, value): return str(value) app = web.cases( web.prefix('/section/<int:section_id>', convs={'int': ZeroInt}) | web.match('/item', 'doc') | handler) #self.assertEqual(web.ask(app, '/section/1').status_int, 200) self.assertEqual(web.ask(app, '/section/1/item').status_int, 200) self.assertEqual(web.ask(app, '/section/001/item').status_int, 200)
def test_simple_match(self): '''Check simple case of match''' app = web.match('/first', 'first') | (lambda e, d: Response()) self.assertEqual(web.ask(app, '/first').status_int, 200) self.assertEqual(web.ask(app, '/second'), None)
def test_match_empty_pattern(self): '''Test if match() works proper with empty patterns''' r = Response() app = web.prefix('/') | web.match('', 'index') | (lambda e, d: r) self.assertEqual(web.ask(app, '/'), r)
def test_prefix_leaf(self): '''Simple prefix''' def handler(env, data): self.assertEqual(env._route_state.path, '/item') return Response() app = web.cases( web.match('/', 'index'), web.prefix('/docs') | web.cases( web.match('/', 'docs') | handler, web.match('/item', 'doc') | handler, web.prefix('/tags') | web.cases( web.match('/', 'tags') | handler, web.match('/tag', 'tag') | handler))) self.assertEqual(web.ask(app, '/docs/item').status_int, 200)
def cases(cls, sections, section): return [ match('/', name='rules') | cache(False) | cls.h_rules, GuardedMatch('/form/', name='form', methods=('GET', 'POST')) | cache(False) | cls.h_form, sections.h_section(section), ]
def test_prefix_state(self): '''Prefix state correctness''' def handler(env, data): return Response() app = web.cases( web.match('/', 'index'), web.prefix('/docs') | web.namespace('doc') | web.cases( web.match('/item', '') | handler, web.prefix('/list') | web.cases(web.match('/item', 'list') | handler), web.match('/other-thing', 'something') | handler), web.match('/something', 'something') | handler) self.assertEqual(web.ask(app, '/docs/something'), None) self.assertEqual(web.ask(app, '/docs/list/something'), None) self.assertEqual(web.ask(app, '/docs/list/other-thing'), None)
def setUp(self): auth = self.auth = CookieAuth(get_user_identity, identify_user) def anonymouse(env, data): self.assertTrue(hasattr(env, 'user')) self.assertEqual(env.user, None) return web.Response('ok') def no_anonymouse(env, data): self.assertTrue(hasattr(env, 'user')) self.assertEqual(env.user, MockUser(name='user name')) return web.Response('ok') self.app = web.cases( auth.login(), auth.logout(redirect_to=None), auth | web.cases( web.match('/a', 'a') | anonymouse, web.match('/b', 'b') | auth_required | no_anonymouse, ), )
def test_by_method_default(self): app = web.match('/') | web.by_method( { 'DELETE': lambda e, d: Response('delete'), }, default_handler=lambda e, d: Response('default')) self.assertEqual(web.ask(app, '/', method="DELETE").body, b'delete') self.assertEqual(web.ask(app, '/').body, b'default')
def test_nested_namespaces(self): def test_ns(env, data): return env.namespace app = web.prefix('/ns1', name="ns1") | \ web.prefix('/ns2', name="ns2") | \ web.match() | test_ns self.assertEqual(web.ask(app, '/ns1/ns2'), 'ns1.ns2')
def test_unicode(self): '''IRI tests''' app = web.subdomain(u'рф') | web.subdomain(u'сайт') | web.match( '/', 'site') | (lambda e, d: Response()) encoded = 'http://xn--80aswg.xn--p1ai/' self.assertEqual( web.Reverse.from_handler(app).site.as_url.get_readable(), u'http://сайт.рф/') self.assertEqual(web.Reverse.from_handler(app).site.as_url, encoded) self.assertNotEqual(web.ask(app, encoded), None)
def test_simple_match(self): '''Method''' from webob.exc import HTTPMethodNotAllowed app = web.cases( web.match('/', 'simple') | web.method('post'), web.match('/second', 'second') | web.method('POST'), web.match('/strict', 'strict') | web.method('post', strict=True)) | (lambda e, d: Response()) self.assertEqual(web.ask(app, '/'), None) self.assertEqual(web.ask(app, '/', method='post').status_int, 200) self.assertEqual( web.ask(app, '/second', method='post').status_int, 200) self.assertRaises(HTTPMethodNotAllowed, lambda: web.ask(app, '/strict').status_int) self.assertEqual( web.ask(app, '/strict', method='post').status_int, 200)
def test_by_method(self): app = web.match('/') | web.by_method( { 'DELETE': lambda e, d: Response('delete'), ('POST', 'PUT'): lambda e, d: Response('post'), }) self.assertEqual(web.ask(app, '/', method="PUT").body, b'post') self.assertEqual(web.ask(app, '/', method="DELETE").body, b'delete') self.assertEqual(web.ask(app, '/').status_int, 405)
def create_handler(app): h_caching = Caching(app.cache, duration=app.cfg.CACHE_TIME) h_sections_ru = app.sections['ru'].handler() h_sections_en = app.sections['en'].handler() return cases( static_files(app.cfg.STATIC_DIR, app.cfg.STATIC_URL), static_files(app.cfg.FRONT_MEDIA_DIR, app.cfg.MEDIA_URL), h_caching | cache(enable=app.cfg.CACHE_ENABLED) | cases( prefix('/en') | app.i18n.handler('en') | cases( match('/', name='index') | h_index, h_sections_en, ), app.i18n.handler('ru') | cases( match('/', name='index') | h_index, h_sections_ru, ), ), HTTPNotFound, )
def test_repr(self): # for coverage '%r' % web.WebHandler() '%r' % web.cases() '%r' % web.request_filter(lambda e, d, n: None) '%r' % web.match('/', 'index') '%r' % web.method('GET') '%r' % web.static_files('/prefix') '%r' % web.prefix('/prefix') '%r' % web.subdomain('name') '%r' % web.namespace('name')
def test_prefix_root(self): '''Prefix root''' def handler(env, data): self.assertEqual(env._route_state.path, '/') return Response() app = web.cases( web.match('/', 'index') | handler, web.prefix('/docs') | web.cases( web.match('/', 'docs') | handler, web.match('/item', 'doc') | handler, web.prefix('/tags') | web.cases( web.match('/', 'tags') | handler, web.match('/tag', 'tag') | handler))) self.assertEqual(web.ask(app, '/docs'), None) self.assertEqual(web.ask(app, '/docs/').status_int, 200) self.assertEqual(web.ask(app, '/docs/tags'), None) self.assertEqual(web.ask(app, '/docs/tags/').status_int, 200) self.assertEqual(web.ask(app, '/docs/tags/asdasd'), None)
def app(self): return web.cases( web.match('/redirect', 'redirect') | redirect_to('rule1', qs={'page': 1}), Rule( '/rule1', name='rule1', handler=(lambda e, d: Response('rule1')), ), Rule('/rule2', method='POST', handler=lambda e, d: Response('rule2')), )