chore: bump deps and remove mock library (#46)

* chore: bump deps and remove mock library

* Rebase

* Rebase

* fix: correct tests

Author: Justintime50

.flake8

@@ -1,2 +1,3 @@
 [flake8]
 max-line-length = 120
+extend-ignore = E203

.github/workflows/build.yml

@@ -20,7 +20,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        pythonversion: ["3.6", "3.7", "3.8", "3.9"]
+        pythonversion: ["3.7", "3.8", "3.9"]
     steps:
       - name: Checkout Repository
         uses: actions/checkout@v2

CHANGELOG.md

@@ -8,6 +8,7 @@
     * Previously a webhook secret was required; now, Harvey will run Pipelines without a webhook secret (bypassing decoding and validation of the previously non-existent secret) if there is no `WEBHOOK_SECRET` variable set
     * Additional refactor surrounding how we validate webhook secrets
 * Fixed the container healthcheck when using the compose workflow - this was accomplished by making the compose and non-compose container names uniform
+* Bumps dependencies (Flask 1 to Flask 2) and now requires Python 3.7. Also removes the `mock` library in favor of the builtin `unittest.mock` library
 * Various code refactors and bug fixes
 
 ## v0.12.0 (2021-08-17)

harvey/pipelines.py

@@ -107,8 +107,8 @@ def open_project_config(webhook):
         # within a JSON file in the repo
         try:
             filename = os.path.join(Global.PROJECTS_PATH, Global.repo_full_name(webhook), 'harvey.json')
-            with open(filename, 'r') as file:
-                config = json.loads(file.read())
+            with open(filename, 'r') as config_file:
+                config = json.loads(config_file.read())
                 print(json.dumps(config, indent=4))
             return config
         except FileNotFoundError:

setup.py

@@ -4,17 +4,16 @@
     long_description = fh.read()
 
 REQUIREMENTS = [
-    'flask == 1.*',  # TODO: bump to v2 after thorough testing
+    'flask == 2.*',
     'requests == 2.*',
     'requests_unixsocket == 0.2.*',
     'slackclient == 2.*',
-    'python-dotenv == 0.17.*',
+    'python-dotenv == 0.19.*',
 ]
 
 DEV_REQUIREMENTS = [
     'coveralls == 3.*',
     'flake8',
-    'mock == 4.*',
     'pytest == 6.*',
     'pytest-cov == 2.*',
 ]
@@ -41,5 +40,5 @@
     entry_points={
         'console_scripts': ['harvey-ci=harvey.app:main'],
     },
-    python_requires='>=3.6',
+    python_requires='>=3.7',
 )

test/unit/conftest.py

@@ -1,5 +1,6 @@
+from unittest.mock import MagicMock, Mock
+
 import harvey.app as app
-import mock
 import pytest
 
 
@@ -33,7 +34,7 @@ def mock_webhook(branch='main'):
 
 @pytest.fixture
 def mock_webhook_object(branch='main'):
-    webhook = mock.MagicMock()
+    webhook = MagicMock()
     webhook.remote_addr = '192.30.252.0'  # A real GitHub IP address
     webhook.json = {
         "ref": f'refs/heads/{branch}',
@@ -61,8 +62,8 @@ def mock_project_path():
 
 # TODO: Move this to a fixture
 def mock_response(status=201, json_data={'mock': 'json'}):
-    response = mock.MagicMock()
-    response.json = mock.MagicMock(
+    response = MagicMock()
+    response.json = MagicMock(
         return_value=json_data,
     )
     response.status_code = status
@@ -81,8 +82,8 @@ def mock_config(pipeline='deploy', language='python', version='3.9', compose=Non
 
 # TODO: Move this to a fixture
 def mock_response_container(status=200, dead=False, paused=False, restarting=False, running=True):
-    response = mock.Mock()
-    response.json = mock.Mock(
+    response = Mock()
+    response.json = Mock(
         return_value={
             'State': {
                 'Dead': dead,

test/unit/test_app.py

@@ -1,5 +1,5 @@
 import harvey.app as app
-import mock
+from unittest.mock import patch
 import pytest
 
 
@@ -17,15 +17,15 @@ def test_routes_are_reachable_get(mock_client, route):
     assert response.status_code == 200
 
 
-@mock.patch('harvey.webhooks.Webhook.parse_webhook')
+@patch('harvey.webhooks.Webhook.parse_webhook')
 def test_start_pipeline(mock_parse_webhook):
     # TODO: Long-term, test the status_code and logic
     app.start_pipeline()
 
     mock_parse_webhook.assert_called_once()
 
 
-@mock.patch('harvey.webhooks.Webhook.parse_webhook')
+@patch('harvey.webhooks.Webhook.parse_webhook')
 def test_start_pipeline_compose(mock_parse_webhook):
     # TODO: Long-term, test the status_code and logic
     app.start_pipeline_compose()

test/unit/test_containers.py

@@ -1,25 +1,25 @@
 from test.unit.conftest import mock_response  # Remove once fixtures are fixed
+from unittest.mock import patch
 
-import mock
 from harvey.containers import Container
 from harvey.globals import Global
 
 
-@mock.patch('requests.post', return_value=mock_response(status=201))
+@patch('requests.post', return_value=mock_response(status=201))
 def test_create_container(mock_request, mock_tag):
     container = Container.create_container(mock_tag)
 
     mock_request.assert_called_once_with(
         f'{Global.BASE_URL}containers/create',
         params={'name': mock_tag},
         json={'Image': mock_tag},
-        headers=Global.JSON_HEADERS
+        headers=Global.JSON_HEADERS,
     )
     assert container.json() == {'mock': 'json'}
     assert container.status_code == 201
 
 
-@mock.patch('requests.post', return_value=mock_response(status=204))
+@patch('requests.post', return_value=mock_response(status=204))
 def test_start_container(mock_request, mock_tag):
     container = Container.start_container(mock_tag)
 
@@ -28,7 +28,7 @@ def test_start_container(mock_request, mock_tag):
     assert container.status_code == 204
 
 
-@mock.patch('requests.post', return_value=mock_response(status=204))
+@patch('requests.post', return_value=mock_response(status=204))
 def test_stop_container(mock_request, mock_tag):
     container = Container.stop_container(mock_tag)
 
@@ -37,7 +37,7 @@ def test_stop_container(mock_request, mock_tag):
     assert container.status_code == 204
 
 
-@mock.patch('requests.get', return_value=mock_response(status=200))
+@patch('requests.get', return_value=mock_response(status=200))
 def test_inspect_container(mock_request, mock_tag):
     container = Container.inspect_container(mock_tag)
 
@@ -46,7 +46,7 @@ def test_inspect_container(mock_request, mock_tag):
     assert container.status_code == 200
 
 
-@mock.patch('requests.get', return_value=mock_response(status=200))
+@patch('requests.get', return_value=mock_response(status=200))
 def test_list_containers(mock_request, mock_tag):
     container = Container.list_containers()
 
@@ -55,17 +55,17 @@ def test_list_containers(mock_request, mock_tag):
     assert container.status_code == 200
 
 
-@mock.patch('requests.get', return_value=mock_response(status=200))
+@patch('requests.get', return_value=mock_response(status=200))
 def test_inspect_container_logs(mock_request):
     Container.inspect_container_logs(1)
 
     mock_request.assert_called_once_with(
         f'{Global.BASE_URL}containers/1/logs',
-        params={'stdout': True, 'stderr': True}
+        params={'stdout': True, 'stderr': True},
     )
 
 
-@mock.patch('requests.post', return_value=mock_response(status=200))
+@patch('requests.post', return_value=mock_response(status=200))
 def test_wait_container(mock_request, mock_tag):
     container = Container.wait_container(mock_tag)
 
@@ -74,14 +74,14 @@ def test_wait_container(mock_request, mock_tag):
     assert container.status_code == 200
 
 
-@mock.patch('requests.delete', return_value=mock_response(status=204))
+@patch('requests.delete', return_value=mock_response(status=204))
 def test_remove_container(mock_request, mock_tag):
     container = Container.remove_container(mock_tag)
 
     mock_request.assert_called_once_with(
         f'{Global.BASE_URL}containers/{mock_tag}',
         json={'force': True},
-        headers=Global.JSON_HEADERS
+        headers=Global.JSON_HEADERS,
     )
     assert container.json() == {'mock': 'json'}
     assert container.status_code == 204

test/unit/test_git.py

@@ -1,68 +1,68 @@
 import subprocess
+from unittest.mock import patch
 
-import mock
 from harvey.git import Git
 
 
-@mock.patch('os.path.exists', return_value=True)
-@mock.patch('harvey.git.Git.pull_repo')
+@patch('os.path.exists', return_value=True)
+@patch('harvey.git.Git.pull_repo')
 def test_update_git_repo_path_exists(mock_pull_repo, mock_path_exists, mock_project_path, mock_webhook):  # noqa
     Git.update_git_repo(mock_webhook)
 
     mock_pull_repo.assert_called_once_with(mock_project_path, mock_webhook)
 
 
-@mock.patch('os.path.exists', return_value=False)
-@mock.patch('harvey.git.Git.clone_repo')
-def test_update_git_repo_path_does_not_exist(mock_clone_repo, mock_path_exists, mock_project_path, mock_webhook):  # noqa
+@patch('os.path.exists', return_value=False)
+@patch('harvey.git.Git.clone_repo')
+def test_update_git_repo_path_does_not_exist(mock_clone_repo, mock_path_exists, mock_project_path, mock_webhook):
     Git.update_git_repo(mock_webhook)
 
     mock_clone_repo.assert_called_once_with(mock_project_path, mock_webhook)
 
 
-@mock.patch('subprocess.check_output')
+@patch('subprocess.check_output')
 def test_clone_repo(mock_subprocess, mock_project_path, mock_webhook):
     # TODO: Mock the subprocess better to ensure it does what it's supposed to
     Git.clone_repo(mock_project_path, mock_webhook)
 
     mock_subprocess.assert_called_once()
 
 
-@mock.patch('harvey.utils.Utils.kill')
-@mock.patch('subprocess.check_output', side_effect=subprocess.TimeoutExpired(cmd=subprocess.check_output, timeout=0.1))  # noqa
-def test_clone_repo_subprocess_timeout(mock_subprocess, mock_utils_kill, mock_project_path, mock_webhook):  # noqa
+@patch('harvey.utils.Utils.kill')
+@patch('subprocess.check_output', side_effect=subprocess.TimeoutExpired(cmd=subprocess.check_output, timeout=0.1))
+def test_clone_repo_subprocess_timeout(mock_subprocess, mock_utils_kill, mock_project_path, mock_webhook):
     Git.clone_repo(mock_project_path, mock_webhook)
 
     mock_utils_kill.assert_called_once()
 
 
-@mock.patch('harvey.utils.Utils.kill')
-@mock.patch('subprocess.check_output', side_effect=subprocess.CalledProcessError(returncode=1, cmd=subprocess.check_output))  # noqa
-def test_clone_repo_process_error(mock_subprocess, mock_utils_kill, mock_project_path, mock_webhook):  # noqa
+@patch('harvey.utils.Utils.kill')
+@patch('subprocess.check_output', side_effect=subprocess.CalledProcessError(returncode=1, cmd=subprocess.check_output))
+def test_clone_repo_process_error(mock_subprocess, mock_utils_kill, mock_project_path, mock_webhook):
     Git.clone_repo(mock_project_path, mock_webhook)
 
     mock_utils_kill.assert_called_once()
 
 
-@mock.patch('subprocess.check_output')
+@patch('subprocess.check_output')
 def test_pull_repo(mock_subprocess, mock_project_path, mock_webhook):
     # TODO: Mock the subprocess better to ensure it does what it's supposed to
     Git.pull_repo(mock_project_path, mock_webhook)
 
     mock_subprocess.assert_called_once()
 
 
-@mock.patch('harvey.utils.Utils.kill')
-@mock.patch('subprocess.check_output', side_effect=subprocess.TimeoutExpired(cmd=subprocess.check_output, timeout=0.1))  # noqa
-def test_pull_repo_subprocess_timeout(mock_subprocess, mock_utils_kill, mock_project_path, mock_webhook):  # noqa
+@patch('harvey.utils.Utils.kill')
+@patch('subprocess.check_output', side_effect=subprocess.TimeoutExpired(cmd=subprocess.check_output, timeout=0.1))
+def test_pull_repo_subprocess_timeout(mock_subprocess, mock_utils_kill, mock_project_path, mock_webhook):
     Git.pull_repo(mock_project_path, mock_webhook)
 
     mock_utils_kill.assert_called_once()
 
 
-@mock.patch('harvey.utils.Utils.kill')
-@mock.patch('subprocess.check_output', side_effect=subprocess.CalledProcessError(returncode=1, cmd=subprocess.check_output))  # noqa
-def test_pull_repo_process_error(mock_subprocess, mock_utils_kill, mock_project_path, mock_webhook):  # noqa
+@patch('harvey.utils.Utils.kill')
+@patch('subprocess.check_output', side_effect=subprocess.CalledProcessError(returncode=1, cmd=subprocess.check_output))
+def test_pull_repo_process_error(mock_subprocess, mock_utils_kill, mock_project_path, mock_webhook):
     Git.pull_repo(mock_project_path, mock_webhook)
 
     mock_utils_kill.assert_called_once()

test/unit/test_images.py

@@ -1,13 +1,13 @@
 from test.unit.conftest import mock_response  # Remove once fixtures are fixed
+from unittest.mock import patch
 
-import mock
 import pytest
 from harvey.globals import Global
 from harvey.images import Image
 
 
-@pytest.mark.parametrize('context', [('test'), (None)])
-@mock.patch('subprocess.check_output')
+@pytest.mark.parametrize('context', ['test', (None)])
+@patch('subprocess.check_output')
 def test_build_image(mock_subprocess, context, mock_webhook):
     # TODO: Mock the subprocess better to ensure it does what it's supposed to
     Image.build_image(
@@ -17,32 +17,32 @@ def test_build_image(mock_subprocess, context, mock_webhook):
             'version': '3.9',
         },
         mock_webhook,
-        context
+        context,
     )
 
     mock_subprocess.assert_called_once()
 
 
-@mock.patch('requests.get', return_value=mock_response(201))
+@patch('requests.get', return_value=mock_response(201))
 def test_retrieve_image(mock_request):
     Image.retrieve_image(1)
 
     mock_request.assert_called_once_with(Global.BASE_URL + 'images/1/json')
 
 
-@mock.patch('requests.get', return_value=mock_response(201))
+@patch('requests.get', return_value=mock_response(201))
 def test_retrieve_all_images(mock_request):
     Image.retrieve_all_images()
 
     mock_request.assert_called_once_with(Global.BASE_URL + 'images/json')
 
 
-@mock.patch('requests.delete', return_value=mock_response(201))
+@patch('requests.delete', return_value=mock_response(201))
 def test_remove_image(mock_request):
     Image.remove_image(1)
 
     mock_request.assert_called_once_with(
         Global.BASE_URL + 'images/1',
         json={'force': True},
-        headers=Global.JSON_HEADERS
+        headers=Global.JSON_HEADERS,
     )