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)

    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_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 get_data(self, compact=True):
     data = MultiDict(self.raw_data) # XXX
     if compact:
         compact_data = MultiDict()
         for key, value in data.iteritems():
             if value:
                 compact_data.add(key, value)
         data = compact_data
     return data

        def _w(*args, **kwargs):
            page = int(kwargs.pop(own_parameters["page"], 1))
            real_items_per_page = int(kwargs.pop(own_parameters["items_per_page"], items_per_page))

            # Iterate over all of the named arguments expected by the function f
            # if any of those arguments have values present in the kwargs dict,
            # add the value to the positional args list, and remove it from the
            # kwargs dict
            argvars = inspect.getargspec(f)[0][1:]
            if argvars:
                args = list(args)
                for i, var in enumerate(args):
                    if i >= len(argvars):
                        break
                    var = argvars[i]
                    if var in kwargs:
                        if i + 1 >= len(args):
                            args.append(kwargs[var])
                        else:
                            args[i + 1] = kwargs[var]
                        del kwargs[var]

            res = f(*args, **kwargs)
            if isinstance(res, dict) and name in res:
                additional_parameters = MultiDict()
                for key, value in request.params.iteritems():
                    if key not in own_parameters:
                        additional_parameters.add(key, value)

                collection = res[name]

                # Use CustomPage if our extra custom arg was provided
                if items_first_page is not None:
                    page_class = CustomPage
                else:
                    page_class = Page

                page = page_class(
                    collection,
                    page,
                    items_per_page=real_items_per_page,
                    items_first_page=items_first_page,
                    **additional_parameters.dict_of_lists()
                )
                # wrap the pager so that it will render
                # the proper page-parameter
                page.pager = partial(page.pager, page_param=own_parameters["page"])
                res[name] = page
                # this is a bit strange - it appears
                # as if c returns an empty
                # string for everything it dosen't know.
                # I didn't find that documented, so I
                # just put this in here and hope it works.
                if not hasattr(tmpl_context, "paginators") or type(tmpl_context.paginators) == str:
                    tmpl_context.paginators = Bunch()
                tmpl_context.paginators[name] = page
            return res