def test_get_args(self): @functions.signature(str, str, int, atypes.ArrayType(int), types.listtype, body=NestedObj) def myfunc(self, first, second, third, foo, nested): pass funcdef = functions.FunctionDefinition.get(myfunc) params = multidict.MultiDict(foo='0,1, 2, three', second='2') mimetype = 'application/json' body = b'{"o": {"id": 1234, "name": "an object"}}' fromargs = ['one'] fromkwargs = {'third': '1'} newargs, newkwargs = args.get_args(funcdef, fromargs, fromkwargs, params, body, mimetype) self.assertEqual([], newargs) n = newkwargs.pop('nested') self.assertEqual( { 'first': 'one', 'foo': ['0', '1', '2', 'three'], 'second': 2, 'third': [1] }, newkwargs) self.assertEqual(1234, n.o.id) self.assertEqual('an object', n.o.name) # check_arguments missing mandatory argument 'second' params = multidict.MultiDict(foo='0,1, 2, three', ) self.assertRaises(exception.MissingArgument, args.get_args, funcdef, fromargs, fromkwargs, params, body, mimetype)
def test_queries_multiple_uris(self, storage): """ Uses a `terms` filter against target.scope to filter for URI. When multiple "uri" fields are supplied, the normalized URIs of all of them should be collected into a set and sent in the query. """ request = mock.Mock() params = multidict.MultiDict() params.add("uri", "http://example.com") params.add("uri", "http://example.net") storage.expand_uri.side_effect = [ ["http://giraffes.com/", "https://elephants.com/"], ["http://tigers.com/", "https://elephants.com/"], ] urifilter = query.UriFilter(request) result = urifilter(params) query_uris = result["terms"]["target.scope"] storage.expand_uri.assert_any_call(request.db, "http://example.com") storage.expand_uri.assert_any_call(request.db, "http://example.net") assert sorted(query_uris) == sorted(["httpx://giraffes.com", "httpx://elephants.com", "httpx://tigers.com"])
def _get_instance(self, **kwargs): if kwargs: data = multidict.MultiDict(kwargs) else: data = self.data.copy() def tracker(*args, **kwargs): pass return self.klass(data, __tracker=tracker, __name='tracker')
def test_add(self): d = multidict.MultiDict({"a": "1"}) d.add("a", "2") self.assertEqual(list(d.getall("a")), ["1", "2"]) d = self._get_instance() d.add("b", "3") self.assertEqual(list(d.getall("b")), ["1", "3"])
def test_add(self): d = multidict.MultiDict({'a': '1'}) d.add('a', '2') self.assertEquals(list(d.getall('a')), ['1', '2']) d = self._get_instance() d.add('b', '3') self.assertEqual(list(d.getall('b')), ['1', '3'])
def test_tagsmatcher_aliases_tag_to_tags(): """'tag' params should be transformed into 'tags' queries. 'tag' is aliased to 'tags' because users often type tag instead of tags. """ params = multidict.MultiDict() params.add('tag', 'foo') params.add('tag', 'bar') result = query.TagsMatcher()(params) assert result == { 'bool': { 'must': [ { 'match': { 'tags': { 'query': 'foo', 'operator': 'and' } } }, { 'match': { 'tags': { 'query': 'bar', 'operator': 'and' } } }, ] } }
def test_tagsmatcher_aliases_tag_to_tags(): """'tag' params should be transformed into 'tags' queries. 'tag' is aliased to 'tags' because users often type tag instead of tags. """ params = multidict.MultiDict() params.add('tag', 'foo') params.add('tag', 'bar') result = query.TagsMatcher()(params) assert list(result.keys()) == ['bool'] assert list(result['bool'].keys()) == ['must'] assert len(result['bool']['must']) == 2 assert { 'match': { 'tags': { 'query': 'foo', 'operator': 'and' } } } in result['bool']['must'] assert { 'match': { 'tags': { 'query': 'bar', 'operator': 'and' } } } in result['bool']['must']
def test_from_param(self): # datetime param expected = datetime.datetime(2015, 8, 13, 11, 38, 9, 496475) self.assertEqual( expected, args.from_param(datetime.datetime, '2015-08-13T11:38:09.496475')) self.assertIsNone(args.from_param(datetime.datetime, None)) # usertype param self.assertEqual(['0', '1', '2', 'three'], args.from_param(types.listtype, '0,1, 2, three')) # array param atype = atypes.ArrayType(int) self.assertEqual([0, 1, 1234, None], args.from_param(atype, [0, '1', '1_234', None])) self.assertIsNone(args.from_param(atype, None)) # string param self.assertEqual('foo', args.from_param(str, 'foo')) self.assertIsNone(args.from_param(str, None)) # string param with from_params hit_paths = set() params = multidict.MultiDict(foo='bar', ) self.assertEqual('bar', args.from_params(str, params, 'foo', hit_paths)) self.assertEqual({'foo'}, hit_paths)
def test_supports_filtering_for_multiple_users(self): userfilter = query.UserFilter() params = multidict.MultiDict() params.add("user", "alice") params.add("user", "luke") assert userfilter(params) == {"terms": {"user": ["alice", "luke"]}}
def _get_instance(self, environ=None, **kwargs): if environ is None: environ = {} if kwargs: data = multidict.MultiDict(kwargs) else: data = self.data.copy() return self.klass(data, environ)
def generate_response(self, start_response, status, headers, body): headers = multidict.MultiDict(headers) content_type = headers.get('Content-Type') if content_type and content_type.startswith('text/html'): body = self.generate_body(body) headers['Content-Length'] = str(len(body)) start_response(status, list(headers.iteritems()))(body)
def test_array_from_params(self): hit_paths = set() datatype = atypes.ArrayType(str) params = multidict.MultiDict(foo='bar', one='two') self.assertEqual(['bar'], args.from_params(datatype, params, 'foo', hit_paths)) self.assertEqual({'foo'}, hit_paths) self.assertEqual(['two'], args.array_from_params(datatype, params, 'one', hit_paths)) self.assertEqual({'foo', 'one'}, hit_paths)
def test_usertype_from_params(self): hit_paths = set() datatype = types.listtype params = multidict.MultiDict(foo='0,1, 2, three', ) self.assertEqual(['0', '1', '2', 'three'], args.usertype_from_params(datatype, params, 'foo', hit_paths)) self.assertEqual(['0', '1', '2', 'three'], args.from_params(datatype, params, 'foo', hit_paths)) self.assertEqual( atypes.Unset, args.usertype_from_params(datatype, params, 'bar', hit_paths))
def on_unenroll_submit(cls, student, handler, parameters_list): # pylint: disable=abstract-class-instantiated parameters = multidict.MultiDict(parameters_list) if parameters.get(cls.DATA_REMOVAL_FIELD_NAME, 'False') != 'True': return False # Paint first page of our hijacking flow. handler.template_value['unenroll_parameters'] = transforms.dumps( parameters_list) DataRemovalConfirmationHandler.class_get(handler) # Tell unenroll_post_continue that we are hijacking the page flow, # so it should not render its own page. return True
def test_default_params_multidict(self): """Multiple params go into multiple "match" dicts.""" builder = query.Builder(ES_VERSION) params = multidict.MultiDict() params.add("user", "fred") params.add("user", "bob") q = builder.build(params) assert q["query"] == { 'bool': {'filter': [], 'must': [{'match': {'user': '******'}}, {'match': {'user': '******'}}]}, }
def test_args_from_params(self): @functions.signature(str, str, int, atypes.ArrayType(int), types.listtype) def myfunc(self, first, second, third, foo): pass funcdef = functions.FunctionDefinition.get(myfunc) params = multidict.MultiDict(foo='0,1, 2, three', third='1', second='2') self.assertEqual(([], { 'foo': ['0', '1', '2', 'three'], 'second': 2, 'third': [1] }), args.args_from_params(funcdef, params)) # unexpected param params = multidict.MultiDict(bar='baz') self.assertRaises(exception.UnknownArgument, args.args_from_params, funcdef, params) # no params plus a body params = multidict.MultiDict(__body__='') self.assertEqual(([], {}), args.args_from_params(funcdef, params))
def test_anymatcher_multiple_params(): """Multiple keywords at once are handled correctly.""" anymatcher = query.AnyMatcher() params = multidict.MultiDict() params.add("any", "howdy") params.add("any", "there") result = anymatcher(params) assert result == { "simple_query_string": { "fields": ["quote", "tags", "text", "uri.parts", "user"], "query": "howdy there", } }
def test_builder_default_params_multidict(): """Multiple params go into multiple "match" dicts.""" builder = query.Builder() params = multidict.MultiDict() params.add("user", "fred") params.add("user", "bob") q = builder.build(params) assert q["query"] == { "bool": { "must": [ {"match": {"user": "******"}}, {"match": {"user": "******"}} ] } }
def params(self): """Override params property of webob.request.BaseRequest. Added an 'encoded_params' attribute in case of PY2 to avoid encoding values in next subsequent calls to the params property. """ if six.PY2: encoded_params = getattr(self, 'encoded_params', None) if encoded_params is None: params = super(Request, self).params params_dict = multidict.MultiDict() for key, value in params.items(): params_dict.add(key, encodeutils.safe_encode(value)) setattr(self, 'encoded_params', multidict.NestedMultiDict(params_dict)) return self.encoded_params return super(Request, self).params
def test_build_with_keyword(): """Keywords are returned in the query dict in a "multi_match" clause.""" params = multidict.MultiDict() params.add("any", "howdy") q = query.build(request_params=params) assert q["query"]["filtered"]["query"] == { "bool": { "must": [{ "multi_match": { "fields": ["quote", "tags", "text", "uri.parts", "user"], "query": ["howdy"], "type": "cross_fields" } }] } }
def test_post(self): request = webapp2.Request.blank('/blobstore', method='POST', POST=multidict.MultiDict([ ('blob_key', 'a'), ('blob_key', 'b') ])) response = webapp2.Response() handler = blobstore_viewer.BlobstoreRequestHandler(request, response) self.mox.StubOutWithMock(blobstore, 'delete') blobstore.delete(['a', 'b']) self.mox.ReplayAll() handler.post() self.mox.VerifyAll() self.assertEqual(302, response.status_int) self.assertEqual('http://localhost/blobstore', response.headers.get('Location'))
def test_build_with_multiple_keywords(): """Multiple keywords at once are handled correctly.""" params = multidict.MultiDict() params.add("any", "howdy") params.add("any", "there") q = query.build(request_params=params) assert q["query"]["filtered"]["query"] == { "bool": { "must": [{ "multi_match": { "fields": ["quote", "tags", "text", "uri.parts", "user"], "query": ["howdy", "there"], "type": "cross_fields" } }] } }
def test_accepts_url_aliases(self, storage): request = mock.Mock() params = multidict.MultiDict() params.add("uri", "http://example.com") params.add("url", "http://example.net") storage.expand_uri.side_effect = [ ["http://giraffes.com/", "https://elephants.com/"], ["http://tigers.com/", "https://elephants.com/"], ] urifilter = query.UriFilter(request) result = urifilter(params) query_uris = result["terms"]["target.scope"] storage.expand_uri.assert_any_call(request.db, "http://example.com") storage.expand_uri.assert_any_call(request.db, "http://example.net") assert sorted(query_uris) == sorted(["httpx://giraffes.com", "httpx://elephants.com", "httpx://tigers.com"])
def test_build_query_with_multiple_text_params(): """Multiple "test" request params produce multiple "match" clauses.""" params = multidict.MultiDict() params.add("text", "foo") params.add("text", "bar") query = search.build_query(request_params=params) assert query["query"] == { "bool": { "must": [{ "match": { "text": "foo" } }, { "match": { "text": "bar" } }] } }
def test_build_with_multiple_quote_params(): """Multiple "quote" request params produce multiple "match" clauses.""" params = multidict.MultiDict() params.add("quote", "foo") params.add("quote", "bar") q = query.build(request_params=params) assert q["query"]["filtered"]["query"] == { "bool": { "must": [{ "match": { "quote": "foo" } }, { "match": { "quote": "bar" } }] } }
def test_build_for_multiple_users(): """Multiple "user" params go into multiple "match" dicts.""" params = multidict.MultiDict() params.add("user", "fred") params.add("user", "bob") q = query.build(request_params=params) assert q["query"]["filtered"]["query"] == { "bool": { "must": [{ "match": { "user": "******" } }, { "match": { "user": "******" } }] } }
def test_build_for_multiple_tags(): """Multiple "tags" params go into multiple "match" dicts.""" params = multidict.MultiDict() params.add("tags", "foo") params.add("tags", "bar") q = query.build(request_params=params) assert q["query"]["filtered"]["query"] == { "bool": { "must": [{ "match": { "tags": "foo" } }, { "match": { "tags": "bar" } }] } }
def setUp(self): self._list = [("a", text_("\xe9")), ("a", "e"), ("a", "f"), ("b", "1")] self.data = multidict.MultiDict(self._list) self.d = self._get_instance()
def setUp(self): self._list = [('a', text_('\xe9')), ('a', 'e'), ('a', 'f'), ('b', '1')] self.data = multidict.MultiDict(self._list) self.d = self._get_instance()
def _get_instance(self, **kwargs): if kwargs: data = multidict.MultiDict(kwargs) else: data = self.data.copy() return self.klass(data, {})