from __future__ import annotations

from typing import TYPE_CHECKING

import pytest

import requests

from pytest_httpserver.hooks import Chain

from pytest_httpserver.hooks import Delay

from pytest_httpserver.hooks import Garbage

if TYPE_CHECKING:

from werkzeug import Request

from werkzeug import Response

from pytest_httpserver import HTTPServer

class MyDelay(Delay):

def __init__(self, seconds: float) -> None:

super().__init__(seconds)

self.evidence: float | None = None

def _sleep(self) -> None:

assert self.evidence is None, "_sleep should be called only once"

self.evidence = self._seconds

def suffix_hook_factory(suffix: bytes):

def hook(_request: Request, response: Response) -> Response:

response.set_data(response.get_data() + suffix)

return response

return hook

def test_hook(httpserver: HTTPServer):

my_hook = suffix_hook_factory(b"-SUFFIX")

httpserver.expect_request("/foo").with_post_hook(my_hook).respond_with_data("OK")

assert requests.get(httpserver.url_for("/foo")).text == "OK-SUFFIX"

def test_delay_hook(httpserver: HTTPServer):

delay = MyDelay(10)

httpserver.expect_request("/foo").with_post_hook(delay).respond_with_data("OK")

assert requests.get(httpserver.url_for("/foo")).text == "OK"

assert delay.evidence == 10

def test_garbage_hook(httpserver: HTTPServer):

httpserver.expect_request("/prefix").with_post_hook(Garbage(prefix_size=128)).respond_with_data("OK")

httpserver.expect_request("/suffix").with_post_hook(Garbage(suffix_size=128)).respond_with_data("OK")

httpserver.expect_request("/both").with_post_hook(Garbage(prefix_size=128, suffix_size=128)).respond_with_data("OK")

httpserver.expect_request("/large_prefix").with_post_hook(Garbage(prefix_size=10 * 1024 * 1024)).respond_with_data(

"OK"

)

resp_content = requests.get(httpserver.url_for("/prefix")).content

assert len(resp_content) == 130

assert resp_content[128:] == b"OK"

resp_content = requests.get(httpserver.url_for("/large_prefix")).content

assert len(resp_content) == 10 * 1024 * 1024 + 2

assert resp_content[10 * 1024 * 1024 :] == b"OK"

resp_content = requests.get(httpserver.url_for("/suffix")).content

assert len(resp_content) == 130

assert resp_content[:2] == b"OK"

resp_content = requests.get(httpserver.url_for("/both")).content

assert len(resp_content) == 258

assert resp_content[128:130] == b"OK"

with pytest.raises(AssertionError, match="prefix_size should be positive integer"):

Garbage(-10)

with pytest.raises(AssertionError, match="suffix_size should be positive integer"):

Garbage(10, -10)

def test_chain(httpserver: HTTPServer):

delay = MyDelay(10)

httpserver.expect_request("/foo").with_post_hook(Chain(delay, Garbage(128))).respond_with_data("OK")

assert len(requests.get(httpserver.url_for("/foo")).content) == 130

assert delay.evidence == 10

def test_multiple_hooks(httpserver: HTTPServer):

delay = MyDelay(10)

httpserver.expect_request("/foo").with_post_hook(delay).with_post_hook(Garbage(128)).respond_with_data("OK")

assert len(requests.get(httpserver.url_for("/foo")).content) == 130

assert delay.evidence == 10

def test_multiple_hooks_correct_order(httpserver: HTTPServer):

hook1 = suffix_hook_factory(b"-S1")

hook2 = suffix_hook_factory(b"-S2")

httpserver.expect_request("/foo").with_post_hook(hook1).with_post_hook(hook2).respond_with_data("OK")

assert requests.get(httpserver.url_for("/foo")).text == "OK-S1-S2"