rework unit tests in the Pytest style. (reportportal#77)

iivanou · web-flow · commit 045f0165fd29 · 2020-03-24T15:19:58.000+03:00
diff --git a/.travis.yml b/.travis.yml
@@ -10,12 +10,12 @@ python:
   - "3.7"
   - "3.8"
 install:
-  - pip install pycodestyle pydocstyle
+  - pip install pycodestyle pydocstyle pytest delayed-assert requests
 before_script:
   - pycodestyle .
   - pydocstyle .
 script:
-  - python setup.py test
+  - pytest tests/ -s -vv
   - python setup.py -q install
 jobs:
   include:
diff --git a/setup.py b/setup.py
@@ -22,10 +22,5 @@
         'Programming Language :: Python :: 3.7',
         'Programming Language :: Python :: 3.8'
     ],
-    install_requires=['requests>=2.4.2', 'six'],
-    setup_requires=['pytest-runner'],
-    tests_require=[
-        'pytest',
-        'delayed-assert'
-    ]
+    install_requires=['requests>=2.4.2', 'six']
 )
diff --git a/tests/__init__.py b/tests/__init__.py
@@ -1 +1,4 @@
-"""tests for client Python."""
+"""This package contains unit tests for the project."""
+
+from six import add_move, MovedModule
+add_move(MovedModule('mock', 'mock', 'unittest.mock'))
diff --git a/tests/conftest.py b/tests/conftest.py
@@ -0,0 +1,32 @@
+"""This module contains common Pytest fixtures and hooks for unit tests."""
+
+from six.moves import mock
+
+from pytest import fixture
+
+from reportportal_client.service import ReportPortalService
+
+
+@fixture()
+def response():
+    """Cook up a mock for the Response with specific arguments."""
+    def inner(ret_code, ret_value):
+        """Set up response with the given parameters.
+
+        :param ret_code:  Return code for the response
+        :param ret_value: Return value for the response
+        :return:          Mocked Responce object with the given parameters
+        """
+        with mock.patch('requests.Response') as resp:
+            resp.status_code = ret_code
+            resp.json.return_value = ret_value
+            return resp
+    return inner
+
+
+@fixture(scope='session')
+def rp_service():
+    """Prepare instance of the ReportPortalService for testing."""
+    service = ReportPortalService('http://endpoint', 'project', 'token')
+    service.session = mock.Mock()
+    return service
diff --git a/tests/test_service.py b/tests/test_service.py
@@ -1,112 +1,84 @@
-"""Tests for service.py ."""
+"""This modules includes unit tests for the service.py module."""
 
-try:
-    from unittest.mock import create_autospec, Mock, patch, MagicMock
-except ImportError:
-    from mock import create_autospec, Mock, patch, MagicMock
 
-from reportportal_client.service import _convert_string, _list_to_payload, \
-    uri_join, _get_id, _get_msg, _get_data, _get_json, _get_messages, \
-    ReportPortalService
-
-import unittest
 from datetime import datetime
+from six.moves import mock
+
+from delayed_assert import expect, assert_expectations
+
+from reportportal_client.service import (
+    _convert_string,
+    _get_data,
+    _get_id,
+    _get_json,
+    _get_messages,
+    _get_msg,
+    _list_to_payload
+)
 
 
-class TestServiceFunctions(unittest.TestCase):
-    """Test for additional functions."""
+class TestServiceFunctions:
+    """This class contains test methods for helper functions."""
 
     def test_check_convert_to_string(self):
         """Test for support and convert strings to utf-8."""
-        self.assertEqual(_convert_string("Hello world"), 'Hello world')
-        self.assertEqual(type(_convert_string("Hello world")), str)
+        expect(_convert_string("Hello world") == 'Hello world')
+        expect(lambda: isinstance(_convert_string("Hello world"), str))
+        assert_expectations()
 
     def test_list_to_payload(self):
         """Test convert dict to list of dicts."""
         initial_dict = {'key': "value", 'key1': 'value1'}
         expected_list = [{'key': 'key', 'value': 'value'},
                          {'key': 'key1', 'value': 'value1'}]
-        self.assertEqual(_list_to_payload(initial_dict), expected_list)
-
-    def test_get_id(self):
-        """Test for get id from Response obj."""
-        fake_json = {"id": 123}
+        assert _list_to_payload(initial_dict) == expected_list
 
-        with patch('requests.Response', new_callable=MagicMock()) as mock_get:
-            mock_get.status_code = 200
-            mock_get.json.return_value = fake_json
+    def test_get_id(self, response):
+        """Test for the get_id function."""
+        assert _get_id(response(200, {"id": 123})) == 123
 
-            obj = _get_id(mock_get)
-
-        self.assertEqual(obj, 123)
-
-    def test_get_msg(self):
-        """Test get_msg recieved from Response."""
+    def test_get_msg(self, response):
+        """Test for the get_msg function."""
         fake_json = {"id": 123}
+        assert _get_msg(response(200, fake_json)) == fake_json
 
-        with patch('requests.Response', new_callable=MagicMock()) as mock_get:
-            mock_get.status_code = 200
-            mock_get.json.return_value = fake_json
-
-            obj = _get_msg(mock_get)
-
-        self.assertEqual(obj, fake_json)
-
-    def test_get_data(self):
-        """Test get data from Response."""
+    def test_get_data(self, response):
+        """Test for the get_data function."""
         fake_json = {"id": 123}
+        assert _get_data(response(200, fake_json)) == fake_json
 
-        with patch('requests.Response', new_callable=MagicMock()) as mock_get:
-            mock_get.status_code = 200
-            mock_get.json.return_value = fake_json
-
-            obj = _get_data(mock_get)
-
-        self.assertEqual(obj, fake_json)
-
-    def test_get_json(self):
-        """Test get json from Response."""
+    def test_get_json(self, response):
+        """Test for the get_json function."""
         fake_json = {"id": 123}
-
-        with patch('requests.Response', new_callable=MagicMock()) as mock_get:
-            mock_get.status_code = 200
-            mock_get.json.return_value = fake_json
-
-            obj = _get_json(mock_get)
-
-        self.assertEqual(obj, fake_json)
+        assert _get_json(response(200, fake_json)) == fake_json
 
     def test_get_messages(self):
-        """Test get errors from response."""
+        """Test for the get_messages function."""
         data = {"responses": [{"errorCode": 422, "message": "error"}]}
-
-        obj = _get_messages(data)
-
-        self.assertEqual(obj, ['422: error'])
+        assert _get_messages(data) == ['422: error']
 
 
-class ReportPortalServiceTest(unittest.TestCase):
+class TestReportPortalService:
     """This class stores methods which test ReportPortalService."""
 
-    def setUp(self):
-        """Instantiate the ReportPortalService class and mock its session."""
-        self.rp = ReportPortalService('http://endpoint', 'project', 'token')
-        self.rp.session = MagicMock()
-
-    def test_start_launch(self):
-        """Test start launch and sending request."""
-        with patch('reportportal_client.service._get_data',
-                   new_callable=Mock()) as mock_get:
-            mock_get.return_value = {"id": 111}
-            launch_id = self.rp.start_launch('name',
-                                             datetime.now().isoformat())
-        self.assertEqual(launch_id, 111)
-
-    def test_finish_launch(self):
-        """Test finish launch and sending request."""
-        with patch('reportportal_client.service._get_msg',
-                   new_callable=Mock()) as mock_get:
-            mock_get.return_value = {"id": 111}
-            _get_msg = self.rp.finish_launch('name',
-                                             datetime.now().isoformat())
-        self.assertEqual(_get_msg, {"id": 111})
+    @mock.patch('reportportal_client.service._get_data')
+    def test_start_launch(self, mock_get, rp_service):
+        """Test start launch and sending request.
+
+        :param mock_get:   Mocked _get_data() function
+        :param rp_service: Pytest fixture
+        """
+        mock_get.return_value = {"id": 111}
+        launch_id = rp_service.start_launch('name', datetime.now().isoformat())
+        assert launch_id == 111
+
+    @mock.patch('reportportal_client.service._get_msg')
+    def test_finish_launch(self, mock_get, rp_service):
+        """Test finish launch and sending request.
+
+        :param mock_get:   Mocked _get_msg() function
+        :param rp_service: Pytest fixture
+        """
+        mock_get.return_value = {"id": 111}
+        _get_msg = rp_service.finish_launch('name', datetime.now().isoformat())
+        assert _get_msg == {"id": 111}
