def test_different_custom_predicates_with_same_hash(self):
from pyramid.config.util import predvalseq
class PredicateWithHash(object):
def __hash__(self):
return 1
a = PredicateWithHash()
b = PredicateWithHash()
_, _, a_phash = self._callFUT(custom=predvalseq([a]))
_, _, b_phash = self._callFUT(custom=predvalseq([b]))
self.assertEqual(a_phash, b_phash)
def test_different_custom_predicates_with_same_hash(self):
from pyramid.config.util import predvalseq
class PredicateWithHash(object):
def __hash__(self):
return 1
a = PredicateWithHash()
b = PredicateWithHash()
_, _, a_phash = self._callFUT(custom=predvalseq([a]))
_, _, b_phash = self._callFUT(custom=predvalseq([b]))
self.assertEqual(a_phash, b_phash)
def test_predicate_text_is_correct(self):
from pyramid.config.util import predvalseq
_, predicates, _ = self._callFUT(
xhr='xhr',
request_method='request_method',
path_info='path_info',
request_param='param',
header='header',
accept='accept',
containment='containment',
request_type='request_type',
custom=predvalseq([
DummyCustomPredicate(),
DummyCustomPredicate.classmethod_predicate,
DummyCustomPredicate.classmethod_predicate_no_text,
]),
match_param='foo=bar')
self.assertEqual(predicates[0].text(), 'xhr = True')
self.assertEqual(predicates[1].text(),
"request_method = request_method")
self.assertEqual(predicates[2].text(), 'path_info = path_info')
self.assertEqual(predicates[3].text(), 'request_param param')
self.assertEqual(predicates[4].text(), 'header header')
self.assertEqual(predicates[5].text(), 'accept = accept')
self.assertEqual(predicates[6].text(), 'containment = containment')
self.assertEqual(predicates[7].text(), 'request_type = request_type')
self.assertEqual(predicates[8].text(), "match_param foo=bar")
self.assertEqual(predicates[9].text(), 'custom predicate')
self.assertEqual(predicates[10].text(), 'classmethod predicate')
self.assertTrue(predicates[11].text().startswith('custom predicate'))
def test_predicate_text_is_correct(self):
from pyramid.config.util import predvalseq
_, predicates, _ = self._callFUT(
xhr='xhr',
request_method='request_method',
path_info='path_info',
request_param='param',
header='header',
accept='accept',
containment='containment',
request_type='request_type',
custom=predvalseq(
[
DummyCustomPredicate(),
DummyCustomPredicate.classmethod_predicate,
DummyCustomPredicate.classmethod_predicate_no_text,
]
),
match_param='foo=bar')
self.assertEqual(predicates[0].text(), 'xhr = True')
self.assertEqual(predicates[1].text(),
"request_method = request_method")
self.assertEqual(predicates[2].text(), 'path_info = path_info')
self.assertEqual(predicates[3].text(), 'request_param param')
self.assertEqual(predicates[4].text(), 'header header')
self.assertEqual(predicates[5].text(), 'accept = accept')
self.assertEqual(predicates[6].text(), 'containment = containment')
self.assertEqual(predicates[7].text(), 'request_type = request_type')
self.assertEqual(predicates[8].text(), "match_param foo=bar")
self.assertEqual(predicates[9].text(), 'custom predicate')
self.assertEqual(predicates[10].text(), 'classmethod predicate')
self.assertTrue(predicates[11].text().startswith('custom predicate'))
def test_predicate_text_is_correct(self):
from pyramid.config.util import predvalseq
_, predicates, _ = self._callFUT(
xhr="xhr",
request_method="request_method",
path_info="path_info",
request_param="param",
header="header",
accept="accept",
containment="containment",
request_type="request_type",
custom=predvalseq(
[
DummyCustomPredicate(),
DummyCustomPredicate.classmethod_predicate,
DummyCustomPredicate.classmethod_predicate_no_text,
]
),
match_param="foo=bar",
)
self.assertEqual(predicates[0].text(), "xhr = True")
self.assertEqual(predicates[1].text(), "request_method = request_method")
self.assertEqual(predicates[2].text(), "path_info = path_info")
self.assertEqual(predicates[3].text(), "request_param param")
self.assertEqual(predicates[4].text(), "header header")
self.assertEqual(predicates[5].text(), "accept = accept")
self.assertEqual(predicates[6].text(), "containment = containment")
self.assertEqual(predicates[7].text(), "request_type = request_type")
self.assertEqual(predicates[8].text(), "match_param foo=bar")
self.assertEqual(predicates[9].text(), "custom predicate")
self.assertEqual(predicates[10].text(), "classmethod predicate")
self.assertTrue(predicates[11].text().startswith("custom predicate"))
def test_ordering_importance_and_number(self):
from pyramid.config.util import predvalseq
order1, _, _ = self._callFUT(
xhr='xhr',
request_method='request_method',
)
order2, _, _ = self._callFUT(
custom=predvalseq([DummyCustomPredicate()]),
)
self.assertTrue(order1 < order2)
order1, _, _ = self._callFUT(
xhr='xhr',
request_method='request_method',
)
order2, _, _ = self._callFUT(
request_method='request_method',
custom=predvalseq([DummyCustomPredicate()]),
)
self.assertTrue(order1 > order2)
order1, _, _ = self._callFUT(
xhr='xhr',
request_method='request_method',
path_info='path_info',
)
order2, _, _ = self._callFUT(
request_method='request_method',
custom=predvalseq([DummyCustomPredicate()]),
)
self.assertTrue(order1 < order2)
order1, _, _ = self._callFUT(
xhr='xhr',
request_method='request_method',
path_info='path_info',
)
order2, _, _ = self._callFUT(
xhr='xhr',
request_method='request_method',
custom=predvalseq([DummyCustomPredicate()]),
)
self.assertTrue(order1 > order2)
def test_ordering_importance_and_number(self):
from pyramid.config.util import predvalseq
order1, _, _ = self._callFUT(
xhr='xhr',
request_method='request_method',
)
order2, _, _ = self._callFUT(
custom=predvalseq([DummyCustomPredicate()]),
)
self.assertTrue(order1 < order2)
order1, _, _ = self._callFUT(
xhr='xhr',
request_method='request_method',
)
order2, _, _ = self._callFUT(
request_method='request_method',
custom=predvalseq([DummyCustomPredicate()]),
)
self.assertTrue(order1 > order2)
order1, _, _ = self._callFUT(
xhr='xhr',
request_method='request_method',
path_info='path_info',
)
order2, _, _ = self._callFUT(
request_method='request_method',
custom=predvalseq([DummyCustomPredicate()]),
)
self.assertTrue(order1 < order2)
order1, _, _ = self._callFUT(
xhr='xhr',
request_method='request_method',
path_info='path_info',
)
order2, _, _ = self._callFUT(
xhr='xhr',
request_method='request_method',
custom=predvalseq([DummyCustomPredicate()]),
)
self.assertTrue(order1 > order2)
def test_custom_predicates_can_affect_traversal(self):
from pyramid.config.util import predvalseq
def custom(info, request):
m = info["match"]
m["dummy"] = "foo"
return True
_, predicates, _ = self._callFUT(custom=predvalseq([custom]), traverse="/1/:dummy/:a")
self.assertEqual(len(predicates), 2)
info = {"match": {"a": "a"}}
request = DummyRequest()
self.assertTrue(all([p(info, request) for p in predicates]))
self.assertEqual(info, {"match": {"a": "a", "dummy": "foo", "traverse": ("1", "foo", "a")}})
def test_custom_predicates_can_affect_traversal(self):
from pyramid.config.util import predvalseq
def custom(info, request):
m = info['match']
m['dummy'] = 'foo'
return True
_, predicates, _ = self._callFUT(
custom=predvalseq([custom]),
traverse='/1/:dummy/:a')
self.assertEqual(len(predicates), 2)
info = {'match':{'a':'a'}}
request = DummyRequest()
self.assertTrue(all([p(info, request) for p in predicates]))
self.assertEqual(info, {'match':
{'a':'a', 'dummy':'foo',
'traverse':('1', 'foo', 'a')}})
def test_custom_predicates_can_affect_traversal(self):
from pyramid.config.util import predvalseq
def custom(info, request):
m = info['match']
m['dummy'] = 'foo'
return True
_, predicates, _ = self._callFUT(
custom=predvalseq([custom]),
traverse='/1/:dummy/:a')
self.assertEqual(len(predicates), 2)
info = {'match':{'a':'a'}}
request = DummyRequest()
self.assertTrue(all([p(info, request) for p in predicates]))
self.assertEqual(info, {'match':
{'a':'a', 'dummy':'foo',
'traverse':('1', 'foo', 'a')}})
def test_ordering_importance_of_predicates(self):
from pyramid.config.util import predvalseq
order1, _, _ = self._callFUT(
xhr='xhr',
)
order2, _, _ = self._callFUT(
request_method='request_method',
)
order3, _, _ = self._callFUT(
path_info='path_info',
)
order4, _, _ = self._callFUT(
request_param='param',
)
order5, _, _ = self._callFUT(
header='header',
)
order6, _, _ = self._callFUT(
accept='accept',
)
order7, _, _ = self._callFUT(
containment='containment',
)
order8, _, _ = self._callFUT(
request_type='request_type',
)
order9, _, _ = self._callFUT(
match_param='foo=bar',
)
order10, _, _ = self._callFUT(
custom=predvalseq([DummyCustomPredicate()]),
)
self.assertTrue(order1 > order2)
self.assertTrue(order2 > order3)
self.assertTrue(order3 > order4)
self.assertTrue(order4 > order5)
self.assertTrue(order5 > order6)
self.assertTrue(order6 > order7)
self.assertTrue(order7 > order8)
self.assertTrue(order8 > order9)
self.assertTrue(order9 > order10)
def test_ordering_importance_of_predicates(self):
from pyramid.config.util import predvalseq
order1, _, _ = self._callFUT(
xhr='xhr',
)
order2, _, _ = self._callFUT(
request_method='request_method',
)
order3, _, _ = self._callFUT(
path_info='path_info',
)
order4, _, _ = self._callFUT(
request_param='param',
)
order5, _, _ = self._callFUT(
header='header',
)
order6, _, _ = self._callFUT(
accept='accept',
)
order7, _, _ = self._callFUT(
containment='containment',
)
order8, _, _ = self._callFUT(
request_type='request_type',
)
order9, _, _ = self._callFUT(
match_param='foo=bar',
)
order10, _, _ = self._callFUT(
custom=predvalseq([DummyCustomPredicate()]),
)
self.assertTrue(order1 > order2)
self.assertTrue(order2 > order3)
self.assertTrue(order3 > order4)
self.assertTrue(order4 > order5)
self.assertTrue(order5 > order6)
self.assertTrue(order6 > order7)
self.assertTrue(order7 > order8)
self.assertTrue(order8 > order9)
self.assertTrue(order9 > order10)
def test_ordering_importance_of_predicates(self):
from pyramid.config.util import predvalseq
order1, _, _ = self._callFUT(xhr="xhr")
order2, _, _ = self._callFUT(request_method="request_method")
order3, _, _ = self._callFUT(path_info="path_info")
order4, _, _ = self._callFUT(request_param="param")
order5, _, _ = self._callFUT(header="header")
order6, _, _ = self._callFUT(accept="accept")
order7, _, _ = self._callFUT(containment="containment")
order8, _, _ = self._callFUT(request_type="request_type")
order9, _, _ = self._callFUT(match_param="foo=bar")
order10, _, _ = self._callFUT(custom=predvalseq([DummyCustomPredicate()]))
self.assertTrue(order1 > order2)
self.assertTrue(order2 > order3)
self.assertTrue(order3 > order4)
self.assertTrue(order4 > order5)
self.assertTrue(order5 > order6)
self.assertTrue(order6 > order7)
self.assertTrue(order7 > order8)
self.assertTrue(order8 > order9)
self.assertTrue(order9 > order10)
def register_connect():
pvals = other_predicates
pvals.update(
dict(
xhr=xhr,
request_method=request_method,
path_info=path_info,
request_param=request_param,
header=header,
accept=accept,
traverse=traverse,
custom=predvalseq(custom_predicates),
)
)
predlist = self.route_predlist
_, preds, _ = predlist.make(self, **pvals)
route = mapper.connect(
name, pattern, factory, predicates=preds,
pregenerator=pregenerator, static=static
)
intr['object'] = route
return route
def register_connect():
pvals = predicates.copy()
pvals.update(
dict(
xhr=xhr,
request_method=request_method,
path_info=path_info,
request_param=request_param,
header=header,
accept=accept,
traverse=traverse,
custom=predvalseq(custom_predicates),
))
predlist = self.get_predlist('route')
_, preds, _ = predlist.make(self, **pvals)
route = mapper.connect(name,
pattern,
factory,
predicates=preds,
pregenerator=pregenerator,
static=static)
intr['object'] = route
return route
def test_ordering_number_of_predicates(self):
from pyramid.config.util import predvalseq
order1, _, _ = self._callFUT(
xhr="xhr",
request_method="request_method",
path_info="path_info",
request_param="param",
match_param="foo=bar",
header="header",
accept="accept",
containment="containment",
request_type="request_type",
custom=predvalseq([DummyCustomPredicate()]),
)
order2, _, _ = self._callFUT(
xhr="xhr",
request_method="request_method",
path_info="path_info",
request_param="param",
match_param="foo=bar",
header="header",
accept="accept",
containment="containment",
request_type="request_type",
custom=predvalseq([DummyCustomPredicate()]),
)
order3, _, _ = self._callFUT(
xhr="xhr",
request_method="request_method",
path_info="path_info",
request_param="param",
match_param="foo=bar",
header="header",
accept="accept",
containment="containment",
request_type="request_type",
)
order4, _, _ = self._callFUT(
xhr="xhr",
request_method="request_method",
path_info="path_info",
request_param="param",
match_param="foo=bar",
header="header",
accept="accept",
containment="containment",
)
order5, _, _ = self._callFUT(
xhr="xhr",
request_method="request_method",
path_info="path_info",
request_param="param",
match_param="foo=bar",
header="header",
accept="accept",
)
order6, _, _ = self._callFUT(
xhr="xhr",
request_method="request_method",
path_info="path_info",
request_param="param",
match_param="foo=bar",
header="header",
)
order7, _, _ = self._callFUT(
xhr="xhr",
request_method="request_method",
path_info="path_info",
request_param="param",
match_param="foo=bar",
)
order8, _, _ = self._callFUT(
xhr="xhr", request_method="request_method", path_info="path_info", request_param="param"
)
order9, _, _ = self._callFUT(xhr="xhr", request_method="request_method", path_info="path_info")
order10, _, _ = self._callFUT(xhr="xhr", request_method="request_method")
order11, _, _ = self._callFUT(xhr="xhr")
order12, _, _ = self._callFUT()
self.assertEqual(order1, order2)
self.assertTrue(order3 > order2)
self.assertTrue(order4 > order3)
self.assertTrue(order5 > order4)
self.assertTrue(order6 > order5)
self.assertTrue(order7 > order6)
self.assertTrue(order8 > order7)
self.assertTrue(order9 > order8)
self.assertTrue(order10 > order9)
self.assertTrue(order11 > order10)
self.assertTrue(order12 > order10)
