Migrate tests to pytest

Author: akopdev

bitrix24/bitrix24.py

@@ -6,6 +6,7 @@
 
 import warnings
 from time import sleep
+from typing import Any, Dict
 from urllib.parse import urlparse
 
 import requests
@@ -36,13 +37,13 @@ def __init__(self, domain: str, timeout: int = 60, safe: bool = True):
     def _prepare_domain(self, domain: str):
         """Normalize user passed domain to a valid one."""
         if not domain:
-            raise Exception("Empty domain")
+            raise BitrixError("Empty domain")
 
         o = urlparse(domain)
         user_id, code = o.path.split("/")[2:4]
         return "{0}://{1}/rest/{2}/{3}".format(o.scheme, o.netloc, user_id, code)
 
-    def _prepare_params(self, params, prev=""):
+    def _prepare_params(self, params: Dict[str, Any], prev=""):
         """
         Transform list of parameters to a valid bitrix array.
 
@@ -80,7 +81,8 @@ def _prepare_params(self, params, prev=""):
                         ret += "{0}={1}&".format(key, value)
         return ret
 
-    def request(self, url, method, p):
+    def request(self, method, p):
+        url = "{0}/{1}.json".format(self.domain, method)
         if method.rsplit(".", 1)[0] in ["add", "update", "delete", "set"]:
             r = requests.post(url, data=p, timeout=self.timeout, verify=self.safe).json()
         else:
@@ -111,12 +113,11 @@ def callMethod(self, method: str, **params):
             Returning the REST method response as an array, an object or a scalar
         """
         if not method or len(method.split(".")) < 3:
-            raise BitrixError("Empty method")
+            raise BitrixError("Wrong method name", 400)
 
         try:
-            url = "{0}/{1}.json".format(self.domain, method)
             p = self._prepare_params(params)
-            r = self.request(url, method, p)
+            r = self.request(method, p)
             if not r:
                 return None
         except ValueError:

tests/conftest.py

@@ -0,0 +1,8 @@
+import pytest
+
+from bitrix24 import Bitrix24
+
+
+@pytest.fixture
+def b24():
+    return Bitrix24("https://example.bitrix24.com/rest/1/123456789")

tests/test_bitrix24.py

@@ -1,76 +1,23 @@
-import unittest
+import pytest
 
 from bitrix24 import Bitrix24, BitrixError
 
 
-class Bitrix24Test(unittest.TestCase):
-    def setUp(self):
-        self.b24 = Bitrix24("https://example.bitrix24.com/rest/1/123456789")
+def test_init_with_empty_domain():
+    with pytest.raises(BitrixError):
+        Bitrix24("")
 
-    def test_init_with_empty_domain(self):
-        with self.assertRaises(Exception):
-            Bitrix24("")
 
-    def test_call_with_empty_method(self):
-        with self.assertRaises(BitrixError):
-            self.b24.callMethod("")
+def test_call_with_empty_method(b24):
+    with pytest.raises(BitrixError):
+        b24.callMethod("")
 
-    def test_call_non_exists_method(self):
-        with self.assertRaises(BitrixError):
-            self.b24.callMethod("hello.world")
 
-    def test_call_wrong_method(self):
-        with self.assertRaises(BitrixError):
-            self.b24.callMethod("helloworld")
+def test_call_non_exists_method(b24):
+    with pytest.raises(BitrixError):
+        b24.callMethod("hello.world")
 
 
-class ParamsPreparationTest(unittest.TestCase):
-    def setUp(self):
-        self.b24 = Bitrix24("https://example.bitrix24.com/rest/1/123456789")
-
-    def test_one_level(self):
-        params = {"fruit": "apple"}
-        param_string = self.b24._prepare_params(params)
-        self.assertEqual(param_string, "fruit=apple&")
-
-    def test_one_level_several_items(self):
-        params = {"fruit": "apple", "vegetable": "broccoli"}
-        param_string = self.b24._prepare_params(params)
-        self.assertEqual(param_string, "fruit=apple&vegetable=broccoli&")
-
-    def test_multi_level(self):
-        params = {"fruit": {"citrus": "lemon"}}
-        param_string = self.b24._prepare_params(params)
-        self.assertEqual(param_string, "fruit[citrus]=lemon&")
-
-    def test_multi_level_deep(self):
-        params = {"root": {"level 1": {"level 2": {"level 3": "value"}}}}
-        param_string = self.b24._prepare_params(params)
-        self.assertEqual(param_string, "root[level 1][level 2][level 3]=value&")
-
-    def test_list_dict_mixed(self):
-        params = {"root": {"level 1": [{"list_dict 1": "value 1"}, {"list_dict 2": "value 2"}]}}
-        param_string = self.b24._prepare_params(params)
-        self.assertEqual(
-            param_string,
-            "root[level 1][0][list_dict 1]=value 1&root[level 1][1][list_dict 2]=value 2&",
-        )
-
-    def test_multi_level_several_items(self):
-        params = {"fruit": {"citrus": "lemon", "sweet": "apple"}}
-        param_string = self.b24._prepare_params(params)
-        self.assertEqual(param_string, "fruit[citrus]=lemon&fruit[sweet]=apple&")
-
-    def test_list(self):
-        params = {"fruit": ["lemon", "apple"]}
-        param_string = self.b24._prepare_params(params)
-        self.assertEqual(param_string, "fruit[0]=lemon&fruit[1]=apple&")
-
-    def test_tuple(self):
-        params = {"fruit": ("lemon", "apple")}
-        param_string = self.b24._prepare_params(params)
-        self.assertEqual(param_string, "fruit[0]=lemon&fruit[1]=apple&")
-
-    def test_string(self):
-        param_string = self.b24._prepare_params("")
-        self.assertEqual(param_string, "")
+def test_call_wrong_method(b24):
+    with pytest.raises(BitrixError):
+        b24.callMethod("helloworld")

tests/test_params_preparation.py

@@ -0,0 +1,51 @@
+def test_one_level(b24):
+    params = {"fruit": "apple"}
+    param_string = b24._prepare_params(params)
+    assert param_string == "fruit=apple&"
+
+
+def test_one_level_several_items(b24):
+    params = {"fruit": "apple", "vegetable": "broccoli"}
+    param_string = b24._prepare_params(params)
+    assert param_string == "fruit=apple&vegetable=broccoli&"
+
+
+def test_multi_level(b24):
+    params = {"fruit": {"citrus": "lemon"}}
+    param_string = b24._prepare_params(params)
+    assert param_string == "fruit[citrus]=lemon&"
+
+
+def test_multi_level_deep(b24):
+    params = {"root": {"level 1": {"level 2": {"level 3": "value"}}}}
+    param_string = b24._prepare_params(params)
+    assert param_string == "root[level 1][level 2][level 3]=value&"
+
+
+def test_list_dict_mixed(b24):
+    params = {"root": {"level 1": [{"list_d 1": "value 1"}, {"list_d 2": "value 2"}]}}
+    param_string = b24._prepare_params(params)
+    assert param_string == "root[level 1][0][list_d 1]=value 1&root[level 1][1][list_d 2]=value 2&"
+
+
+def test_multi_level_several_items(b24):
+    params = {"fruit": {"citrus": "lemon", "sweet": "apple"}}
+    param_string = b24._prepare_params(params)
+    assert param_string == "fruit[citrus]=lemon&fruit[sweet]=apple&"
+
+
+def test_list(b24):
+    params = {"fruit": ["lemon", "apple"]}
+    param_string = b24._prepare_params(params)
+    assert param_string == "fruit[0]=lemon&fruit[1]=apple&"
+
+
+def test_tuple(b24):
+    params = {"fruit": ("lemon", "apple")}
+    param_string = b24._prepare_params(params)
+    assert param_string == "fruit[0]=lemon&fruit[1]=apple&"
+
+
+def test_string(b24):
+    param_string = b24._prepare_params("")
+    assert param_string == ""