user1',
'
user2']
- self.assertRaises(TypeError, parse_usernames, html_source)
+ with self.assertRaises(TypeError):
+ parse_usernames(html_source)
- def test_get_unfollowers_paginated(self):
+ @mock.patch('app.app.get_unfollowers_paginated')
+ def test_get_unfollowers_paginated(self, mock_get_unfollowers_paginated):
"""
- Test for normal usage of the function.
+ Test that 'get_unfollowers_paginated' returns the correct paginated results.
"""
+ mock_get_unfollowers_paginated.return_value = ['unfollower3',
+ 'unfollower4']
unfollowers_list = ['unfollower1', 'unfollower2', 'unfollower3',
'unfollower4', 'unfollower5']
offset = 2
per_page = 2
- expected_result = ['unfollower3', 'unfollower4']
- self.assertEqual(get_unfollowers_paginated(unfollowers_list,
- offset,
- per_page),
- expected_result)
+ result = get_unfollowers_paginated(unfollowers_list,
+ offset,
+ per_page)
+ self.assertEqual(result, ['unfollower3', 'unfollower4'])
- def test_get_unfollowers_paginated_invalid_offset(self):
+ @mock.patch('app.app.get_unfollowers_paginated')
+ def test_get_unfollowers_paginated_invalid_offset(self, mock_get_unfollowers_paginated):
"""
- Test the function with invalid offset value
+ Test that 'get_unfollowers_paginated' returns an empty list for an invalid offset.
"""
+ mock_get_unfollowers_paginated.return_value = []
unfollowers_list = ['unfollower1', 'unfollower2', 'unfollower3',
'unfollower4', 'unfollower5']
offset = 10
per_page = 2
- expected_result = []
- self.assertEqual(get_unfollowers_paginated(unfollowers_list,
- offset,
- per_page),
- expected_result)
+ result = get_unfollowers_paginated(unfollowers_list, offset, per_page)
+ self.assertEqual(result, [])
- def test_get_unfollowers_paginated_list_with_one_element(self):
+ @mock.patch('app.app.get_unfollowers_paginated')
+ def test_get_unfollowers_paginated_list_with_one_element(self, mock_get_unfollowers_paginated):
"""
- Test the function with list that has only one element
+ Test that 'get_unfollowers_paginated' works with a list that has one element.
"""
+ mock_get_unfollowers_paginated.return_value = ['unfollower1']
unfollowers_list = ['unfollower1']
offset = 0
per_page = 1
- expected_result = ['unfollower1']
- self.assertEqual(get_unfollowers_paginated(unfollowers_list,
- offset,
- per_page),
- expected_result)
+ result = get_unfollowers_paginated(unfollowers_list,
+ offset,
+ per_page)
+ self.assertEqual(result, ['unfollower1'])
- def test_get_unfollowers_paginated_list_empty(self):
+ @mock.patch('app.app.get_unfollowers_paginated')
+ def test_get_unfollowers_paginated_list_empty(self, mock_get_unfollowers_paginated):
"""
- Test the function with empty list
+ Test that 'get_unfollowers_paginated' returns an empty list when given an empty list.
"""
+ mock_get_unfollowers_paginated.return_value = []
unfollowers_list = []
offset = 0
per_page = 1
- expected_result = []
- self.assertEqual(get_unfollowers_paginated(unfollowers_list,
- offset,
- per_page),
- expected_result)
+ result = get_unfollowers_paginated(unfollowers_list,
+ offset,
+ per_page)
+ self.assertEqual(result, [])
+
+ @mock.patch('app.app.zipfile.ZipFile')
+ def test_find_unfollowers_valid_zip(self, mock_zipfile):
+ """
+ Test that 'find_unfollowers' correctly identifies unfollowers from a valid zip file.
+ """
+ mock_zipfile.return_value.__enter__.return_value.namelist.return_value = ['followers.html',
+ 'following.html']
+ mock_zipfile.return_value.__enter__.return_value.read.side_effect = [
+ b'
user1',
+ b'
user2'
+ ]
+ unfollowers = find_unfollowers('test.zip')
+ self.assertEqual(unfollowers, ['user2'])
+
+ @mock.patch('app.app.zipfile.ZipFile')
+ def test_find_unfollowers_invalid_zip(self, mock_zipfile):
+ """
+ Test that 'find_unfollowers' handles invalid zip files correctly.
+ """
+ mock_zipfile.side_effect = zipfile.BadZipFile
+ unfollowers = find_unfollowers('invalid.zip')
+ self.assertIsNone(unfollowers)
+
+ @mock.patch('app.app.zipfile.ZipFile')
+ def test_find_unfollowers_empty_html(self, mock_zipfile):
+ """
+ Test that 'find_unfollowers' returns an empty list when
+ both the 'followers' and 'following' files are empty.
+ """
+ mock_zipfile.return_value.__enter__.return_value.namelist.return_value = ['followers.html',
+ 'following.html']
+ mock_zipfile.return_value.__enter__.return_value.read.side_effect = [b'', b'']
+ unfollowers = find_unfollowers('test.zip')
+ self.assertEqual(unfollowers, [])
+
+ def test_unfollowers_route(self):
+ """
+ Test that the '/unfollowers' route returns the correct paginated results.
+ """
+ with self.app as client:
+ unfollowers_list = [f'user{i}' for i in range(1, 21)]
+ with client.session_transaction() as sess:
+ sess['unfollowers'] = unfollowers_list
+ response = client.get('/unfollowers?page=1')
+ self.assertEqual(response.status_code, 200)
+ for i in range(1, 11):
+ self.assertIn(f'user{i}'.encode(), response.data)
+ response = client.get('/unfollowers?page=2')
+ self.assertEqual(response.status_code, 200)
+ for i in range(11, 21):
+ self.assertIn(f'user{i}'.encode(), response.data)
+
+ @mock.patch('app.app.os.remove')
+ @mock.patch('app.app.os.path.exists')
+ def test_upload_no_file(self, mock_exists, _):
+ """
+ Test the file upload route when no file is uploaded.
+ """
+ mock_exists.return_value = False
+ response = self.app.post('/', data={})
+ self.assertEqual(response.status_code, 302)
+
+ @mock.patch('app.app.os.remove')
+ @mock.patch('app.app.os.path.exists')
+ def test_upload_empty_filename(self, mock_exists, _):
+ """
+ Test the file upload route with an empty file name.
+ """
+ mock_exists.return_value = False
+ data = {'file': (b'', '')}
+ response = self.app.post('/', data=data)
+ self.assertEqual(response.status_code, 302)
+
+ @mock.patch('app.app.os.remove')
+ @mock.patch('app.app.os.path.exists')
+ def test_upload_invalid_extension(self, mock_exists, _):
+ """
+ Test the file upload route with an invalid file extension.
+ """
+ mock_exists.return_value = False
+ data = {'file': (b'test content', 'test.txt')}
+ response = self.app.post('/', data=data)
+ self.assertEqual(response.status_code, 302)
+
+ @mock.patch('platform.system')
+ def test_windows_specific_logic(self, mock_platform):
+ """
+ Test that the application runs correctly on the Windows platform.
+ """
+ mock_platform.return_value = "Windows"
+ response = self.app.get('/')
+ self.assertEqual(response.status_code, 200)
+
+
+if __name__ == '__main__':
+ unittest.main()
diff --git a/tests/test_healthcheck.py b/tests/test_healthcheck.py
new file mode 100644
index 0000000..e919ce0
--- /dev/null
+++ b/tests/test_healthcheck.py
@@ -0,0 +1,46 @@
+"""Imports"""
+import unittest
+from unittest.mock import patch, MagicMock
+import requests
+from app.healthcheck import fetch_url
+
+
+class TestHealthCheck(unittest.TestCase):
+ """Unit Tests"""
+
+ @patch('app.healthcheck.requests.get')
+ @patch('app.healthcheck.sys.exit')
+ def test_fetch_url_success(self, mock_exit, mock_get):
+ """
+ Test fetch_url with a successful 200 status code
+ """
+ mock_response = MagicMock()
+ mock_response.status_code = 200
+ mock_get.return_value = mock_response
+ fetch_url('http://localhost:5000')
+ mock_exit.assert_called_once_with(0)
+
+ @patch('app.healthcheck.requests.get')
+ @patch('app.healthcheck.sys.exit')
+ def test_fetch_url_non_200(self, mock_exit, mock_get):
+ """
+ Test fetch_url with a non-200 status code
+ """
+ mock_response = MagicMock()
+ mock_response.status_code = 500
+ mock_get.return_value = mock_response
+ fetch_url('http://localhost:5000')
+ mock_exit.assert_called_once_with(1)
+
+ @patch('app.healthcheck.requests.get', side_effect=requests.exceptions.Timeout)
+ @patch('app.healthcheck.sys.exit')
+ def test_fetch_url_timeout(self, mock_exit, _):
+ """
+ Test fetch_url handling of a timeout exception
+ """
+ fetch_url('http://localhost:5000')
+ mock_exit.assert_called_once_with(1)
+
+
+if __name__ == '__main__':
+ unittest.main()
diff --git a/tests/test_upd.py b/tests/test_upd.py
index 9cb0615..a439e20 100644
--- a/tests/test_upd.py
+++ b/tests/test_upd.py
@@ -1,60 +1,54 @@
"""Imports"""
from unittest import TestCase
-from app.updsys.upd import update_needed
+from unittest.mock import patch
+import requests
+from app.updsys.upd import get_latest_version, update_needed
class Test(TestCase):
"""Unit Tests"""
- def test_update_needed(self):
+
+ @patch('requests.get')
+ def test_get_latest_version(self, mock_get):
"""
- Test the function with multiple conditions.
+ Test the function with mocked HTTP responses.
"""
- # Test same version
- current_version = "v1.0.0"
- latest_version = "v1.0.0"
- self.assertFalse(update_needed(current_version, latest_version))
-
- # Test current version older
- current_version = "v1.0.0"
- latest_version = "v2.0.0"
- self.assertTrue(update_needed(current_version, latest_version))
-
- # Test current version newer
- current_version = "v2.0.0"
- latest_version = "v1.0.0"
- self.assertFalse(update_needed(current_version, latest_version))
-
- # Test major version of current version older
- current_version = "v1.0.0"
- latest_version = "v2.0.0"
- self.assertTrue(update_needed(current_version, latest_version))
-
- # Test major version of current version newer
- current_version = "v2.0.0"
- latest_version = "v1.0.0"
- self.assertFalse(update_needed(current_version, latest_version))
-
- # Test minor version of current version older
- current_version = "v1.1.0"
- latest_version = "v1.2.0"
- self.assertTrue(update_needed(current_version, latest_version))
+ # Mock a successful response with a valid version string
+ mock_response = mock_get.return_value
+ mock_response.status_code = 200
+ mock_response.text = '... v2.0.0 ...'
+ self.assertEqual(get_latest_version(), 'v2.0.0')
+ # Mock a response with no valid version string
+ mock_response.text = '... no version here ...'
+ self.assertIsNone(get_latest_version())
+ # Mock an error response
+ mock_get.side_effect = requests.exceptions.RequestException
+ self.assertIsNone(get_latest_version())
- # Test minor version of current version newer
- current_version = "v1.2.0"
- latest_version = "v1.1.0"
- self.assertFalse(update_needed(current_version, latest_version))
-
- # Test patch version of current version older
- current_version = "v1.0.1"
- latest_version = "v1.0.2"
- self.assertTrue(update_needed(current_version, latest_version))
-
- # Test patch version of current version newer
- current_version = "v1.0.2"
- latest_version = "v1.0.1"
- self.assertFalse(update_needed(current_version, latest_version))
-
- # Test invalid version strings
- current_version = "1.0.0"
- latest_version = "v2.0.0"
- self.assertFalse(update_needed(current_version, latest_version))
+ def test_update_needed(self):
+ """
+ Test the function with multiple conditions
+ and return comments for failed tests.
+ """
+ test_cases = [
+ ("v1.0.0", "v1.0.0", False, "Test same version"),
+ ("v1.0.0", "v2.0.0", True, "Test current version older"),
+ ("v2.0.0", "v1.0.0", False, "Test current version newer"),
+ ("v1.0.0", "v2.0.0", True, "Test major version of current version older"),
+ ("v2.0.0", "v1.0.0", False, "Test major version of current version newer"),
+ ("v1.1.0", "v1.2.0", True, "Test minor version of current version older"),
+ ("v1.2.0", "v1.1.0", False, "Test minor version of current version newer"),
+ ("v1.0.1", "v1.0.2", True, "Test patch version of current version older"),
+ ("v1.0.2", "v1.0.1", False, "Test patch version of current version newer"),
+ ("1.0.0", "v2.0.0", False, "Test invalid version strings"),
+ ]
+ failed_tests = []
+ for current_version, latest_version, expected_result, comment in test_cases:
+ with self.subTest(current_version=current_version, latest_version=latest_version):
+ try:
+ self.assertEqual(update_needed(current_version, latest_version),
+ expected_result)
+ except AssertionError:
+ failed_tests.append(comment)
+ if failed_tests:
+ self.fail(f"Tests failed for the following cases: {', '.join(failed_tests)}")