def test_with_classifiers(self, monkeypatch, db_request, metrics, page): params = MultiDict([("q", "foo bar"), ("c", "foo :: bar"), ("c", "fiz :: buz")]) if page is not None: params["page"] = page db_request.params = params es_query = pretend.stub() db_request.es = pretend.stub() get_es_query = pretend.call_recorder(lambda *a, **kw: es_query) monkeypatch.setattr(views, "get_es_query", get_es_query) classifier1 = ClassifierFactory.create(classifier="foo :: bar") classifier2 = ClassifierFactory.create(classifier="foo :: baz") classifier3 = ClassifierFactory.create(classifier="fiz :: buz") project = ProjectFactory.create() release1 = ReleaseFactory.create(project=project) release1.created = datetime.date(2011, 1, 1) release1._classifiers.append(classifier1) release1._classifiers.append(classifier2) page_obj = pretend.stub(page_count=(page or 1) + 10, item_count=1000) page_cls = pretend.call_recorder(lambda *a, **kw: page_obj) monkeypatch.setattr(views, "ElasticsearchPage", page_cls) url_maker = pretend.stub() url_maker_factory = pretend.call_recorder(lambda request: url_maker) monkeypatch.setattr(views, "paginate_url_factory", url_maker_factory) search_view = search(db_request) assert search_view == { "page": page_obj, "term": params.get("q", ""), "order": "", "applied_filters": params.getall("c"), "available_filters": [{ "foo": { classifier1.classifier.split(" :: ")[1]: {}, classifier2.classifier.split(" :: ")[1]: {}, } }], } assert ("fiz", [classifier3.classifier ]) not in search_view["available_filters"] assert page_cls.calls == [ pretend.call(es_query, url_maker=url_maker, page=page or 1) ] assert url_maker_factory.calls == [pretend.call(db_request)] assert get_es_query.calls == [ pretend.call(db_request.es, params.get("q"), "", params.getall("c")) ] assert metrics.histogram.calls == [ pretend.call("warehouse.views.search.results", 1000) ]
def test_with_a_query(self, monkeypatch, db_request, page): params = MultiDict({"q": "foo bar"}) if page is not None: params["page"] = page db_request.params = params sort = pretend.stub() suggest = pretend.stub( sort=pretend.call_recorder(lambda *a, **kw: sort), ) es_query = pretend.stub( suggest=pretend.call_recorder(lambda *a, **kw: suggest), ) db_request.es = pretend.stub( query=pretend.call_recorder(lambda *a, **kw: es_query)) page_obj = pretend.stub(page_count=(page or 1) + 10) page_cls = pretend.call_recorder(lambda *a, **kw: page_obj) monkeypatch.setattr(views, "ElasticsearchPage", page_cls) url_maker = pretend.stub() url_maker_factory = pretend.call_recorder(lambda request: url_maker) monkeypatch.setattr(views, "paginate_url_factory", url_maker_factory) assert search(db_request) == { "page": page_obj, "term": params.get("q", ''), "order": params.get("o", ''), "applied_filters": [], "available_filters": [], } assert page_cls.calls == [ pretend.call(suggest, url_maker=url_maker, page=page or 1), ] assert url_maker_factory.calls == [pretend.call(db_request)] assert db_request.es.query.calls == [ pretend.call( "multi_match", query="foo bar", fields=[ "author", "author_email", "description^5", "download_url", "home_page", "keywords^5", "license", "maintainer", "maintainer_email", "normalized_name^10", "platform", "summary^5", ], ), ] assert es_query.suggest.calls == [ pretend.call( name="name_suggestion", term={"field": "name"}, text="foo bar", ), ]
def test_without_a_query(self, monkeypatch, db_request, page): params = MultiDict() if page is not None: params["page"] = page db_request.params = params es_query = pretend.stub() db_request.es = pretend.stub(query=lambda *a, **kw: es_query) page_obj = pretend.stub(page_count=(page or 1) + 10) page_cls = pretend.call_recorder(lambda *a, **kw: page_obj) monkeypatch.setattr(views, "ElasticsearchPage", page_cls) url_maker = pretend.stub() url_maker_factory = pretend.call_recorder(lambda request: url_maker) monkeypatch.setattr(views, "paginate_url_factory", url_maker_factory) assert search(db_request) == { "page": page_obj, "term": params.get("q", ''), "order": params.get("o", ''), "applied_filters": [], "available_filters": [], } assert page_cls.calls == [ pretend.call(es_query, url_maker=url_maker, page=page or 1), ] assert url_maker_factory.calls == [pretend.call(db_request)]
def test_without_a_query(self, monkeypatch, db_request, page): params = MultiDict() if page is not None: params["page"] = page db_request.params = params es_query = pretend.stub() db_request.es = pretend.stub(query=lambda *a, **kw: es_query) page_obj = pretend.stub(page_count=(page or 1) + 10, item_count=1000) page_cls = pretend.call_recorder(lambda *a, **kw: page_obj) monkeypatch.setattr(views, "ElasticsearchPage", page_cls) url_maker = pretend.stub() url_maker_factory = pretend.call_recorder(lambda request: url_maker) monkeypatch.setattr(views, "paginate_url_factory", url_maker_factory) assert search(db_request) == { "page": page_obj, "term": params.get("q", ''), "order": params.get("o", ''), "applied_filters": [], "available_filters": [], } assert page_cls.calls == [ pretend.call(es_query, url_maker=url_maker, page=page or 1), ] assert url_maker_factory.calls == [pretend.call(db_request)]
def test_with_an_ordering(self, monkeypatch, db_request, page): params = MultiDict({"q": "foo bar", "o": "-created"}) if page is not None: params["page"] = page db_request.params = params sort = pretend.stub() suggest = pretend.stub( sort=pretend.call_recorder(lambda *a, **kw: sort), ) es_query = pretend.stub( suggest=pretend.call_recorder(lambda *a, **kw: suggest), ) db_request.es = pretend.stub( query=pretend.call_recorder(lambda *a, **kw: es_query) ) page_obj = pretend.stub(page_count=(page or 1) + 10) page_cls = pretend.call_recorder(lambda *a, **kw: page_obj) monkeypatch.setattr(views, "ElasticsearchPage", page_cls) url_maker = pretend.stub() url_maker_factory = pretend.call_recorder(lambda request: url_maker) monkeypatch.setattr(views, "paginate_url_factory", url_maker_factory) assert search(db_request) == { "page": page_obj, "term": params.get("q", ''), "order": params.get("o", ''), "applied_filters": [], "available_filters": [], } assert page_cls.calls == [ pretend.call(sort, url_maker=url_maker, page=page or 1), ] assert url_maker_factory.calls == [pretend.call(db_request)] assert db_request.es.query.calls == [ pretend.call( "multi_match", query="foo bar", fields=[ "name^2", "version", "author", "author_email", "maintainer", "maintainer_email", "home_page", "license", "summary", "description", "keywords", "platform", "download_url", ], ), ] assert es_query.suggest.calls == [ pretend.call( name="name_suggestion", term={"field": "name"}, text="foo bar", ), ] assert suggest.sort.calls == [ pretend.call("-created") ]
def test_with_an_ordering(self, monkeypatch, db_request, page, order, expected): params = MultiDict({"q": "foo bar"}) if page is not None: params["page"] = page if order is not None: params["o"] = order db_request.params = params sort = pretend.stub() suggest = pretend.stub( sort=pretend.call_recorder(lambda *a, **kw: sort), ) es_query = pretend.stub( suggest=pretend.call_recorder(lambda *a, **kw: suggest), ) db_request.es = pretend.stub( query=pretend.call_recorder(lambda *a, **kw: es_query) ) page_obj = pretend.stub(page_count=(page or 1) + 10) page_cls = pretend.call_recorder(lambda *a, **kw: page_obj) monkeypatch.setattr(views, "ElasticsearchPage", page_cls) url_maker = pretend.stub() url_maker_factory = pretend.call_recorder(lambda request: url_maker) monkeypatch.setattr(views, "paginate_url_factory", url_maker_factory) assert search(db_request) == { "page": page_obj, "term": params.get("q", ''), "order": params.get("o", ''), "applied_filters": [], "available_filters": [], } assert page_cls.calls == [ pretend.call( sort if order is not None else suggest, url_maker=url_maker, page=page or 1, ), ] assert url_maker_factory.calls == [pretend.call(db_request)] assert db_request.es.query.calls == [ pretend.call( "dis_max", queries=self._gather_es_queries(params["q"]) ) ] assert es_query.suggest.calls == [ pretend.call( "name_suggestion", params["q"], term={"field": "name"}, ), ] assert suggest.sort.calls == [pretend.call(i) for i in expected]
def test_with_a_single_char_query(self, monkeypatch, db_request, page): params = MultiDict({"q": "a"}) if page is not None: params["page"] = page db_request.params = params sort = pretend.stub() suggest = pretend.stub( sort=pretend.call_recorder(lambda *a, **kw: sort), ) es_query = pretend.stub( suggest=pretend.call_recorder(lambda *a, **kw: suggest), ) db_request.es = pretend.stub( query=pretend.call_recorder(lambda *a, **kw: es_query) ) page_obj = pretend.stub(page_count=(page or 1) + 10, item_count=1000) page_cls = pretend.call_recorder(lambda *a, **kw: page_obj) monkeypatch.setattr(views, "ElasticsearchPage", page_cls) url_maker = pretend.stub() url_maker_factory = pretend.call_recorder(lambda request: url_maker) monkeypatch.setattr(views, "paginate_url_factory", url_maker_factory) assert search(db_request) == { "page": page_obj, "term": params.get("q", ''), "order": params.get("o", ''), "applied_filters": [], "available_filters": [], } assert page_cls.calls == [ pretend.call(suggest, url_maker=url_maker, page=page or 1), ] assert url_maker_factory.calls == [pretend.call(db_request)] assert db_request.es.query.calls == [ pretend.call( views.gather_es_queries(params["q"]) ) ] assert es_query.suggest.calls == [ pretend.call( "name_suggestion", params["q"], term={"field": "name"}, ), ] assert db_request.registry.datadog.histogram.calls == [ pretend.call('warehouse.views.search.results', 1000) ]
class MulticaseParentAction (object): def __init__ (self, websocket, params): self.websocket = websocket self.params = MultiDict(params) def handle (self): return self.params def check_and_process (self): if self.websocket not in State.clients_sockets: response = error_response('Forbidden') response['request_id'] = self.params.get('request_id') return response response = self.handle() if 'request_id' in self.params: response['request_id'] = self.params['request_id'] return response # TODO: Move to the State? def call_client_action (self, character_id, action_name, params): data = json.dumps({'call_action': action_name, 'params': params}, cls = CustomJSONEncoder) websocket, _ = State.clients_by_character[character_id] # TODO: Validate if receiver is in the same session with sender websocket.send(data) def group_call_client_action (self, action_name, params, include_sender = False): data = json.dumps({'call_action': action_name, 'params': params}, cls = CustomJSONEncoder) character_id = State.clients_sockets[self.websocket] _, session_id = State.clients_by_character[character_id] for _, websocket in State.clients_by_session[session_id].viewitems(): if include_sender or (websocket is not self.websocket): websocket.send(data)
def test_with_a_single_char_query(self, monkeypatch, db_request, page): params = MultiDict({"q": "a"}) if page is not None: params["page"] = page db_request.params = params sort = pretend.stub() suggest = pretend.stub( sort=pretend.call_recorder(lambda *a, **kw: sort), ) es_query = pretend.stub( suggest=pretend.call_recorder(lambda *a, **kw: suggest), ) db_request.es = pretend.stub( query=pretend.call_recorder(lambda *a, **kw: es_query)) page_obj = pretend.stub(page_count=(page or 1) + 10, item_count=1000) page_cls = pretend.call_recorder(lambda *a, **kw: page_obj) monkeypatch.setattr(views, "ElasticsearchPage", page_cls) url_maker = pretend.stub() url_maker_factory = pretend.call_recorder(lambda request: url_maker) monkeypatch.setattr(views, "paginate_url_factory", url_maker_factory) assert search(db_request) == { "page": page_obj, "term": params.get("q", ''), "order": params.get("o", ''), "applied_filters": [], "available_filters": [], } assert page_cls.calls == [ pretend.call(suggest, url_maker=url_maker, page=page or 1), ] assert url_maker_factory.calls == [pretend.call(db_request)] assert db_request.es.query.calls == [ pretend.call("dis_max", queries=self._gather_es_queries(params["q"])) ] assert es_query.suggest.calls == [ pretend.call( "name_suggestion", params["q"], term={"field": "name"}, ), ] assert db_request.registry.datadog.histogram.calls == [ pretend.call('warehouse.views.search.results', 1000) ]
def test_does_not_remove_group_term_from_query_if_group_does_not_exist( self, pyramid_request, unparse): query = MultiDict({"group": "does_not_exist"}) check_url(pyramid_request, query, unparse=unparse) assert query.get("group") == "does_not_exist" assert not unparse.called
def test_does_not_remove_group_term_from_query_if_group_does_not_exist( self, pyramid_request, unparse): query = MultiDict({'group': 'does_not_exist'}) check_url(pyramid_request, query, unparse=unparse) assert query.get('group') == 'does_not_exist' assert not unparse.called
def test_with_exact_phrase_query(self, monkeypatch, db_request, metrics, page): params = MultiDict({"q": '"foo bar"'}) if page is not None: params["page"] = page db_request.params = params sort = pretend.stub() suggest = pretend.stub( sort=pretend.call_recorder(lambda *a, **kw: sort)) es_query = pretend.stub( suggest=pretend.call_recorder(lambda *a, **kw: suggest)) db_request.es = pretend.stub( query=pretend.call_recorder(lambda *a, **kw: es_query)) page_obj = pretend.stub(page_count=(page or 1) + 10, item_count=(page or 1) + 10) page_cls = pretend.call_recorder(lambda *a, **kw: page_obj) monkeypatch.setattr(views, "ElasticsearchPage", page_cls) url_maker = pretend.stub() url_maker_factory = pretend.call_recorder(lambda request: url_maker) monkeypatch.setattr(views, "paginate_url_factory", url_maker_factory) assert search(db_request) == { "page": page_obj, "term": params.get("q", ""), "order": params.get("o", ""), "applied_filters": [], "available_filters": [], } assert page_cls.calls == [ pretend.call(suggest, url_maker=url_maker, page=page or 1) ] assert url_maker_factory.calls == [pretend.call(db_request)] assert db_request.es.query.calls == [ pretend.call(views.gather_es_queries(params["q"])) ] assert es_query.suggest.calls == [ pretend.call("name_suggestion", params["q"], term={"field": "name"}) ] assert metrics.histogram.calls == [ pretend.call("warehouse.views.search.results", (page or 1) + 10) ]
def test_does_not_remove_group_term_from_query_if_group_does_not_exist( self, pyramid_request, unparse ): query = MultiDict({"group": "does_not_exist"}) check_url(pyramid_request, query, unparse=unparse) assert query.get("group") == "does_not_exist" assert not unparse.called
def test_does_not_remove_user_term_from_query_if_user_does_not_exist( self, pyramid_request, unparse, user_service): query = MultiDict({'user': '******'}) user_service.fetch.return_value = None check_url(pyramid_request, query, unparse=unparse) assert query.get('user') == 'jose' assert not unparse.called
def test_does_not_remove_group_term_from_query_if_group_does_not_exist(self, pyramid_request, unparse): query = MultiDict({'group': 'does_not_exist'}) check_url(pyramid_request, query, unparse=unparse) assert query.get('group') == 'does_not_exist' assert not unparse.called
def test_does_not_remove_user_term_from_query_if_user_does_not_exist( self, pyramid_request, unparse, user_service ): query = MultiDict({"user": "******"}) user_service.fetch.return_value = None check_url(pyramid_request, query, unparse=unparse) assert query.get("user") == "jose" assert not unparse.called
def collection_post(self): payload = MultiDict(self.request.json_body) # fetch user # TODO: assign currently logged-in user's id user = DBSession.query(User).filter_by(id=1).one() # fetch status status_name = 'DRAFTS' if payload.get('is_draft', False) else 'ONGOING' status = DBSession.query(ItemStatus).filter_by(name=status_name).one() qty = int(payload.get('quantity', 1)) price = payload['price'] if payload.get( 'price', None) and payload['price'] else None new_item = Item(user=user, name=payload['name'], type=payload['type'], trade_with=payload.get('trade_with', None), status=status, price=price, quantity=qty, description=payload['description'], reason=payload['reason']) # load assigned tags and extend new item's tags if payload.get('tags', None): tag_ids = [ tag['id'] for tag in payload['tags'] if tag.get('id', None) ] tags = DBSession.query(ItemTag).filter( ItemTag.id.in_(tag_ids)).all() new_item.tags.extend(tags) DBSession.add(new_item) DBSession.commit() return new_item.to_dict()
def test_with_a_query(self, monkeypatch, db_request, metrics, page): params = MultiDict({"q": "foo bar"}) if page is not None: params["page"] = page db_request.params = params db_request.es = pretend.stub() es_query = pretend.stub() get_es_query = pretend.call_recorder(lambda *a, **kw: es_query) monkeypatch.setattr(views, "get_es_query", get_es_query) page_obj = pretend.stub(page_count=(page or 1) + 10, item_count=1000) page_cls = pretend.call_recorder(lambda *a, **kw: page_obj) monkeypatch.setattr(views, "ElasticsearchPage", page_cls) url_maker = pretend.stub() url_maker_factory = pretend.call_recorder(lambda request: url_maker) monkeypatch.setattr(views, "paginate_url_factory", url_maker_factory) assert search(db_request) == { "page": page_obj, "term": params.get("q", ""), "order": "", "applied_filters": [], "available_filters": [], } assert get_es_query.calls == [ pretend.call(db_request.es, params.get("q"), "", []) ] assert page_cls.calls == [ pretend.call(es_query, url_maker=url_maker, page=page or 1) ] assert url_maker_factory.calls == [pretend.call(db_request)] assert metrics.histogram.calls == [ pretend.call("warehouse.views.search.results", 1000) ]
def application(env, start_response): res = None path = env['PATH_INFO'].lstrip('/') method = env['REQUEST_METHOD'] args = MultiDict(parse_qsl(env.get('QUERY_STRING', ''))) parts = path.split('/') volume = args.get('volume') if not volume: volumes = cluster.get_volumes(args['key']) for v in volumes: if v.node is current_node and v.id in current_node.volumes: volume = v.id break if volume: v = current_node.volumes[volume] collection = parts[0] if method == 'PUT': return put_file(env, start_response, v, collection, args['key']) elif method == 'GET': fname, meta = v.get(collection, args['key']) res = Response() res.charset = None res.headers['X-Sendfile'] = fname res.headers['X-Crc'] = str(meta['crc']) res.content_length = os.path.getsize(fname) if 'ct' in meta: res.content_type = meta['ct'] else: collection = parts[0] key = args['key'] v = volumes[0] res = HTTPTemporaryRedirect( location='http://{}/{}?key={}&volume={}'.format(v.node.id, collection, key, v.id)) for v in volumes: res.headers.add( 'X-Location', 'http://{}/{}?key={}&volume={}'.format(v.node.id, collection, key, v.id)) if not res: res = HTTPNotFound() return res(env, start_response)
class MimeHeaders(object): """Dictionary-like object that preserves the order and supports multiple values for the same key, knows whether it has been changed after the creation """ def __init__(self, items=()): self._v = MultiDict([(normalize(key), remove_newlines(val)) for (key, val) in items]) self.changed = False self.num_prepends = 0 def __getitem__(self, key): v = self._v.get(normalize(key), None) if v is not None: return encodedword.decode(v) return None def __len__(self): return len(self._v) def __iter__(self): return iter(self._v) def __contains__(self, key): return normalize(key) in self._v def __setitem__(self, key, value): key = normalize(key) if key in self._v: self._v[key] = remove_newlines(value) self.changed = True else: self.prepend(key, remove_newlines(value)) def __delitem__(self, key): del self._v[normalize(key)] self.changed = True def __nonzero__(self): return len(self._v) > 0 def prepend(self, key, value): self._v._items.insert(0, (normalize(key), remove_newlines(value))) self.num_prepends += 1 def add(self, key, value): """Adds header without changing the existing headers with same name""" self.prepend(key, value) def keys(self): """ Returns the keys. (message header names) It remembers the order in which they were added, what is really important """ return self._v.keys() def transform(self, fn, decode=False): """Accepts a function, getting a key, val and returning a new pair of key, val and applies the function to all header, value pairs in the message. """ changed = [False] def wrapper(key, val): new_key, new_val = fn(key, val) if new_val != val or new_key != key: changed[0] = True return new_key, new_val v = MultiDict(wrapper(k, v) for k, v in self.iteritems(raw=not decode)) if changed[0]: self._v = v self.changed = True def items(self): """ Returns header,val pairs in the preserved order. """ return list(self.iteritems()) def iteritems(self, raw=False): """ Returns iterator header,val pairs in the preserved order. """ if raw: return self._v.iteritems() return iter([(x[0], encodedword.decode(x[1])) for x in self._v.iteritems()]) def get(self, key, default=None): """ Returns header value (case-insensitive). """ v = self._v.get(normalize(key), default) if v is not None: return encodedword.decode(v) return None def getraw(self, key, default=None): """ Returns raw header value (case-insensitive, non-decoded. """ return self._v.get(normalize(key), default) def getall(self, key): """ Returns all header values by the given header name (case-insensitive). """ v = self._v.getall(normalize(key)) return [encodedword.decode(x) for x in v] def have_changed(self, ignore_prepends=False): """ Tells whether someone has altered the headers after creation. """ return self.changed or (self.num_prepends > 0 and not ignore_prepends) def __str__(self): return str(self._v) @classmethod def from_stream(cls, stream): """ Takes a stream and reads the headers, decodes headers to unicode dict like object. """ return cls(parse_stream(stream)) def to_stream(self, stream, prepends_only=False): """ Takes a stream and serializes headers in a mime format. """ i = 0 for h, v in self.iteritems(raw=True): if prepends_only and i == self.num_prepends: break i += 1 try: h.encode('ascii') except UnicodeDecodeError: raise EncodingError("Non-ascii header name") stream.write("{0}: {1}\r\n".format(h, to_mime(h, v)))
def GET(self, req): """ Handles listing of in-progress multipart uploads, handles list objects request. """ # any operations with multipart buckets are not allowed to user check_container_name_no_such_bucket_error(self.container_name) if 'uploads' in req.GET: return self.get_uploads(req) else: acl = req.GET.get('acl') params = MultiDict([('format', 'json')]) max_keys = req.GET.get('max-keys') if (max_keys is not None and max_keys.isdigit()): max_keys = min(int(max_keys), MAX_BUCKET_LISTING) else: max_keys = MAX_BUCKET_LISTING params['limit'] = str(max_keys + 1) for param_name in ('marker', 'prefix', 'delimiter'): if param_name in req.GET: params[param_name] = req.GET[param_name] req.GET.clear() req.GET.update(params) resp = req.get_response(self.app) status = resp.status_int body = resp.body if status != 200: if status == 401: return get_err_response('AccessDenied') elif status == 404: return get_err_response('InvalidBucketName') else: return get_err_response('InvalidURI') if acl is not None: return get_acl(self.account_name) objects = json.loads(resp.body) body = ('<?xml version="1.0" encoding="UTF-8"?>' '<ListBucketResult ' 'xmlns="http://s3.amazonaws.com/doc/2006-03-01/">' '<Prefix>%s</Prefix>' '<Marker>%s</Marker>' '<Delimiter>%s</Delimiter>' '<IsTruncated>%s</IsTruncated>' '<MaxKeys>%s</MaxKeys>' '<Name>%s</Name>' '%s' '%s' '</ListBucketResult>' % ( xml_escape(params.get('prefix', '')), xml_escape(params.get('marker', '')), xml_escape(params.get('delimiter', '')), 'true' if len(objects) == (max_keys + 1) else 'false', max_keys, xml_escape(self.container_name), "".join(['<Contents><Key>%s</Key><LastModified>%sZ</Last'\ 'Modified><ETag>%s</ETag><Size>%s</Size><Storage'\ 'Class>STANDARD</StorageClass></Contents>' % (xml_escape(i['name']), i['last_modified'][:-3], i['hash'], i['bytes']) for i in objects[:max_keys] if 'subdir' not in i]), "".join(['<CommonPrefixes><Prefix>%s</Prefix></Common'\ 'Prefixes>' % xml_escape(i['subdir']) for i in objects[:max_keys] if 'subdir' in i]))) return Response(body=body, content_type='application/xml')
class MimeHeaders(object): """Dictionary-like object that preserves the order and supports multiple values for the same key, knows whether it has been changed after the creation """ def __init__(self, items=()): self.v = MultiDict( [(normalize(key), val) for (key, val) in items]) self.changed = False def __getitem__(self, key): return self.v.get(normalize(key), None) def __len__(self): return len(self.v) def __iter__(self): return iter(self.v) def __contains__(self, key): return normalize(key) in self.v def __setitem__(self, key, value): self.v[normalize(key)] = _remove_newlines(value) self.changed = True def __delitem__(self, key): del self.v[normalize(key)] self.changed = True def __nonzero__(self): return len(self.v) > 0 def prepend(self, key, val): self.v._items.insert(0, (key, _remove_newlines(val))) self.changed = True def add(self, key, value): """Adds header without changing the existing headers with same name""" self.v.add(normalize(key), _remove_newlines(value)) self.changed = True def keys(self): """ Returns the keys. (message header names) It remembers the order in which they were added, what is really important """ return self.v.keys() def transform(self, fn): """Accepts a function, getting a key, val and returning a new pair of key, val and applies the function to all header, value pairs in the message. """ changed = [False] def tracking_fn(key, val): new_key, new_val = fn(key, val) if new_val != val or new_key != key: changed[0] = True return new_key, new_val v = MultiDict(tracking_fn(key, val) for key, val in self.v.iteritems()) if changed[0]: self.v = v self.changed = True def items(self): """ Returns header,val pairs in the preserved order. """ return list(self.iteritems()) def iteritems(self): """ Returns iterator header,val pairs in the preserved order. """ return self.v.iteritems() def get(self, key, default=None): """ Returns header value (case-insensitive). """ return self.v.get(normalize(key), default) def getall(self, key): """ Returns all header values by the given header name (case-insensitive) """ return self.v.getall(normalize(key)) def have_changed(self): """Tells whether someone has altered the headers after creation""" return self.changed def __str__(self): return str(self.v) @classmethod def from_stream(cls, stream): """Takes a stream and reads the headers, decodes headers to unicode dict like object""" return cls(parse_stream(stream)) def to_stream(self, stream): """Takes a stream and serializes headers in a mime format""" for h, v in self.v.iteritems(): try: h = h.encode('ascii') except UnicodeDecodeError: raise EncodingError("Non-ascii header name") stream.write("{0}: {1}\r\n".format(h, to_mime(h, v)))
def test_with_classifiers(self, monkeypatch, db_request, page): params = MultiDict([ ("q", "foo bar"), ("c", "foo :: bar"), ("c", "fiz :: buz"), ]) if page is not None: params["page"] = page db_request.params = params es_query = pretend.stub( suggest=pretend.call_recorder(lambda *a, **kw: es_query), filter=pretend.call_recorder(lambda *a, **kw: es_query), sort=pretend.call_recorder(lambda *a, **kw: es_query), ) db_request.es = pretend.stub( query=pretend.call_recorder(lambda *a, **kw: es_query)) classifier1 = ClassifierFactory.create(classifier="foo :: bar") classifier2 = ClassifierFactory.create(classifier="foo :: baz") classifier3 = ClassifierFactory.create(classifier="fiz :: buz") project = ProjectFactory.create() release1 = ReleaseFactory.create(project=project) release1.created = datetime.date(2011, 1, 1) release1._classifiers.append(classifier1) release1._classifiers.append(classifier2) page_obj = pretend.stub(page_count=(page or 1) + 10, item_count=1000) page_cls = pretend.call_recorder(lambda *a, **kw: page_obj) monkeypatch.setattr(views, "ElasticsearchPage", page_cls) url_maker = pretend.stub() url_maker_factory = pretend.call_recorder(lambda request: url_maker) monkeypatch.setattr(views, "paginate_url_factory", url_maker_factory) search_view = search(db_request) assert search_view == { "page": page_obj, "term": params.get("q", ''), "order": params.get("o", ''), "applied_filters": params.getall("c"), "available_filters": [('foo', [ classifier1.classifier, classifier2.classifier, ])], } assert (("fiz", [classifier3.classifier]) not in search_view["available_filters"]) assert page_cls.calls == [ pretend.call(es_query, url_maker=url_maker, page=page or 1), ] assert url_maker_factory.calls == [pretend.call(db_request)] assert db_request.es.query.calls == [ pretend.call(views.gather_es_queries(params["q"])) ] assert es_query.suggest.calls == [ pretend.call( "name_suggestion", params["q"], term={"field": "name"}, ), ] assert es_query.filter.calls == [ pretend.call('terms', classifiers=['foo :: bar']), pretend.call('terms', classifiers=['fiz :: buz']) ]
def test_with_classifiers(self, monkeypatch, db_request, page): params = MultiDict([ ("q", "foo bar"), ("c", "foo :: bar"), ("c", "fiz :: buz"), ]) if page is not None: params["page"] = page db_request.params = params es_query = pretend.stub( suggest=pretend.call_recorder(lambda *a, **kw: es_query), filter=pretend.call_recorder(lambda *a, **kw: es_query), sort=pretend.call_recorder(lambda *a, **kw: es_query), ) db_request.es = pretend.stub( query=pretend.call_recorder(lambda *a, **kw: es_query) ) classifier1 = ClassifierFactory.create(classifier="foo :: bar") classifier2 = ClassifierFactory.create(classifier="foo :: baz") classifier3 = ClassifierFactory.create(classifier="fiz :: buz") project = ProjectFactory.create() release1 = ReleaseFactory.create(project=project) release1.created = datetime.date(2011, 1, 1) release1._classifiers.append(classifier1) release1._classifiers.append(classifier2) page_obj = pretend.stub(page_count=(page or 1) + 10) page_cls = pretend.call_recorder(lambda *a, **kw: page_obj) monkeypatch.setattr(views, "ElasticsearchPage", page_cls) url_maker = pretend.stub() url_maker_factory = pretend.call_recorder(lambda request: url_maker) monkeypatch.setattr(views, "paginate_url_factory", url_maker_factory) search_view = search(db_request) assert search_view == { "page": page_obj, "term": params.get("q", ''), "order": params.get("o", ''), "applied_filters": params.getall("c"), "available_filters": [ ('foo', [ classifier1.classifier, classifier2.classifier, ]) ], } assert ( ("fiz", [ classifier3.classifier ]) not in search_view["available_filters"] ) assert page_cls.calls == [ pretend.call(es_query, url_maker=url_maker, page=page or 1), ] assert url_maker_factory.calls == [pretend.call(db_request)] assert db_request.es.query.calls == [ pretend.call( "dis_max", queries=self._gather_es_queries(params["q"]) ) ] assert es_query.suggest.calls == [ pretend.call( "name_suggestion", params["q"], term={"field": "name"}, ), ] assert es_query.filter.calls == [ pretend.call('terms', classifiers=['foo :: bar', 'fiz :: buz']) ]
def identify(self, environ: Any): u''' Override the parent's identifier to introduce a login counter (possibly along with a post-login page) and load the login counter into the ``environ``. ''' request = Request(environ, charset=self.charset) path_info = environ[u'PATH_INFO'] script_name = environ.get(u'SCRIPT_NAME') or u'/' query = request.GET if path_info == self.login_handler_path: # We are on the URL where repoze.who processes authentication. # # Let's append the login counter to the query string of the # 'came_from' URL. It will be used by the challenge below if # authorization is denied for this request. form = dict(request.POST) form.update(query) try: login = form[u'login'] password = form[u'password'] except KeyError: credentials = None else: if request.charset == u'us-ascii': credentials = { u'login': str(login), u'password': str(password), } else: credentials = {u'login': login, u'password': password} try: credentials[u'max_age'] = form[u'remember'] # type: ignore except KeyError: pass referer = environ.get(u'HTTP_REFERER', script_name) destination = cast(str, form.get(u'came_from', referer)) if self.post_login_url: # There's a post-login page, so we have to replace the # destination with it. destination = self._get_full_path(self.post_login_url, environ) if u'came_from' in query: # There's a referrer URL defined, so we have to pass it to # the post-login page as a GET variable. destination = self._insert_qs_variable(destination, u'came_from', query[u'came_from']) failed_logins = self._get_logins(environ, True) new_dest = self._set_logins_in_url(destination, failed_logins) environ[u'repoze.who.application'] = HTTPFound(location=new_dest) return credentials elif path_info == self.logout_handler_path: # We are on the URL where repoze.who logs the user out. # r = Request(environ) params = dict(list(r.GET.items()) + list(r.POST.items())) form = MultiDict(params) form.update(query) referer = environ.get(u'HTTP_REFERER', script_name) came_from = form.get(u'came_from', referer) # set in environ for self.challenge() to find later environ[u'came_from'] = came_from environ[u'repoze.who.application'] = HTTPUnauthorized() return None elif path_info == self.login_form_url or self._get_logins(environ): # We are on the URL that displays the from OR any other page # # where the login counter is included in the query string. # # So let's load the counter into the environ and then hide it from # the query string (it will cause problems in frameworks like TG2, # where this unexpected variable would be passed to the controller) environ[u'repoze.who.logins'] = self._get_logins(environ, True) # Hiding the GET variable in the environ: if self.login_counter_name in query: del query[self.login_counter_name] environ[u'QUERY_STRING'] = urlencode(query, doseq=True)
def put(self): item_id = int(self.request.matchdict['item_id']) payload = MultiDict(self.request.json_body) item = DBSession.query(Item).filter_by(id=item_id).one() transaction_date = None print payload # fetch status if payload.get('is_draft', False): status_name = 'DRAFTS' elif payload.get('status', None) and payload['status'] == 'archived': status_name = 'ARCHIVED' transaction_date = datetime.now() else: status_name = 'ONGOING' status = DBSession.query(ItemStatus).filter_by(name=status_name).one() # fetch new tags new_tags = [] ids_to_add = [ int(tag['id']) for tag in payload.get('tags', []) if tag.get('id', None) ] if ids_to_add: new_tags.extend( DBSession.query(ItemTag).filter( ItemTag.id.in_(ids_to_add)).all()) item.tags = new_tags # replace existing tags new_qty = int(payload.get('quantity', 1)) price = payload['price'] if payload['price'] else None item.name = payload['name'] item.type = payload['type'] item.trade_with = payload.get('trade_with', None) item.status = status item.price = price item.description = payload['description'] item.reason = payload.get('reason', None) item.transaction_date = transaction_date # adjust original quantity if new_qty > item.quantity: additional_quantity = new_qty - item.quantity item.original_quantity += additional_quantity elif new_qty < item.quantity: additional_quantity = item.quantity - new_qty item.original_quantity -= additional_quantity item.quantity = new_qty updating_fields = ('updating item: %s', 'name: %s', 'type: %s', 'status: %s', 'price: %s', 'quantity: %s', 'description: %s', 'reason: %s', 'tags: %s', 'transaction date: %s\n') logger.info('\n'.join(updating_fields) % (item_id, item.name, item.type, item.status, item.price, item.quantity, item.description, item.reason, item.tags, item.transaction_date)) DBSession.commit() return item.to_dict()
def get_uploads(self, req): """Handles listing of in-progress multipart uploads""" acl = req.GET.get('acl') params = MultiDict([('format', 'json')]) max_uploads = req.GET.get('max-uploads') if (max_uploads is not None and max_uploads.isdigit()): max_uploads = min(int(max_uploads), MAX_UPLOADS_LISTING) else: max_uploads = MAX_UPLOADS_LISTING params['limit'] = str(max_uploads + 1) for param_name in ('key-marker', 'prefix', 'delimiter', 'upload-id-marker'): if param_name in req.GET: params[param_name] = req.GET[param_name] cont_name = MULTIPART_UPLOAD_PREFIX + self.container_name cont_path = "/v1/%s/%s/" % (self.account_name, cont_name) req.upath_info = cont_path req.GET.clear() req.GET.update(params) resp = req.get_response(self.app) status = resp.status_int if status != 200: if status == 401: return get_err_response('AccessDenied') elif status == 404: return get_err_response('InvalidBucketName') else: return get_err_response('InvalidURI') if acl is not None: return get_acl(self.account_name) objects = json.loads(resp.body) uploads = '' splited_name = '' for obj in objects: if obj['name'].endswith('/meta'): splited_name = obj['name'].split('/') uploads = uploads.join( "<Upload>" "<Key>%s</Key>" "<UploadId>%s</UploadId>" "<Initiator>" "<ID>%s</ID>" "<DisplayName>%s</DisplayName>" "</Initiator>" "<Owner>" "<ID>%s</ID>" "<DisplayName>%s</DisplayName>" "</Owner>" "<StorageClass>STANDARD</StorageClass>" "<Initiated>%sZ</Initiated>" "</Upload>" % ( splited_name[0], splited_name[1], self.account_name, self.account_name, self.account_name, self.account_name, obj['last_modified'][:-3])) else: objects.remove(obj) #TODO: Currently there are less then max_uploads results # in a response; Amount of uploads == amount of meta files # received in a request for a list of objects in a bucket. if len(objects) == (max_uploads + 1): is_truncated = 'true' next_key_marker = splited_name[0] next_uploadId_marker = splited_name[1] else: is_truncated = 'false' next_key_marker = next_uploadId_marker = '' body = ('<?xml version="1.0" encoding="UTF-8"?>' '<ListMultipartUploadsResult ' 'xmlns="http://s3.amazonaws.com/doc/2006-03-01/">' '<Bucket>%s</Bucket>' '<KeyMarker>%s</KeyMarker>' '<UploadIdMarker>%s</UploadIdMarker>' '<NextKeyMarker>%s</NextKeyMarker>' '<NextUploadIdMarker>%s</NextUploadIdMarker>' '<MaxUploads>%s</MaxUploads>' '<IsTruncated>%s</IsTruncated>' '%s' '</ListMultipartUploadsResult>' % ( xml_escape(self.container_name), xml_escape(params.get('key-marker', '')), xml_escape(params.get('upload-id-marker', '')), next_key_marker, next_uploadId_marker, max_uploads, is_truncated, uploads ) ) return Response(body=body, content_type='application/xml')
def test_with_classifiers(self, monkeypatch, db_request, page): params = MultiDict([ ("q", "foo bar"), ("c", "foo :: bar"), ("c", "fiz :: buz"), ]) if page is not None: params["page"] = page db_request.params = params es_query = pretend.stub( suggest=pretend.call_recorder(lambda *a, **kw: es_query), filter=pretend.call_recorder(lambda *a, **kw: es_query), sort=pretend.call_recorder(lambda *a, **kw: es_query), ) db_request.es = pretend.stub( query=pretend.call_recorder(lambda *a, **kw: es_query)) classifier1 = ClassifierFactory.create(classifier="foo :: bar") classifier2 = ClassifierFactory.create(classifier="foo :: baz") classifier3 = ClassifierFactory.create(classifier="fiz :: buz") page_obj = pretend.stub(page_count=(page or 1) + 10) page_cls = pretend.call_recorder(lambda *a, **kw: page_obj) monkeypatch.setattr(views, "ElasticsearchPage", page_cls) url_maker = pretend.stub() url_maker_factory = pretend.call_recorder(lambda request: url_maker) monkeypatch.setattr(views, "paginate_url_factory", url_maker_factory) assert search(db_request) == { "page": page_obj, "term": params.get("q", ''), "order": params.get("o", ''), "applied_filters": params.getall("c"), "available_filters": [('fiz', [classifier3.classifier]), ('foo', [ classifier1.classifier, classifier2.classifier, ])], } assert page_cls.calls == [ pretend.call(es_query, url_maker=url_maker, page=page or 1), ] assert url_maker_factory.calls == [pretend.call(db_request)] assert db_request.es.query.calls == [ pretend.call( "multi_match", query="foo bar", fields=[ "author", "author_email", "description^5", "download_url", "home_page", "keywords^5", "license", "maintainer", "maintainer_email", "normalized_name^10", "platform", "summary^5", ], ), ] assert es_query.suggest.calls == [ pretend.call( name="name_suggestion", term={"field": "name"}, text="foo bar", ), ] assert es_query.filter.calls == [ pretend.call('terms', classifiers=['foo :: bar', 'fiz :: buz']) ]
def view_one_click_buy(self): good_id = self.request.matchdict.get('id') good = Good.by_id(good_id) # TODO test good exists ! if good is None: return HTTPNotFound('Товар не найден') if not good.active: return HTTPForbidden('Товар сня') appstruct = dict() user_logined = self.user is not None email = None if user_logined: email = self.user.email appstruct['email'] = email # TODO + поле name one_click_buy_schema = OneClickBuySchema() submit_button_name = 'form_good_one_click_buy_submit' payment_system_default = helpers.get_setting('payment_system_default') payment_systems_captions = get_payment_clients_captions() if payment_system_default is None: raise Exception('payment_system_default in config was not set!') else: payment_system_default_caption = payment_systems_captions.get( payment_system_default) if payment_system_default_caption is None: raise Exception('default_payment_system is not loaded!') appstruct['payment_system'] = payment_system_default one_click_buy_form = FormMod( one_click_buy_schema.bind( user_logined=user_logined, # TODO logout return url param logout_url=self.request.route_url('logout'), payment_systems=payment_systems_captions), buttons=[Button(name=submit_button_name, title='Приобрести')], # css_class='no-red-stars' ) rendered_redirect_form = None if submit_button_name in self.request.params: post = MultiDict() post._items = list(self.request.POST.items()) if user_logined: helpers.multidict_rm_values(post, 'email') if email is not None: post.add('email', email) if post.get('payment_system') is None: post.add('payment_system', payment_system_default) payment_system = post.get('payment_system') controls = post.items() # TODO add email to controls if email is not None try: one_click_buy_form.validate(post.items()) except deform.ValidationFailure as e: return dict( good=good, rendered_one_click_buy_form=e.render(), ) # captch check! # self.request.params() user = self.user if email is None: email = self.request.params.get('email') if email is None or email == '': return HTTPBadRequest('No email specified') if user is None: user = User.by_email(email) if user is None: # TODO register to separate function user = User() user.email = email password = User.generate_password() user.set_password(password) error = db_save_model(user) if error is not None: return self.db_error_response(error) helpers.send_html_mail(user.email, 'registered', { 'user_name': user.name, 'password': password }) # TODO read http://docs.sqlalchemy.org/en/latest/orm/cascades.html#merge try: with transaction.manager: new_order = Order(user_id=user.id) DBSession.add(new_order) new_order.alter_wanted_good_count(good.id, delta_count=1.0) except DBAPIError as error: return self.db_error_response(error) amount_to_pay = new_order.get_amount_to_pay() try: with transaction.manager: DBSession.add(new_order) # TODO generalize and move transaction make code somewhere new_money_transaction = MoneyTransaction( order_id=new_order.id, user_id=user.id, payment_system=payment_system, shop_money_delta=amount_to_pay, type=EnumMoneyTransactionType.buy) DBSession.add(new_money_transaction) DBSession.flush() # money_transaction.init() payment_client = payment_systems.get_payment_client_by_name( payment_system) if payment_client is None: return HTTPInternalServerError('Error on payment init') # working type definition! """:type payment_client AbstractPaymentClient""" status_redirect_form = payment_client.run_transaction( new_money_transaction) """:type status_redirect_form MoneyTransactionStatus""" if status_redirect_form is None: raise Exception('payment form not generated') if type(status_redirect_form ) is not MoneyTransactionStatus: raise Exception( 'status_redirect_form is not MoneyTransactionStatus class' ) if status_redirect_form.status != EnumMoneyTransactionStatus.redirect_to_payment_form: raise Exception( 'status_redirect_form.status is not payment form') rendered_redirect_form = status_redirect_form.render_post_form( ) except DBAPIError as error: return self.db_error_response(error) # redirect to payment # TODO payment system choose # try: # with transaction.manager: # new_order.payment_start() # except DBAPIError as error: # return self.db_error_response(error) # TODO backlink param # or write backlink to the order class? return dict( good=good, rendered_one_click_buy_form=one_click_buy_form.render(appstruct), rendered_redirect_form=rendered_redirect_form)
def test_with_classifiers(self, monkeypatch, db_request, metrics, page): params = MultiDict([("q", "foo bar"), ("c", "foo :: bar"), ("c", "fiz :: buz")]) if page is not None: params["page"] = page db_request.params = params es_query = pretend.stub( suggest=pretend.call_recorder(lambda *a, **kw: es_query), filter=pretend.call_recorder(lambda *a, **kw: es_query), query=pretend.call_recorder(lambda *a, **kw: es_query), sort=pretend.call_recorder(lambda *a, **kw: es_query), ) db_request.es = pretend.stub( query=pretend.call_recorder(lambda *a, **kw: es_query) ) classifier1 = ClassifierFactory.create(classifier="foo :: bar") classifier2 = ClassifierFactory.create(classifier="foo :: baz") classifier3 = ClassifierFactory.create(classifier="fiz :: buz") project = ProjectFactory.create() release1 = ReleaseFactory.create(project=project) release1.created = datetime.date(2011, 1, 1) release1._classifiers.append(classifier1) release1._classifiers.append(classifier2) page_obj = pretend.stub(page_count=(page or 1) + 10, item_count=1000) page_cls = pretend.call_recorder(lambda *a, **kw: page_obj) monkeypatch.setattr(views, "ElasticsearchPage", page_cls) url_maker = pretend.stub() url_maker_factory = pretend.call_recorder(lambda request: url_maker) monkeypatch.setattr(views, "paginate_url_factory", url_maker_factory) search_view = search(db_request) assert search_view == { "page": page_obj, "term": params.get("q", ""), "order": params.get("o", ""), "applied_filters": params.getall("c"), "available_filters": [ { "foo": { classifier1.classifier.split(" :: ")[1]: {}, classifier2.classifier.split(" :: ")[1]: {}, } } ], } assert ("fiz", [classifier3.classifier]) not in search_view["available_filters"] assert page_cls.calls == [ pretend.call(es_query, url_maker=url_maker, page=page or 1) ] assert url_maker_factory.calls == [pretend.call(db_request)] assert db_request.es.query.calls == [ pretend.call(views.gather_es_queries(params["q"])) ] assert es_query.suggest.calls == [ pretend.call("name_suggestion", params["q"], term={"field": "name"}) ] assert es_query.query.calls == [ pretend.call("prefix", classifiers="foo :: bar"), pretend.call("prefix", classifiers="fiz :: buz"), ] assert metrics.histogram.calls == [ pretend.call("warehouse.views.search.results", 1000) ]
from wsgiref.util import setup_testing_defaults from wsgiref.simple_server import make_server, demo_app from urllib.parse import parse_qs from webob import Request, Response from webob.multidict import MultiDict md = MultiDict() md.add('a', 1) md.add('b', 2) md.add('b', 3) md.add(1, 100) md.add(1, 200) md.add(2, 200) #print(md) print(md[1]) print(md.get('b')) print(md.getall('b'))
def test_with_classifiers(self, monkeypatch, db_request, page): params = MultiDict([ ("q", "foo bar"), ("c", "foo :: bar"), ("c", "fiz :: buz"), ]) if page is not None: params["page"] = page db_request.params = params es_query = pretend.stub( suggest=pretend.call_recorder(lambda *a, **kw: es_query), filter=pretend.call_recorder(lambda *a, **kw: es_query), sort=pretend.call_recorder(lambda *a, **kw: es_query), ) db_request.es = pretend.stub( query=pretend.call_recorder(lambda *a, **kw: es_query) ) classifier1 = ClassifierFactory.create(classifier="foo :: bar") classifier2 = ClassifierFactory.create(classifier="foo :: baz") classifier3 = ClassifierFactory.create(classifier="fiz :: buz") page_obj = pretend.stub(page_count=(page or 1) + 10) page_cls = pretend.call_recorder(lambda *a, **kw: page_obj) monkeypatch.setattr(views, "ElasticsearchPage", page_cls) url_maker = pretend.stub() url_maker_factory = pretend.call_recorder(lambda request: url_maker) monkeypatch.setattr(views, "paginate_url_factory", url_maker_factory) assert search(db_request) == { "page": page_obj, "term": params.get("q", ''), "order": params.get("o", ''), "applied_filters": params.getall("c"), "available_filters": [ ('fiz', [classifier3.classifier]), ('foo', [ classifier1.classifier, classifier2.classifier, ]) ], } assert page_cls.calls == [ pretend.call(es_query, url_maker=url_maker, page=page or 1), ] assert url_maker_factory.calls == [pretend.call(db_request)] assert db_request.es.query.calls == [ pretend.call( "multi_match", query="foo bar", fields=[ "name^2", "version", "author", "author_email", "maintainer", "maintainer_email", "home_page", "license", "summary", "description", "keywords", "platform", "download_url", ], ), ] assert es_query.suggest.calls == [ pretend.call( name="name_suggestion", term={"field": "name"}, text="foo bar", ), ] assert es_query.filter.calls == [ pretend.call('terms', classifiers=['foo :: bar', 'fiz :: buz']) ]