Add HW 2

homework/02-grpc-messenger/tests/test_client.py

@@ -0,0 +1,179 @@
+import os
+import time
+
+import pytest
+import requests
+
+HTTP_CONNECT_TIMEOUT_S = 1
+HTTP_READ_TIMEOUT_S = 5
+HTTP_READY_TIMEOUT_S = 20
+HTTP_RETRY_INTERVAL_S = 0.5
+HTTP_TIMEOUT = (HTTP_CONNECT_TIMEOUT_S, HTTP_READ_TIMEOUT_S)
+MESSAGE_TIMEOUT_S = 10
+MESSAGE_POLL_INTERVAL_S = 0.05
+
+
+def wait_for_http(url):
+    deadline = time.monotonic() + HTTP_READY_TIMEOUT_S
+    last_exception = None
+    while True:
+        remaining = deadline - time.monotonic()
+        if remaining <= 0:
+            pytest.fail(
+                f'timed out waiting for HTTP endpoint {url}: {last_exception}',
+                pytrace=False,
+            )
+        readiness_timeout = (
+            min(HTTP_CONNECT_TIMEOUT_S, remaining),
+            min(HTTP_READ_TIMEOUT_S, remaining),
+        )
+        try:
+            response = requests.get(url, timeout=readiness_timeout)
+            response.close()
+            return
+        except (requests.exceptions.ConnectionError, requests.exceptions.Timeout) as exc:
+            last_exception = exc
+
+        remaining = deadline - time.monotonic()
+        if remaining <= 0:
+            pytest.fail(
+                f'timed out waiting for HTTP endpoint {url}: {last_exception}',
+                pytrace=False,
+            )
+        time.sleep(min(HTTP_RETRY_INTERVAL_S, remaining))
+
+
+def post_json(url, path, timeout=HTTP_TIMEOUT, **kwargs):
+    endpoint = url + path
+    try:
+        response = requests.post(endpoint, timeout=timeout, **kwargs)
+    except requests.exceptions.Timeout as exc:
+        pytest.fail(f'timed out waiting for HTTP response from {endpoint}: {exc}', pytrace=False)
+    except requests.exceptions.ConnectionError as exc:
+        pytest.fail(f'could not connect to HTTP endpoint {endpoint}: {exc}', pytrace=False)
+
+    try:
+        assert response.status_code == 200, response.text
+        return response.json()
+    finally:
+        response.close()
+
+
+@pytest.fixture(scope='session')
+def client1_ready_url():
+    url = 'http://' + os.environ.get('MESSENGER_TEST_CLIENT1_ADDR', '127.0.0.1:8080')
+    wait_for_http(url)
+    return url
+
+
+@pytest.fixture(scope='session')
+def client2_ready_url():
+    url = 'http://' + os.environ.get('MESSENGER_TEST_CLIENT2_ADDR', '127.0.0.1:8081')
+    wait_for_http(url)
+    return url
+
+
+@pytest.fixture
+def client1_url(client1_ready_url):
+    url = client1_ready_url
+    get_messages(url)  # we need to flush pending messages before and after each tests
+    yield url
+    get_messages(url)
+
+
+@pytest.fixture
+def client2_url(client2_ready_url):
+    url = client2_ready_url
+    get_messages(url)
+    yield url
+    get_messages(url)
+
+
+def send_message(url, mes):
+    return post_json(url, '/sendMessage', json=mes)
+
+
+def get_messages(url, **kwargs):
+    return post_json(url, '/getAndFlushMessages', **kwargs)
+
+
+def wait_for_messages(url, expected):
+    deadline = time.monotonic() + MESSAGE_TIMEOUT_S
+    messages = []
+    while len(messages) < len(expected):
+        remaining = deadline - time.monotonic()
+        if remaining <= 0:
+            pytest.fail(
+                f'timed out waiting for messages from {url}: '
+                f'expected {expected!r}, received {messages!r}',
+                pytrace=False,
+            )
+        # Divide the remaining budget between connecting and reading the response.
+        timeout = (
+            min(HTTP_CONNECT_TIMEOUT_S, remaining / 2),
+            min(HTTP_READ_TIMEOUT_S, remaining / 2),
+        )
+        batch = get_messages(url, timeout=timeout)
+        assert isinstance(batch, list), f'expected a message array, received {batch!r}'
+        messages.extend(batch)
+        assert messages == expected[:len(messages)], \
+            f'expected {expected!r}, received {messages!r}'
+        remaining = deadline - time.monotonic()
+        if remaining <= 0:
+            pytest.fail(f'timed out waiting for messages from {url}', pytrace=False)
+        if len(messages) < len(expected):
+            time.sleep(min(MESSAGE_POLL_INTERVAL_S, remaining))
+    return messages
+
+
+def test_single_client_single_message(client1_url, client2_url):
+    mes = {
+        'author': 'TestSingleClient',
+        'text': 'This is test text'
+    }
+    resp = send_message(client1_url, mes)
+    mes['sendTime'] = resp['sendTime']
+    assert wait_for_messages(client1_url, [mes]) == [mes]
+    # Drain both subscriptions before the next test sends more messages.
+    assert wait_for_messages(client2_url, [mes]) == [mes]
+
+
+def test_single_client_multiple_messages(client1_url, client2_url):
+    mes = [{
+        'author': 'TestSingleClient1',
+        'text': 'This is test text'
+    }, {
+        'author': 'TestSingleClient2',
+        'text': 'This is test text'
+    }]
+    for m in mes:
+        resp = send_message(client1_url, m)
+        m['sendTime'] = resp['sendTime']
+    assert wait_for_messages(client1_url, mes) == mes
+    assert wait_for_messages(client2_url, mes) == mes
+
+
+def test_two_clients_multiple_messages(client1_url, client2_url):
+    client1_name = 'TestMultiClient1'
+    client2_name = 'TestMultiClient2'
+    mes = [{
+        'author': client1_name,
+        'text': 'This is test text #1'
+    }, {
+        'author': client1_name,
+        'text': 'This is test text #2'
+    }, {
+        'author': client2_name,
+        'text': 'This is test text #3'
+    }, {
+        'author': client2_name,
+        'text': 'This is test text #4'
+    }]
+    times = set()
+    for m in mes:
+        resp = send_message(client1_url if m['author'] == client1_name else client2_url, m)
+        m['sendTime'] = resp['sendTime']
+        times.add(m['sendTime'])
+    assert len(times) == len(mes)
+    assert wait_for_messages(client1_url, mes) == mes
+    assert wait_for_messages(client2_url, mes) == mes