Python multidict.MultiDict类代码示例

    def whitenoise_tween(request):
        whn = request.registry.whitenoise

        if whn.autorefresh:
            static_file = whn.find_file(request.path_info)
        else:
            static_file = whn.files.get(request.path_info)

        # We could not find a static file, so we'll just continue processing
        # this as normal.
        if static_file is None:
            return handler(request)

        request_headers = dict(kv for kv in request.environ.items() if kv[0].startswith("HTTP_"))

        if request.method not in {"GET", "HEAD"}:
            return HTTPMethodNotAllowed()
        else:
            path, headers = static_file.get_path_and_headers(request_headers)
            headers = MultiDict(headers)

            resp = FileResponse(
                path,
                request=request,
                content_type=headers.pop("Content-Type", None),
                content_encoding=headers.pop("Content-Encoding", None),
            )
            resp.md5_etag()
            resp.headers.update(headers)

            return resp

    def test_reset_fail(self):
        """
       Test the flow of the module if we complete the self assessment step and then reset
       Since the problem only allows one attempt, should fail.
       @return:
       """
        assessment = [0, 1]

        # Simulate a student saving an answer
        self._handle_ajax("save_answer", {"student_answer": self.answer})

        # Mock a student submitting an assessment
        assessment_dict = MultiDict({'assessment': sum(assessment)})
        assessment_dict.extend(('score_list[]', val) for val in assessment)

        self._handle_ajax("save_assessment", assessment_dict)
        task_one_json = json.loads(self._module().task_states[0])
        self.assertEqual(json.loads(task_one_json['child_history'][0]['post_assessment']), assessment)

        # Move to the next step in the problem
        self._handle_ajax("next_problem", {})
        self.assertEqual(self._module().current_task_number, 0)

        html = self._module().render('student_view').content
        self.assertIsInstance(html, basestring)

        # Module should now be done
        rubric = self._handle_ajax("get_combined_rubric", {})
        self.assertIsInstance(rubric, basestring)
        self.assertEqual(self._module().state, "done")

        # Try to reset, should fail because only 1 attempt is allowed
        reset_data = json.loads(self._handle_ajax("reset", {}))
        self.assertEqual(reset_data['success'], False)

 def test_multiple_values(self):
     formdata = MultiDict()
     formdata.add('items', '1')
     formdata.add('items', '2')
     form = self.Form(formdata)
     assert form.items.data == ['1', '2']
     assert form.validate()

 def test_jsonify_multidict(self):
     data = MultiDict()
     data.add('a', 1)
     data.add('a', 2)
     data.add('b', 3)
     json_data = jsonify.encode(data)
     self.assertEqual('{"a": [1, 2], "b": 3}', json_data)

class Utility(object):

    def __init__(self):
        self.accept_headers = MultiDict()
        self.deserializers = {}

    def add_deserializer(self, content_type, callable):
        self.deserializers[content_type] = callable
        self.accept_headers.add('Accept', content_type)

    def deserialize_request_body(self, request):
        content_type = request.content_type
        deserialized = None
        request.response.headers.extend(self.accept_headers)

        if content_type in self.deserializers:
            try:
                deserialized = self.deserializers[content_type](request)
            except HTTPException as http_exc:
                http_exc.headers.extend(self.accept_headers)
                raise
        else:
            raise HTTPUnsupportedMediaType(content_type,
                                           headers=self.accept_headers)

        return deserialized

 def test_parse_filter_params(self):
     query_params = MultiDict()
     query_params.add('type', 1)
     query_params.add('type', 2)
     query_params.add('test', 22)
     res = parse_filter_params(query_params, self.filterable)
     self.assertEqual({'type': [1, 2]}, res)

    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_a_list_field_can_have_a_single_value(self):
        schema = QueryParamSchema()
        params = MultiDict()
        params.add("list_field", "first")

        parsed = validate_query_params(schema, params)

        assert parsed.getall("list_field") == ["first"]

 def test_repeated_argument(self):
     params = MultiDict(verb='a')
     params.add('repeated', 'b')
     params.add('repeated', 'b')
     self.assertRaises(BadArgument,
                       views._check_params,
                       params,
                       ['repeated'])

def ignore_request_params_fields (request_params):
	result_data = MultiDict()

	for name, value in request_params.items():
		if value != "IGNORE-THIS-FIELD":
			result_data.add(name, value)

	return result_data

    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_it_does_not_include_unknown_fields(self):
        schema = QueryParamSchema()
        params = MultiDict()
        params.add("string_field", "include_me")
        params.add("unknown_field", "ignore_me")

        parsed = validate_query_params(schema, params)

        assert "unknown_field" not in parsed

    def test_it_keeps_only_last_value_for_non_sequence_fields(self):
        schema = QueryParamSchema()
        params = MultiDict()
        params.add("string_field", "first")
        params.add("string_field", "second")

        parsed = validate_query_params(schema, params)

        assert parsed.getall("string_field") == ["second"]

    def test_it_keeps_all_values_for_sequence_fields(self):
        schema = QueryParamSchema()
        params = MultiDict()
        params.add("list_field", "first")
        params.add("list_field", "second")

        parsed = validate_query_params(schema, params)

        assert parsed.getall("list_field") == ["first", "second"]

 def qs_add(self, *args, **kwargs):
     query = self.query.copy()
     if args:
         mdict = MultiDict(args[0])
         for k, v in mdict.items():
             query.add(k, v)
     for k, v in kwargs.items():
         query.add(k, v)
     return self._copy(query=query)