Add tests for the shared HTTP client modules

Author: bgunebakan

tests/client/test_options.py

@@ -0,0 +1,149 @@
+# -*- coding: utf-8; -*-
+#
+# Licensed to CRATE Technology GmbH ("Crate") under one or more contributor
+# license agreements.  See the NOTICE file distributed with this work for
+# additional information regarding copyright ownership.  Crate licenses
+# this file to you under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.  You may
+# obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+# License for the specific language governing permissions and limitations
+# under the License.
+#
+# However, if you have executed another commercial license agreement
+# with Crate these terms will supersede the license and you may use the
+# software solely pursuant to the terms of the relevant commercial agreement.
+
+import socket
+
+import pytest
+
+from crate.client._options import (
+    credentials_from_url,
+    keepalive_socket_options,
+    server_url,
+    sql_path,
+    to_server_list,
+    validate_compress,
+)
+
+
+@pytest.mark.parametrize(
+    "server, expected",
+    [
+        ("a", "http://a"),
+        ("a/path", "http://a/path"),
+        ("a:9345", "http://a:9345"),
+        ("a:9345/path", "http://a:9345/path"),
+        ("https://a:9345", "https://a:9345"),
+        ("https://a:9345/path", "https://a:9345/path"),
+        ("https://a", "https://a"),
+        ("https://a/path", "https://a/path"),
+        ("HTTPS://a", "https://a"),
+        ("demo.crate.io", "http://demo.crate.io"),
+    ],
+)
+def test_server_url(server, expected):
+    assert server_url(server) == expected
+
+
+@pytest.mark.parametrize(
+    "servers",
+    [
+        "localhost:4200 https://localhost:4201",
+        ["localhost:4200", "https://localhost:4201"],
+        ("localhost:4200", "https://localhost:4201"),
+    ],
+)
+def test_to_server_list(servers):
+    assert to_server_list(servers) == [
+        "http://localhost:4200",
+        "https://localhost:4201",
+    ]
+
+
+@pytest.mark.parametrize(
+    "url, username, password, expected",
+    [
+        ("http://localhost:4200", None, None, (None, None)),
+        ("http://crate@localhost:4200", None, None, ("crate", None)),
+        (
+            "http://crate:s3cr3t@localhost:4200",
+            None,
+            None,
+            ("crate", "s3cr3t"),
+        ),
+        ("http://localhost:4200", None, "s3cr3t", (None, "s3cr3t")),
+        ("http://crate@localhost:4200", None, "s3cr3t", ("crate", "s3cr3t")),
+        (
+            "http://crate:from-url@localhost:4200",
+            None,
+            "s3cr3t",
+            ("crate", "from-url"),
+        ),
+        ("http://localhost:4200", "", None, ("", None)),
+    ],
+)
+def test_credentials_from_url(url, username, password, expected):
+    assert credentials_from_url(url, username, password) == expected
+
+
+@pytest.mark.parametrize("compress", [True, False, 0, 8192])
+def test_validate_compress(compress):
+    assert validate_compress(compress) is compress
+
+
+@pytest.mark.parametrize(
+    "compress, type_name", [("8192", "'str'"), (None, "'NoneType'")]
+)
+def test_validate_compress_invalid(compress, type_name):
+    with pytest.raises(
+        TypeError, match=f"compress must be bool or int, got {type_name}"
+    ):
+        validate_compress(compress)
+
+
+@pytest.mark.parametrize(
+    "error_trace, expected",
+    [
+        (False, "/_sql?types=true"),
+        (True, "/_sql?types=true&error_trace=true"),
+    ],
+)
+def test_sql_path(error_trace, expected):
+    assert sql_path(error_trace) == expected
+
+
+def test_sql_path_with_given_path():
+    assert sql_path(True, "/_sql") == "/_sql&error_trace=true"
+
+
+def test_keepalive_socket_options_off():
+    assert keepalive_socket_options(False, 30, 10, 5) == []
+
+
+def test_keepalive_socket_options_defaults():
+    assert keepalive_socket_options() == [
+        (socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
+    ]
+
+
+@pytest.mark.skipif(
+    not all(
+        hasattr(socket, name)
+        for name in ("TCP_KEEPIDLE", "TCP_KEEPINTVL", "TCP_KEEPCNT")
+    ),
+    reason="Platform does not support all TCP keepalive options",
+)
+def test_keepalive_socket_options_tcp():
+    assert keepalive_socket_options(True, 30, 10, 5) == [
+        (socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1),
+        (socket.IPPROTO_TCP, socket.TCP_KEEPIDLE, 30),
+        (socket.IPPROTO_TCP, socket.TCP_KEEPINTVL, 10),
+        (socket.IPPROTO_TCP, socket.TCP_KEEPCNT, 5),
+    ]

tests/client/test_pool.py

@@ -0,0 +1,148 @@
+# -*- coding: utf-8; -*-
+#
+# Licensed to CRATE Technology GmbH ("Crate") under one or more contributor
+# license agreements.  See the NOTICE file distributed with this work for
+# additional information regarding copyright ownership.  Crate licenses
+# this file to you under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.  You may
+# obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+# License for the specific language governing permissions and limitations
+# under the License.
+#
+# However, if you have executed another commercial license agreement
+# with Crate these terms will supersede the license and you may use the
+# software solely pursuant to the terms of the relevant commercial agreement.
+
+import logging
+
+import pytest
+
+from crate.client import exceptions
+from crate.client._pool import _ServerPool
+from crate.client.http import Client
+
+NODE1 = "http://localhost:4200"
+NODE2 = "http://localhost:4201"
+NODE3 = "http://localhost:4202"
+
+
+class FakeClock:
+    def __init__(self, now: float = 1_700_000_000.0):
+        self.now = now
+
+    def __call__(self) -> float:
+        return self.now
+
+
+@pytest.fixture
+def clock():
+    return FakeClock()
+
+
+def test_round_robin(clock):
+    pool = _ServerPool([NODE1, NODE2, NODE3], clock=clock)
+    picked = [pool._get_server() for _ in range(4)]
+    assert picked == [NODE1, NODE2, NODE3, NODE1]
+
+
+def test_active_servers_is_a_copy(clock):
+    pool = _ServerPool([NODE1, NODE2], clock=clock)
+    active = pool.active_servers
+    active.clear()
+    assert pool.active_servers == [NODE1, NODE2]
+
+
+def test_drop_server(clock):
+    pool = _ServerPool([NODE1, NODE2], clock=clock)
+    pool._drop_server(NODE1, "Connection refused")
+    assert pool.active_servers == [NODE2]
+    assert pool._inactive_servers == [(clock.now, NODE1, "Connection refused")]
+    assert [pool._get_server() for _ in range(2)] == [NODE2, NODE2]
+
+
+def test_drop_unknown_server_is_ignored(clock):
+    pool = _ServerPool([NODE1, NODE2], clock=clock)
+    pool._drop_server(NODE3, "Connection refused")
+    assert pool.active_servers == [NODE1, NODE2]
+    assert pool._inactive_servers == []
+
+
+def test_drop_last_server_raises(clock):
+    pool = _ServerPool([NODE1, NODE2], clock=clock)
+    pool._drop_server(NODE1, "Connection refused")
+    with pytest.raises(
+        exceptions.ConnectionError,
+        match="No more Servers available, exception from last server: "
+        "Read timed out",
+    ):
+        pool._drop_server(NODE2, "Read timed out")
+    assert pool.active_servers == []
+
+
+def test_server_restored_after_retry_interval(clock):
+    pool = _ServerPool([NODE1, NODE2], clock=clock)
+    pool.retry_interval = 5
+    pool._drop_server(NODE1, "Connection refused")
+
+    clock.now += 4
+    pool._get_server()
+    assert pool.active_servers == [NODE2]
+
+    clock.now += 1
+    assert pool._get_server() == NODE2
+    assert pool.active_servers == [NODE1, NODE2]
+    assert pool._inactive_servers == []
+
+
+def test_retry_interval_class_default(clock):
+    pool = _ServerPool([NODE1, NODE2], clock=clock)
+    pool._drop_server(NODE1, "Connection refused")
+
+    clock.now += 29
+    pool._get_server()
+    assert pool.active_servers == [NODE2]
+
+    clock.now += 1
+    pool._get_server()
+    assert sorted(pool.active_servers) == [NODE1, NODE2]
+
+
+def test_oldest_server_restored_when_none_is_active(clock):
+    pool = _ServerPool([NODE1, NODE2, NODE3], clock=clock)
+    pool._drop_server(NODE2, "Connection refused")
+    clock.now += 1
+    pool._drop_server(NODE1, "Connection refused")
+    pool._active_servers = []
+
+    assert pool._get_server() == NODE2
+    assert pool.active_servers == [NODE2]
+    assert pool._inactive_servers == [(clock.now, NODE1, "Connection refused")]
+
+
+def test_pool_logs_on_subclass_logger(clock, caplog):
+    class Pool(_ServerPool):
+        _logger = logging.getLogger("crate.client.test")
+
+    pool = Pool([NODE1, NODE2], clock=clock)
+    pool.retry_interval = 5
+    with caplog.at_level(logging.WARNING):
+        pool._drop_server(NODE1, "Connection refused")
+        clock.now += 5
+        pool._get_server()
+    assert [(r.name, r.getMessage()) for r in caplog.records] == [
+        ("crate.client.test", f"Removed server {NODE1} from active pool"),
+        ("crate.client.test", f"Restored server {NODE1} into active pool"),
+    ]
+
+
+def test_client_logs_on_http_logger(caplog):
+    client = Client(servers=[NODE1, NODE2])
+    with caplog.at_level(logging.WARNING):
+        client._drop_server(NODE1, "Connection refused")
+    assert [r.name for r in caplog.records] == ["crate.client.http"]