Refactor tests

Author: V1NAY8

CONTRIBUTING.md

@@ -50,7 +50,7 @@ The process for contributing to any of the Elasticsearch repositories is similar
 
 2. Run the linter and test suite to ensure your changes do not break existing code:
 
-   ```
+   ```bash
    # Install Nox for task management
    $ python -m pip install nox
 

test_elasticsearch/test_async/test_server/test_clients.py

@@ -29,15 +29,10 @@ async def test_indices_analyze(self, async_client):
 
 
 class TestBulk:
-    async def test_bulk_works_with_string_body(self, async_client):
-        docs = '{ "index" : { "_index" : "bulk_test_index", "_id" : "1" } }\n{"answer": 42}'
-        response = await async_client.bulk(body=docs)
-
-        assert response["errors"] is False
-        assert len(response["items"]) == 1
+    docs = '{ "index" : { "_index" : "bulk_test_index", "_id" : "1" } }\n{"answer": 42}'
 
-    async def test_bulk_works_with_bytestring_body(self, async_client):
-        docs = b'{ "index" : { "_index" : "bulk_test_index", "_id" : "2" } }\n{"answer": 42}'
+    @pytest.mark.parametrize("docs", [docs, docs.encode("utf-8")])
+    async def test_bulk_works_with_string_bytestring_body(self, docs, async_client):
         response = await async_client.bulk(body=docs)
 
         assert response["errors"] is False

test_elasticsearch/test_client/__init__.py

@@ -14,109 +14,3 @@
 #  KIND, either express or implied.  See the License for the
 #  specific language governing permissions and limitations
 #  under the License.
-
-from __future__ import unicode_literals
-
-from elasticsearch.client import Elasticsearch, _normalize_hosts
-
-from ..test_cases import DummyTransportTestCase
-
-
-class TestNormalizeHosts:
-    def test_none_uses_defaults(self):
-        assert [{}] == _normalize_hosts(None)
-
-    def test_strings_are_used_as_hostnames(self):
-        assert [{"host": "elastic.co"}] == _normalize_hosts(["elastic.co"])
-
-    def test_strings_are_parsed_for_port_and_user(self):
-        assert [
-            {"host": "elastic.co", "port": 42},
-            {"host": "elastic.co", "http_auth": "user:secre]"},
-        ] == _normalize_hosts(["elastic.co:42", "user:secre%[email protected]"])
-
-    def test_strings_are_parsed_for_scheme(self):
-        assert [
-            {"host": "elastic.co", "port": 42, "use_ssl": True},
-            {
-                "host": "elastic.co",
-                "http_auth": "user:secret",
-                "use_ssl": True,
-                "port": 443,
-                "url_prefix": "/prefix",
-            },
-        ] == _normalize_hosts(
-            ["https://elastic.co:42", "https://user:[email protected]/prefix"]
-        )
-
-    def test_dicts_are_left_unchanged(self):
-        assert [{"host": "local", "extra": 123}] == _normalize_hosts(
-            [{"host": "local", "extra": 123}]
-        )
-
-    def test_single_string_is_wrapped_in_list(self):
-        assert [{"host": "elastic.co"}] == _normalize_hosts("elastic.co")
-
-
-class TestClient(DummyTransportTestCase):
-    def test_request_timeout_is_passed_through_unescaped(self):
-        self.client.ping(request_timeout=0.1)
-        calls = self.assert_url_called("HEAD", "/")
-        assert [({"request_timeout": 0.1}, {}, None)] == calls
-
-    def test_params_is_copied_when(self):
-        rt = object()
-        params = dict(request_timeout=rt)
-        self.client.ping(params=params)
-        self.client.ping(params=params)
-        calls = self.assert_url_called("HEAD", "/", 2)
-        assert [
-            ({"request_timeout": rt}, {}, None),
-            ({"request_timeout": rt}, {}, None),
-        ] == calls
-        assert not (calls[0][0] is calls[1][0])
-
-    def test_headers_is_copied_when(self):
-        hv = "value"
-        headers = dict(Authentication=hv)
-        self.client.ping(headers=headers)
-        self.client.ping(headers=headers)
-        calls = self.assert_url_called("HEAD", "/", 2)
-        assert [
-            ({}, {"authentication": hv}, None),
-            ({}, {"authentication": hv}, None),
-        ] == calls
-        assert not (calls[0][0] is calls[1][0])
-
-    def test_from_in_search(self):
-        self.client.search(index="i", from_=10)
-        calls = self.assert_url_called("POST", "/i/_search")
-        assert [({"from": "10"}, {}, None)] == calls
-
-    def test_repr_contains_hosts(self):
-        assert "<Elasticsearch([{}])>" == repr(self.client)
-
-    def test_repr_subclass(self):
-        class OtherElasticsearch(Elasticsearch):
-            pass
-
-        assert "<OtherElasticsearch([{}])>" == repr(OtherElasticsearch())
-
-    def test_repr_contains_hosts_passed_in(self):
-        assert "es.org" in repr(Elasticsearch(["es.org:123"]))
-
-    def test_repr_truncates_host_to_5(self):
-        hosts = [{"host": "es" + str(i)} for i in range(10)]
-        es = Elasticsearch(hosts)
-        assert "es5" not in repr(es)
-        assert "..." in repr(es)
-
-    def test_index_uses_post_if_id_is_empty(self):
-        self.client.index(index="my-index", id="", body={})
-
-        self.assert_url_called("POST", "/my-index/_doc")
-
-    def test_index_uses_put_if_id_is_not_empty(self):
-        self.client.index(index="my-index", id=0, body={})
-
-        self.assert_url_called("PUT", "/my-index/_doc/0")

test_elasticsearch/test_cases.py renamed to test_elasticsearch/test_client/common.py

@@ -17,13 +17,13 @@
 
 from collections import defaultdict
 
-from elasticsearch import Elasticsearch
+from elasticsearch.connection import Connection
 
 
-class DummyTransport(object):
-    def __init__(self, hosts, responses=None, **_):
+class DummyTransport(Connection):
+    def __init__(self, hosts, **kwargs):
         self.hosts = hosts
-        self.responses = responses
+        self.responses = kwargs.pop("responses", None)
         self.call_count = 0
         self.calls = defaultdict(list)
 
@@ -36,15 +36,8 @@ def perform_request(self, method, url, params=None, headers=None, body=None):
         return resp
 
 
-class DummyTransportTestCase:
-    def setup_method(self, _):
-        self.client = Elasticsearch(transport_class=DummyTransport)
-
-    def assert_call_count_equals(self, count):
-        assert count == self.client.transport.call_count
-
-    def assert_url_called(self, method, url, count=1):
-        assert (method, url) in self.client.transport.calls
-        calls = self.client.transport.calls[(method, url)]
-        assert count == len(calls)
-        return calls
+def assert_helper(client, method, url, count=1):
+    calls = client.transport.calls
+    assert (method, url) in calls
+    assert count == len(calls[(method, url)])
+    return calls[(method, url)]

test_elasticsearch/test_client/test_client.py

@@ -0,0 +1,84 @@
+#  Licensed to Elasticsearch B.V. under one or more contributor
+#  license agreements. See the NOTICE file distributed with
+#  this work for additional information regarding copyright
+#  ownership. Elasticsearch B.V. 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.
+
+
+import pytest
+
+from elasticsearch.client import Elasticsearch
+
+from .common import DummyTransport, assert_helper
+
+
+class TestClient:
+    def test_request_timeout_is_passed_through_unescaped(self):
+        client = Elasticsearch(transport_class=DummyTransport)
+        client.ping(request_timeout=0.1)
+        calls = assert_helper(client, "HEAD", "/")
+        assert [({"request_timeout": 0.1}, {}, None)] == calls
+
+    def test_params_is_copied_when(self):
+        client = Elasticsearch(transport_class=DummyTransport)
+        params = {"request_timeout": object()}
+        client.ping(params=params)
+        client.ping(params=params)
+        calls = assert_helper(client, "HEAD", "/", 2)
+        assert [(params, {}, None), (params, {}, None)] == calls
+        assert calls[0][0] is not calls[1][0]
+
+    def test_headers_is_copied_when(self):
+        client = Elasticsearch(transport_class=DummyTransport)
+        headers = {"authentication": "value"}
+        client.ping(headers=headers)
+        client.ping(headers=headers)
+        calls = assert_helper(client, "HEAD", "/", 2)
+        assert [({}, headers, None), ({}, headers, None)] == calls
+        assert calls[0][0] is not calls[1][0]
+
+    def test_from_in_search(self):
+        client = Elasticsearch(transport_class=DummyTransport)
+        client.search(index="i", from_=10)
+        calls = assert_helper(client, "POST", "/i/_search")
+        assert [({"from": b"10"}, {}, None)] == calls
+
+    def test_repr_contains_hosts(self):
+        client = Elasticsearch(transport_class=DummyTransport)
+        assert "<Elasticsearch([{}])>" == repr(client)
+
+    def test_repr_subclass(self):
+        class OtherElasticsearch(Elasticsearch):
+            pass
+
+        assert "<OtherElasticsearch([{}])>" == repr(OtherElasticsearch())
+
+    def test_repr_contains_hosts_passed_in(self):
+        assert "es.org" in repr(Elasticsearch(["es.org:123"]))
+
+    def test_repr_truncates_host_to_5(self):
+        hosts = [{"host": "es" + str(i)} for i in range(10)]
+        es = Elasticsearch(hosts)
+        assert '{"host": "es5"}' not in repr(es)
+        assert "..." in repr(es)
+
+    @pytest.mark.parametrize(
+        ["id", "request_method", "url"],
+        [("", "POST", "/my-index/_doc"), (0, "PUT", "/my-index/_doc/0")],
+    )
+    def test_index_uses_id(self, id, request_method, url):
+        client = Elasticsearch(transport_class=DummyTransport)
+        client.index(index="my-index", id=id, body={})
+
+        assert_helper(client, request_method, url)

test_elasticsearch/test_client/test_cluster.py

@@ -15,30 +15,38 @@
 #  specific language governing permissions and limitations
 #  under the License.
 
-from test_elasticsearch.test_cases import DummyTransportTestCase
-
-
-class TestCluster(DummyTransportTestCase):
-    def test_stats_without_node_id(self):
-        self.client.cluster.stats()
-        self.assert_url_called("GET", "/_cluster/stats")
-
-    def test_stats_with_node_id(self):
-        self.client.cluster.stats("node-1")
-        self.assert_url_called("GET", "/_cluster/stats/nodes/node-1")
-
-        self.client.cluster.stats(node_id="node-2")
-        self.assert_url_called("GET", "/_cluster/stats/nodes/node-2")
-
-    def test_state_with_index_without_metric_defaults_to_all(self):
-        self.client.cluster.state()
-        self.assert_url_called("GET", "/_cluster/state")
-
-        self.client.cluster.state(metric="cluster_name")
-        self.assert_url_called("GET", "/_cluster/state/cluster_name")
-
-        self.client.cluster.state(index="index-1")
-        self.assert_url_called("GET", "/_cluster/state/_all/index-1")
-
-        self.client.cluster.state(index="index-1", metric="cluster_name")
-        self.assert_url_called("GET", "/_cluster/state/cluster_name/index-1")
+import pytest
+
+from elasticsearch.client import Elasticsearch
+
+from .common import DummyTransport, assert_helper
+
+
+class TestCluster:
+    @pytest.mark.parametrize("node_id", [None, "node-1", "node-2"])
+    def test_stats_node_id(self, node_id):
+        client = Elasticsearch(transport_class=DummyTransport)
+        client.cluster.stats(node_id=node_id)
+        url = "/_cluster/stats"
+        if node_id:
+            url += "/nodes/" + node_id
+        assert_helper(client, "GET", url)
+
+    @pytest.mark.parametrize(
+        ["index", "metric", "url_suffix"],
+        [
+            (None, None, None),
+            (None, "cluster_name", "/cluster_name"),
+            ("index-1", None, "/_all/index-1"),
+            ("index-1", "cluster_name", "/cluster_name/index-1"),
+        ],
+    )
+    def test_state_with_index_without_metric_defaults_to_all(
+        self, index, metric, url_suffix
+    ):
+        client = Elasticsearch(transport_class=DummyTransport)
+        client.cluster.state(index=index, metric=metric)
+        url = "/_cluster/state"
+        if url_suffix:
+            url += url_suffix
+        assert_helper(client, "GET", url)

test_elasticsearch/test_client/test_indices.py

@@ -17,26 +17,29 @@
 
 import pytest
 
-from test_elasticsearch.test_cases import DummyTransportTestCase
+from elasticsearch.client import Elasticsearch
 
+from .common import DummyTransport, assert_helper
 
-class TestIndices(DummyTransportTestCase):
+
+class TestIndices:
     def test_create_one_index(self):
-        self.client.indices.create("test-index")
-        self.assert_url_called("PUT", "/test-index")
+        client = Elasticsearch(transport_class=DummyTransport)
+        client.indices.create("test-index")
+        assert_helper(client, "PUT", "/test-index")
 
     def test_delete_multiple_indices(self):
-        self.client.indices.delete(["test-index", "second.index", "third/index"])
-        self.assert_url_called("DELETE", "/test-index,second.index,third%2Findex")
+        client = Elasticsearch(transport_class=DummyTransport)
+        client.indices.delete(["test-index", "second.index", "third/index"])
+        assert_helper(client, "DELETE", "/test-index,second.index,third%2Findex")
 
     def test_exists_index(self):
-        self.client.indices.exists("second.index,third/index")
-        self.assert_url_called("HEAD", "/second.index,third%2Findex")
+        client = Elasticsearch(transport_class=DummyTransport)
+        client.indices.exists("second.index,third/index")
+        assert_helper(client, "HEAD", "/second.index,third%2Findex")
 
-    def test_passing_empty_value_for_required_param_raises_exception(self):
-        with pytest.raises(ValueError):
-            self.client.indices.exists(index=None)
-        with pytest.raises(ValueError):
-            self.client.indices.exists(index=[])
+    @pytest.mark.parametrize("index", [None, [], ""])
+    def test_passing_empty_value_for_required_param_raises_exception(self, index):
+        client = Elasticsearch(transport_class=DummyTransport)
         with pytest.raises(ValueError):
-            self.client.indices.exists(index="")
+            client.indices.exists(index=index)