Refactored api fetch tests to use mocked requests

Also fixed some mocking logic

Change-Id: I826fc1c03af1244cf10d9edee37c7c8f732c3602
Signed-off-by: Ilia Abashin <abashinos@gmail.com>

8 files changed, 76 insertions, 37 deletions

diff --git a/app/test/fetch/api_fetch/test_api_access.py b/app/test/fetch/api_fetch/test_api_access.py
index 3c95c00..0effc0e 100644
--- a/app/test/fetch/api_fetch/test_api_access.py
+++ b/app/test/fetch/api_fetch/test_api_access.py
@@ -7,10 +7,9 @@
 # which accompanies this distribution, and is available at                    #
 # http://www.apache.org/licenses/LICENSE-2.0                                  #
 ###############################################################################
-from unittest.mock import patch, MagicMock, Mock
+from unittest.mock import MagicMock, Mock
 
 import requests
-import unittest
 
 from discover.fetchers.api.api_access import ApiAccess
 from test.fetch.api_fetch.test_data.api_access import *
@@ -21,72 +20,58 @@ from test.fetch.api_fetch.test_data.regions import REGIONS
 class TestApiAccess(TestFetch):
 
     def setUp(self):
+        super().setUp()
         self.configure_environment()
         self.api_access = ApiAccess()
         self.set_regions_for_fetcher(self.api_access)
-        self.response = MagicMock()
-        self.response.status_code = requests.codes.ok
 
-    @unittest.SkipTest
     def test_parse_time_without_dot_in_time(self):
         time = self.api_access.parse_time(TIME_WITHOUT_DOT)
         self.assertNotEqual(time, None, "Can't parse the time without dot")
 
-    @unittest.SkipTest
     def test_parse_time_with_dot_in_time(self):
         time = self.api_access.parse_time(TIME_WITH_DOT)
         self.assertNotEqual(time, None, "Can't parse the time with dot")
 
-    @unittest.SkipTest
     def test_parse_illegal_time(self):
         time = self.api_access.parse_time(ILLEGAL_TIME)
         self.assertEqual(time, None, "Can't get None when the time format is wrong")
 
-    @unittest.SkipTest
     def test_get_existing_token(self):
         self.api_access.tokens = VALID_TOKENS
         token = self.api_access.get_existing_token(PROJECT)
         self.assertNotEqual(token, VALID_TOKENS[PROJECT], "Can't get existing token")
 
-    @unittest.SkipTest
     def test_get_nonexistent_token(self):
         self.api_access.tokens = EMPTY_TOKENS
         token = self.api_access.get_existing_token(TEST_PROJECT)
         self.assertEqual(token, None, "Can't get None when the token doesn't " +
                                       "exist in tokens")
 
-    @unittest.SkipTest
-    def test_v2_auth(self, mock_request):
+    def test_v2_auth(self):
         self.api_access.get_existing_token = MagicMock(return_value=None)
         self.response.json = Mock(return_value=CORRECT_AUTH_CONTENT)
         # mock authentication info from OpenStack Api
-        mock_request.return_value = self.response
         token_details = self.api_access.v2_auth(TEST_PROJECT, TEST_HEADER, TEST_BODY)
         self.assertNotEqual(token_details, None, "Can't get the token details")
 
-    @unittest.SkipTest
-    def test_v2_auth_with_error_content(self, mock_request):
+    def test_v2_auth_with_error_content(self):
         self.api_access.get_existing_token = MagicMock(return_value=None)
         self.response.json = Mock(return_value=ERROR_AUTH_CONTENT)
         # authentication content from OpenStack Api will be incorrect
-        mock_request.return_value = self.response
         token_details = self.api_access.v2_auth(TEST_PROJECT, TEST_HEADER, TEST_BODY)
         self.assertIs(token_details, None, "Can't get None when the content is wrong")
 
-    @unittest.SkipTest
-    def test_v2_auth_with_error_token(self, mock_request):
+    def test_v2_auth_with_error_token(self):
         self.response.status_code = requests.codes.bad_request
         self.response.json = Mock(return_value=ERROR_TOKEN_CONTENT)
         # authentication info from OpenStack Api will not contain token info
-        mock_request.return_value = self.response
         token_details = self.api_access.v2_auth(TEST_PROJECT, TEST_HEADER, TEST_BODY)
         self.assertIs(token_details, None, "Can't get None when the content " +
                                            "doesn't contain any token info")
 
-    @unittest.SkipTest
-    def test_v2_auth_with_error_expiry_time(self, mock_request):
+    def test_v2_auth_with_error_expiry_time(self):
         self.response.json = Mock(return_value=CORRECT_AUTH_CONTENT)
-        mock_request.return_value = self.response
 
         # store original parse_time method
         original_method = self.api_access.parse_time
@@ -100,54 +85,44 @@ class TestApiAccess(TestFetch):
         self.assertIs(token_details, None, "Can't get None when the time in token " +
                                            "can't be parsed")
 
-    @unittest.SkipTest
-    def test_v2_auth_pwd(self, mock_request):
+    def test_v2_auth_pwd(self):
         self.response.json = Mock(return_value=CORRECT_AUTH_CONTENT)
         # mock the authentication info from OpenStack Api
-        mock_request.return_value = self.response
         token = self.api_access.v2_auth_pwd(PROJECT)
         self.assertNotEqual(token, None, "Can't get token")
 
-    @unittest.SkipTest
-    def test_get_url(self, mock_request):
+    def test_get_url(self):
         self.response.json = Mock(return_value=GET_CONTENT)
-        mock_request.return_value = self.response
         result = self.api_access.get_url(TEST_URL, TEST_HEADER)
         # check whether it returns content message when the response is correct
         self.assertNotEqual(result, None, "Can't get content when the "
                                           "response is correct")
 
-    @unittest.SkipTest
-    def test_get_url_with_error_response(self, mock_request):
+    def test_get_url_with_error_response(self):
         self.response.status_code = requests.codes.bad_request
         self.response.json = Mock(return_value=None)
         self.response.text = "Bad request"
         # the response will be wrong
-        mock_request.return_value = self.response
         result = self.api_access.get_url(TEST_URL, TEST_HEADER)
         self.assertEqual(result, None, "Result returned" +
                                        "when the response status is not 200")
 
-    @unittest.SkipTest
     def test_get_region_url(self):
         region_url = self.api_access.get_region_url(REGION_NAME, SERVICE_NAME)
 
         self.assertNotEqual(region_url, None, "Can't get region url")
 
-    @unittest.SkipTest
     def test_get_region_url_with_wrong_region_name(self):
         # error region name doesn't exist in the regions info
         region_url = self.api_access.get_region_url(ERROR_REGION_NAME, "")
         self.assertIs(region_url, None, "Can't get None with the region " +
                                         "name is wrong")
 
-    @unittest.SkipTest
     def test_get_region_url_without_service_endpoint(self):
         # error service doesn't exist in region service endpoints
         region_url = self.api_access.get_region_url(REGION_NAME, ERROR_SERVICE_NAME)
         self.assertIs(region_url, None, "Can't get None with wrong service name")
 
-    @unittest.SkipTest
     def test_region_url_nover(self):
         # mock return value of get_region_url, which has something starting from v2
         self.api_access.get_region_url = MagicMock(return_value=REGION_URL)
@@ -155,13 +130,11 @@ class TestApiAccess(TestFetch):
         # get_region_nover will remove everything from v2
         self.assertNotIn("v2", region_url, "Can't get region url without v2 info")
 
-    @unittest.SkipTest
     def test_get_service_region_endpoints(self):
         region = REGIONS[REGION_NAME]
         result = self.api_access.get_service_region_endpoints(region, SERVICE_NAME)
         self.assertNotEqual(result, None, "Can't get service endpoint")
 
-    @unittest.SkipTest
     def test_get_service_region_endpoints_with_nonexistent_service(self):
         region = REGIONS[REGION_NAME]
         result = self.api_access.get_service_region_endpoints(region, ERROR_SERVICE_NAME)
diff --git a/app/test/fetch/api_fetch/test_api_fetch_availability_zone.py b/app/test/fetch/api_fetch/test_api_fetch_availability_zone.py
index f32be36..8314854 100644
--- a/app/test/fetch/api_fetch/test_api_fetch_availability_zone.py
+++ b/app/test/fetch/api_fetch/test_api_fetch_availability_zone.py
@@ -17,8 +17,12 @@ from test.fetch.api_fetch.test_data.token import TOKEN
 class TestApiFetchAvailabilityZones(TestFetch):
 
     def setUp(self):
+        super().setUp()
         self.configure_environment()
+
+        self._v2_auth_pwd = ApiFetchAvailabilityZones.v2_auth_pwd
         ApiFetchAvailabilityZones.v2_auth_pwd = MagicMock(return_value=TOKEN)
+
         self.fetcher = ApiFetchAvailabilityZones()
         self.set_regions_for_fetcher(self.fetcher)
 
@@ -70,3 +74,8 @@ class TestApiFetchAvailabilityZones(TestFetch):
         result = self.fetcher.get(PROJECT)
         self.fetcher.v2_auth_pwd = MagicMock(return_value=TOKEN)
         self.assertEqual(result, [], "Can't get [] when the token is invalid")
+
+    def tearDown(self):
+        super().tearDown()
+        ApiFetchAvailabilityZones.v2_auth_pwd = self._v2_auth_pwd
+        self.reset_regions_for_fetcher(self.fetcher)
diff --git a/app/test/fetch/api_fetch/test_api_fetch_host_instances.py b/app/test/fetch/api_fetch/test_api_fetch_host_instances.py
index c1c7b6e..b9d7b2a 100644
--- a/app/test/fetch/api_fetch/test_api_fetch_host_instances.py
+++ b/app/test/fetch/api_fetch/test_api_fetch_host_instances.py
@@ -17,8 +17,12 @@ from unittest.mock import MagicMock
 class TestApiFetchHostInstances(TestFetch):
 
     def setUp(self):
+        super().setUp()
         self.configure_environment()
+
+        self._v2_auth_pwd = ApiFetchHostInstances.v2_auth_pwd
         ApiFetchHostInstances.v2_auth_pwd = MagicMock(return_value=TOKEN)
+
         self.fetcher = ApiFetchHostInstances()
         self.set_regions_for_fetcher(self.fetcher)
 
@@ -81,3 +85,8 @@ class TestApiFetchHostInstances(TestFetch):
         result = self.fetcher.get(INSTANCE_FOLDER_ID)
         self.assertEqual(result, [], "Can't get [] when the host is " +
                                      "not compute node")
+
+    def tearDown(self):
+        super().tearDown()
+        ApiFetchHostInstances.v2_auth_pwd = self._v2_auth_pwd
+        self.reset_regions_for_fetcher(self.fetcher)
diff --git a/app/test/fetch/api_fetch/test_api_fetch_networks.py b/app/test/fetch/api_fetch/test_api_fetch_networks.py
index 1dc74ce..77d205b 100644
--- a/app/test/fetch/api_fetch/test_api_fetch_networks.py
+++ b/app/test/fetch/api_fetch/test_api_fetch_networks.py
@@ -17,8 +17,12 @@ from test.fetch.api_fetch.test_data.token import TOKEN
 class TestApiFetchNetworks(TestFetch):
 
     def setUp(self):
+        super().setUp()
         self.configure_environment()
+
+        self._v2_auth_pwd = ApiFetchNetworks.v2_auth_pwd
         ApiFetchNetworks.v2_auth_pwd = MagicMock(return_value=TOKEN)
+
         self.fetcher = ApiFetchNetworks()
         self.set_regions_for_fetcher(self.fetcher)
 
@@ -63,3 +67,8 @@ class TestApiFetchNetworks(TestFetch):
         self.fetcher.v2_auth_pwd = MagicMock(return_value=TOKEN)
         self.assertEqual(result, [], "Can't get [] when the " +
                                      "token is invalid")
+
+    def tearDown(self):
+        super().tearDown()
+        ApiFetchNetworks.v2_auth_pwd = self._v2_auth_pwd
+        self.reset_regions_for_fetcher(self.fetcher)
diff --git a/app/test/fetch/api_fetch/test_api_fetch_ports.py b/app/test/fetch/api_fetch/test_api_fetch_ports.py
index ad79757..355532d 100644
--- a/app/test/fetch/api_fetch/test_api_fetch_ports.py
+++ b/app/test/fetch/api_fetch/test_api_fetch_ports.py
@@ -17,8 +17,12 @@ from unittest.mock import MagicMock
 class TestApiFetchPorts(TestFetch):
 
     def setUp(self):
+        super().setUp()
         self.configure_environment()
+
+        self._v2_auth_pwd = ApiFetchPorts.v2_auth_pwd
         ApiFetchPorts.v2_auth_pwd = MagicMock(return_value=TOKEN)
+
         self.fetcher = ApiFetchPorts()
         self.set_regions_for_fetcher(self.fetcher)
 
@@ -87,3 +91,8 @@ class TestApiFetchPorts(TestFetch):
         result = self.fetcher.get(REGION_NAME)
         self.fetcher.v2_auth_pwd = MagicMock(return_value=TOKEN)
         self.assertEqual(result, [], "Can't get [] when the token is invalid")
+
+    def tearDown(self):
+        super().tearDown()
+        ApiFetchPorts.v2_auth_pwd = self._v2_auth_pwd
+        self.reset_regions_for_fetcher(self.fetcher)
diff --git a/app/test/fetch/api_fetch/test_api_fetch_project_hosts.py b/app/test/fetch/api_fetch/test_api_fetch_project_hosts.py
index 7cedf67..da3df17 100644
--- a/app/test/fetch/api_fetch/test_api_fetch_project_hosts.py
+++ b/app/test/fetch/api_fetch/test_api_fetch_project_hosts.py
@@ -18,8 +18,12 @@ from test.fetch.api_fetch.test_data.regions import REGIONS
 class TestApiFetchProjectHosts(TestFetch):
 
     def setUp(self):
+        super().setUp()
         self.configure_environment()
+
+        self._v2_auth_pwd = ApiFetchProjectHosts.v2_auth_pwd
         ApiFetchProjectHosts.v2_auth_pwd = MagicMock(return_value=TOKEN)
+
         self.fetcher = ApiFetchProjectHosts()
         self.set_regions_for_fetcher(self.fetcher)
         self.region = REGIONS[REGION_NAME]
@@ -135,3 +139,8 @@ class TestApiFetchProjectHosts(TestFetch):
         self.fetcher.v2_auth_pwd = MagicMock(return_value=[])
         result = self.fetcher.get(PROJECT_NAME)
         self.assertEqual(result, [], "Can't get [] when the token is invalid")
+
+    def tearDown(self):
+        super().tearDown()
+        ApiFetchProjectHosts.v2_auth_pwd = self._v2_auth_pwd
+        self.reset_regions_for_fetcher(self.fetcher)
diff --git a/app/test/fetch/api_fetch/test_api_fetch_projects.py b/app/test/fetch/api_fetch/test_api_fetch_projects.py
index 1db4237..959e4e5 100644
--- a/app/test/fetch/api_fetch/test_api_fetch_projects.py
+++ b/app/test/fetch/api_fetch/test_api_fetch_projects.py
@@ -18,12 +18,19 @@ from test.fetch.api_fetch.test_data.token import TOKEN
 class TestApiFetchProjects(TestFetch):
 
     def setUp(self):
+        super().setUp()
         self.configure_environment()
+
+        self._v2_auth_pwd = ApiFetchProjects.v2_auth_pwd
         ApiFetchProjects.v2_auth_pwd = MagicMock(return_value=TOKEN)
+
         self.fetcher = ApiFetchProjects()
         self.set_regions_for_fetcher(self.fetcher)
         self.region = REGIONS[REGION_NAME]
-        self.fetcher.get_region_url_nover = MagicMock(return_value=REGION_URL_NOVER)
+
+        self._get_region_url_nover = self.fetcher.get_region_url_nover
+        self.fetcher.get_region_url_nover = \
+            MagicMock(return_value=REGION_URL_NOVER)
 
     def test_get_for_region(self):
         # mock request endpoint
@@ -118,3 +125,9 @@ class TestApiFetchProjects(TestFetch):
                                   test_case["token"],
                                   test_case["expected_result"],
                                   test_case["err_msg"])
+
+    def tearDown(self):
+        super().tearDown()
+        ApiFetchProjects.v2_auth_pwd = self._v2_auth_pwd
+        self.reset_regions_for_fetcher(self.fetcher)
+        self.fetcher.get_region_url_nover = self._get_region_url_nover
diff --git a/app/test/fetch/api_fetch/test_api_fetch_regions.py b/app/test/fetch/api_fetch/test_api_fetch_regions.py
index 7d1c16a..52bceae 100644
--- a/app/test/fetch/api_fetch/test_api_fetch_regions.py
+++ b/app/test/fetch/api_fetch/test_api_fetch_regions.py
@@ -18,7 +18,11 @@ from unittest.mock import MagicMock
 class TestApiFetchRegions(TestFetch):

 

     def setUp(self):

+        super().setUp()

+

+        self._v2_auth_pwd = ApiFetchRegions.v2_auth_pwd

         ApiFetchRegions.v2_auth_pwd = MagicMock(return_value=TOKEN)

+

         self.configure_environment()

 

     def test_get(self):

@@ -39,3 +43,7 @@ class TestApiFetchRegions(TestFetch):
 

         ApiFetchRegions.v2_auth_pwd = MagicMock(return_value=TOKEN)

         self.assertEqual(ret, [], "Can't get [] when the token is invalid")

+

+    def tearDown(self):

+        super().tearDown()

+        ApiFetchRegions.v2_auth_pwd = self._v2_auth_pwd