RedHatTraining/pyramid.git

			@@ -2,9 +2,11 @@

			from pyramid.compat import text_


			class TestActionInfo(unittest.TestCase):
			def _getTargetClass(self):
			from pyramid.config.util import ActionInfo

			return ActionInfo

			def _makeOne(self, filename, lineno, function, linerepr):
			@@ -13,11 +15,13 @@
			def test_class_conforms(self):
			from zope.interface.verify import verifyClass
			from pyramid.interfaces import IActionInfo

			verifyClass(IActionInfo, self._getTargetClass())

			def test_instance_conforms(self):
			from zope.interface.verify import verifyObject
			from pyramid.interfaces import IActionInfo

			verifyObject(IActionInfo, self._makeOne('f', 0, 'f', 'f'))

			def test_ctor(self):
			@@ -29,15 +33,16 @@

			def test___str__(self):
			inst = self._makeOne('filename', 0, 'function', ' linerepr ')
			self.assertEqual(str(inst),
			"Line 0 of file filename:\n linerepr ")
			self.assertEqual(
			str(inst), "Line 0 of file filename:\n linerepr "
			)


			class TestPredicateList(unittest.TestCase):

			def _makeOne(self):
			from pyramid.config.util import PredicateList
			from pyramid import predicates

			inst = PredicateList()
			for name, factory in (
			('xhr', predicates.XHRPredicate),
			@@ -51,7 +56,7 @@
			('match_param', predicates.MatchParamPredicate),
			('custom', predicates.CustomPredicate),
			('traverse', predicates.TraversePredicate),
			):
			):
			inst.add(name, factory)
			return inst

			@@ -67,6 +72,7 @@

			def test_ordering_number_of_predicates(self):
			from pyramid.config.util import predvalseq

			order1, _, _ = self._callFUT(
			xhr='xhr',
			request_method='request_method',
			@@ -78,7 +84,7 @@
			containment='containment',
			request_type='request_type',
			custom=predvalseq([DummyCustomPredicate()]),
			)
			)
			order2, _, _ = self._callFUT(
			xhr='xhr',
			request_method='request_method',
			@@ -90,7 +96,7 @@
			containment='containment',
			request_type='request_type',
			custom=predvalseq([DummyCustomPredicate()]),
			)
			)
			order3, _, _ = self._callFUT(
			xhr='xhr',
			request_method='request_method',
			@@ -101,7 +107,7 @@
			accept='accept',
			containment='containment',
			request_type='request_type',
			)
			)
			order4, _, _ = self._callFUT(
			xhr='xhr',
			request_method='request_method',
			@@ -111,7 +117,7 @@
			header='header',
			accept='accept',
			containment='containment',
			)
			)
			order5, _, _ = self._callFUT(
			xhr='xhr',
			request_method='request_method',
			@@ -120,7 +126,7 @@
			match_param='foo=bar',
			header='header',
			accept='accept',
			)
			)
			order6, _, _ = self._callFUT(
			xhr='xhr',
			request_method='request_method',
			@@ -128,34 +134,28 @@
			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',
			)
			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(
			)
			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)
			@@ -170,36 +170,19 @@

			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',
			)

			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()]),
			)
			custom=predvalseq([DummyCustomPredicate()])
			)
			self.assertTrue(order1 > order2)
			self.assertTrue(order2 > order3)
			self.assertTrue(order3 > order4)
			@@ -212,53 +195,50 @@

			def test_ordering_importance_and_number(self):
			from pyramid.config.util import predvalseq

			order1, _, _ = self._callFUT(
			xhr='xhr',
			request_method='request_method',
			)
			xhr='xhr', request_method='request_method'
			)
			order2, _, _ = self._callFUT(
			custom=predvalseq([DummyCustomPredicate()]),
			)
			custom=predvalseq([DummyCustomPredicate()])
			)
			self.assertTrue(order1 < order2)

			order1, _, _ = self._callFUT(
			xhr='xhr',
			request_method='request_method',
			)
			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',
			)
			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',
			)
			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_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]))
			@@ -269,57 +249,71 @@
			order, predicates, phash = self._callFUT(traverse='/1/:a/:b')
			self.assertEqual(len(predicates), 1)
			pred = predicates[0]
			info = {'traverse':'abc'}
			info = {'traverse': 'abc'}
			request = DummyRequest()
			result = pred(info, request)
			self.assertEqual(result, True)
			self.assertEqual(info, {'traverse':'abc'})
			self.assertEqual(info, {'traverse': 'abc'})

			def test_traverse_matches(self):
			order, predicates, phash = self._callFUT(traverse='/1/:a/:b')
			self.assertEqual(len(predicates), 1)
			pred = predicates[0]
			info = {'match':{'a':'a', 'b':'b'}}
			info = {'match': {'a': 'a', 'b': 'b'}}
			request = DummyRequest()
			result = pred(info, request)
			self.assertEqual(result, True)
			self.assertEqual(info, {'match':
			{'a':'a', 'b':'b', 'traverse':('1', 'a', 'b')}})
			self.assertEqual(
			info, {'match': {'a': 'a', 'b': 'b', 'traverse': ('1', 'a', 'b')}}
			)

			def test_traverse_matches_with_highorder_chars(self):
			order, predicates, phash = self._callFUT(
			traverse=text_(b'/La Pe\xc3\xb1a/{x}', 'utf-8'))
			traverse=text_(b'/La Pe\xc3\xb1a/{x}', 'utf-8')
			)
			self.assertEqual(len(predicates), 1)
			pred = predicates[0]
			info = {'match':{'x':text_(b'Qu\xc3\xa9bec', 'utf-8')}}
			info = {'match': {'x': text_(b'Qu\xc3\xa9bec', 'utf-8')}}
			request = DummyRequest()
			result = pred(info, request)
			self.assertEqual(result, True)
			self.assertEqual(
			info['match']['traverse'],
			(text_(b'La Pe\xc3\xb1a', 'utf-8'),
			text_(b'Qu\xc3\xa9bec', 'utf-8'))
			)
			(
			text_(b'La Pe\xc3\xb1a', 'utf-8'),
			text_(b'Qu\xc3\xa9bec', 'utf-8'),
			),
			)

			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')
			custom=predvalseq([custom]), traverse='/1/:dummy/:a'
			)
			self.assertEqual(len(predicates), 2)
			info = {'match':{'a':'a'}}
			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')}})
			self.assertEqual(
			info,
			{
			'match': {
			'a': 'a',
			'dummy': 'foo',
			'traverse': ('1', 'foo', 'a'),
			}
			},
			)

			def test_predicate_text_is_correct(self):
			from pyramid.config.util import predvalseq

			_, predicates, _ = self._callFUT(
			xhr='xhr',
			request_method='request_method',
			@@ -336,10 +330,12 @@
			DummyCustomPredicate.classmethod_predicate_no_text,
			]
			),
			match_param='foo=bar')
			match_param='foo=bar',
			)
			self.assertEqual(predicates[0].text(), 'xhr = True')
			self.assertEqual(predicates[1].text(),
			"request_method = request_method")
			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')
			@@ -354,25 +350,25 @@
			def test_match_param_from_string(self):
			_, predicates, _ = self._callFUT(match_param='foo=bar')
			request = DummyRequest()
			request.matchdict = {'foo':'bar', 'baz':'bum'}
			request.matchdict = {'foo': 'bar', 'baz': 'bum'}
			self.assertTrue(predicates[0](Dummy(), request))

			def test_match_param_from_string_fails(self):
			_, predicates, _ = self._callFUT(match_param='foo=bar')
			request = DummyRequest()
			request.matchdict = {'foo':'bum', 'baz':'bum'}
			request.matchdict = {'foo': 'bum', 'baz': 'bum'}
			self.assertFalse(predicates[0](Dummy(), request))

			def test_match_param_from_dict(self):
			_, predicates, _ = self._callFUT(match_param=('foo=bar','baz=bum'))
			_, predicates, _ = self._callFUT(match_param=('foo=bar', 'baz=bum'))
			request = DummyRequest()
			request.matchdict = {'foo':'bar', 'baz':'bum'}
			request.matchdict = {'foo': 'bar', 'baz': 'bum'}
			self.assertTrue(predicates[0](Dummy(), request))

			def test_match_param_from_dict_fails(self):
			_, predicates, _ = self._callFUT(match_param=('foo=bar','baz=bum'))
			_, predicates, _ = self._callFUT(match_param=('foo=bar', 'baz=bum'))
			request = DummyRequest()
			request.matchdict = {'foo':'bar', 'baz':'foo'}
			request.matchdict = {'foo': 'bar', 'baz': 'foo'}
			self.assertFalse(predicates[0](Dummy(), request))

			def test_request_method_sequence(self):
			@@ -386,20 +382,22 @@
			self.assertFalse(predicates[0](Dummy(), request))

			def test_request_method_ordering_hashes_same(self):
			hash1, _, __= self._callFUT(request_method=('GET', 'HEAD'))
			hash2, _, __= self._callFUT(request_method=('HEAD', 'GET'))
			hash1, _, __ = self._callFUT(request_method=('GET', 'HEAD'))
			hash2, _, __ = self._callFUT(request_method=('HEAD', 'GET'))
			self.assertEqual(hash1, hash2)
			hash1, _, __= self._callFUT(request_method=('GET',))
			hash2, _, __= self._callFUT(request_method='GET')
			hash1, _, __ = self._callFUT(request_method=('GET',))
			hash2, _, __ = self._callFUT(request_method='GET')
			self.assertEqual(hash1, hash2)

			def test_unknown_predicate(self):
			from pyramid.exceptions import ConfigurationError

			self.assertRaises(ConfigurationError, self._callFUT, unknown=1)

			def test_predicate_close_matches(self):
			from pyramid.exceptions import ConfigurationError
			with self.assertRaises(ConfigurationError) as context:

			with self.assertRaises(ConfigurationError) as context:
			self._callFUT(method='GET')
			expected_msg = (
			"Unknown predicate values: {'method': 'GET'} "
			@@ -410,81 +408,111 @@
			def test_notted(self):
			from pyramid.config import not_
			from pyramid.testing import DummyRequest

			request = DummyRequest()
			_, predicates, _ = self._callFUT(
			xhr='xhr',
			request_method=not_('POST'),
			header=not_('header'),
			)
			xhr='xhr', request_method=not_('POST'), header=not_('header')
			)
			self.assertEqual(predicates[0].text(), 'xhr = True')
			self.assertEqual(predicates[1].text(),
			"!request_method = POST")
			self.assertEqual(predicates[1].text(), "!request_method = POST")
			self.assertEqual(predicates[2].text(), '!header header')
			self.assertEqual(predicates[1](None, request), True)
			self.assertEqual(predicates[2](None, request), True)


			class TestDeprecatedPredicates(unittest.TestCase):
			def test_it(self):
			import warnings

			with warnings.catch_warnings(record=True) as w:
			warnings.filterwarnings('always')
			from pyramid.config.predicates import XHRPredicate

			self.assertEqual(len(w), 1)


			class Test_sort_accept_offers(unittest.TestCase):
			def _callFUT(self, offers, order=None):
			from pyramid.config.util import sort_accept_offers

			return sort_accept_offers(offers, order)

			def test_default_specificities(self):
			result = self._callFUT(['text/html', 'text/html;charset=utf8'])
			self.assertEqual(result, [
			'text/html;charset=utf8', 'text/html',
			])
			self.assertEqual(result, ['text/html;charset=utf8', 'text/html'])

			def test_specific_type_order(self):
			result = self._callFUT(
			['text/html', 'application/json', 'text/html;charset=utf8', 'text/plain'],
			[
			'text/html',
			'application/json',
			'text/html;charset=utf8',
			'text/plain',
			],
			['application/json', 'text/html'],
			)
			self.assertEqual(result, [
			'application/json', 'text/html;charset=utf8', 'text/html', 'text/plain',
			])
			self.assertEqual(
			result,
			[
			'application/json',
			'text/html;charset=utf8',
			'text/html',
			'text/plain',
			],
			)

			def test_params_order(self):
			result = self._callFUT(
			['text/html;charset=utf8', 'text/html;charset=latin1', 'text/html;foo=bar'],
			[
			'text/html;charset=utf8',
			'text/html;charset=latin1',
			'text/html;foo=bar',
			],
			['text/html;charset=latin1', 'text/html;charset=utf8'],
			)
			self.assertEqual(result, [
			'text/html;charset=latin1', 'text/html;charset=utf8', 'text/html;foo=bar',
			])
			self.assertEqual(
			result,
			[
			'text/html;charset=latin1',
			'text/html;charset=utf8',
			'text/html;foo=bar',
			],
			)

			def test_params_inherit_type_prefs(self):
			result = self._callFUT(
			['text/html;charset=utf8', 'text/plain;charset=latin1'],
			['text/plain', 'text/html'],
			)
			self.assertEqual(result, ['text/plain;charset=latin1', 'text/html;charset=utf8'])
			self.assertEqual(
			result, ['text/plain;charset=latin1', 'text/html;charset=utf8']
			)


			class DummyCustomPredicate(object):
			def __init__(self):
			self.__text__ = 'custom predicate'

			def classmethod_predicate(*args): pass
			def classmethod_predicate(*args):
			pass

			classmethod_predicate.__text__ = 'classmethod predicate'
			classmethod_predicate = classmethod(classmethod_predicate)

			@classmethod
			def classmethod_predicate_no_text(*args): pass # pragma: no cover
			def classmethod_predicate_no_text(*args):
			pass # pragma: no cover


			class Dummy(object):
			def __init__(self, **kw):
			self.__dict__.update(**kw)


			class DummyRequest:
			subpath = ()
			matchdict = None

			def __init__(self, environ=None):
			if environ is None:
			environ = {}
			@@ -492,6 +520,7 @@
			self.params = {}
			self.cookies = {}


			class DummyConfigurator(object):
			def maybe_dotted(self, thing):
			return thing