def test_has_params_true(self):
        raw = mocked_request(url_params=[("foo", "1"), ("bar", "2"), ("foo", "3")])
        request = RestRequest(raw)
        self.assertEqual(True, request.has_params)

        raw = mocked_request(query_params=[("one", "1"), ("two", "2"), ("one", "3")])
        request = RestRequest(raw)
        self.assertEqual(True, request.has_params)

        raw = mocked_request(
            url_params=[("foo", "1"), ("bar", "2"), ("foo", "3")],
            query_params=[("one", "1"), ("two", "2"), ("one", "3")],
        )
        request = RestRequest(raw)
        self.assertEqual(True, request.has_params)
 def test_raw_request(self):
     raw = mocked_request()
     request = RestRequest(raw)
     with warnings.catch_warnings():
         warnings.simplefilter("ignore", DeprecationWarning)
         # noinspection PyDeprecation
         self.assertEqual(request.raw, request.raw_request)
    async def test_url_params(self):
        expected = {"bar": "2", "foo": ["1", "3"]}

        raw = mocked_request(url_params=[("foo", "1"), ("bar", "2"), ("foo", "3")])
        request = RestRequest(raw)
        observed = await request.url_params()

        self.assertEqual(expected, observed)
    async def test_query_params(self):
        expected = {"one": ["1", "3"], "two": "2"}

        raw = mocked_request(query_params=[("one", "1"), ("two", "2"), ("one", "3")])
        request = RestRequest(raw)
        observed = await request.query_params()

        self.assertEqual(expected, observed)
    async def test_query_params_with_type(self):
        # noinspection PyPep8Naming
        Params = ModelType.build("Params", {"one": list[int], "two": int})
        expected = Params(one=[1, 3], two=2)

        raw = mocked_request(query_params=[("one", "1"), ("two", "2"), ("one", "3")])
        request = RestRequest(raw)
        observed = await request.query_params(type_=Params)

        self.assertEqual(expected, observed)
    async def test_url_params_with_type(self):
        # noinspection PyPep8Naming
        Params = ModelType.build("Params", {"foo": list[int], "bar": int})
        expected = Params(foo=[1, 3], bar=2)

        raw = mocked_request(url_params=[("foo", "1"), ("bar", "2"), ("foo", "3")])
        request = RestRequest(raw)
        observed = await request.url_params(type_=Params)

        self.assertEqual(expected, observed)
 def test_user(self):
     uuid = uuid4()
     raw = mocked_request(user=uuid)
     request = RestRequest(raw)
     user = request.user
     self.assertEqual(uuid, user)
 def test_headers(self):
     raw = mocked_request(headers={"something": "123"})
     request = RestRequest(raw)
     self.assertEqual({"something": "123"}, request.headers)
 def test_eq_false(self):
     self.assertNotEqual(RestRequest(mocked_request()), RestRequest(mocked_request()))
 def test_eq_true(self):
     request = mocked_request()
     self.assertEqual(RestRequest(request), RestRequest(request))
 def test_repr(self):
     raw = mocked_request()
     request = RestRequest(raw)
     self.assertEqual(f"RestRequest({raw!r})", repr(request))
 async def test_empty_raises(self):
     raw = mocked_request()
     request = RestRequest(raw)
     with self.assertRaises(NotHasContentException):
         await request.content()
 def test_raw(self):
     raw = mocked_request()
     request = RestRequest(raw)
     self.assertEqual(raw, request.raw)
 def test_has_query_params_false(self):
     raw = mocked_request()
     request = RestRequest(raw)
     self.assertEqual(False, request.has_query_params)
 def test_user_unset(self):
     raw = mocked_request()
     request = RestRequest(raw)
     self.assertEqual(None, request.user)
 def test_has_content_false(self):
     raw = mocked_request()
     request = RestRequest(raw)
     self.assertEqual(False, request.has_content)
 async def test_params_raises(self):
     raw = mocked_request()
     request = RestRequest(raw)
     with self.assertRaises(NotHasParamsException):
         await request.params()
Пример #18
0
 async def test_get_callback_none(self):
     handler = self.handler.get_callback(_Cls._fn_none)
     response = await handler(mocked_request())
     self.assertIsInstance(response, web.Response)
     self.assertEqual(None, response.text)
     self.assertEqual("application/json", response.content_type)
 async def test_raises(self):
     raw = mocked_request(content_type="foo/bar", data="foobar".encode())
     request = RestRequest(raw)
     with self.assertRaises(ValueError):
         await request.content()