From 410776542724dc0ff4b654230572585469ec8a2a Mon Sep 17 00:00:00 2001 From: guanana Date: Tue, 20 Jan 2026 19:45:09 +0000 Subject: [PATCH 1/3] Add more tests --- tests/test_assets.py | 213 +++++++++++++++++++++++++++++++++++++++++ tests/test_folders.py | 102 ++++++++++++++++++++ tests/test_misc.py | 114 ++++++++++++++++++++++ tests/test_partners.py | 92 ++++++++++++++++++ tests/test_people.py | 110 +++++++++++++++++++++ tests/test_search.py | 100 +++++++++++++++++++ tests/test_stacks.py | 89 +++++++++++++++++ tests/test_tags.py | 119 +++++++++++++++++++++++ tests/test_trash.py | 68 +++++++++++++ tests/test_users.py | 112 ++++++++++++++++++++++ 10 files changed, 1119 insertions(+) create mode 100644 tests/test_assets.py create mode 100644 tests/test_folders.py create mode 100644 tests/test_misc.py create mode 100644 tests/test_partners.py create mode 100644 tests/test_people.py create mode 100644 tests/test_search.py create mode 100644 tests/test_stacks.py create mode 100644 tests/test_tags.py create mode 100644 tests/test_trash.py create mode 100644 tests/test_users.py diff --git a/tests/test_assets.py b/tests/test_assets.py new file mode 100644 index 0000000..82aac49 --- /dev/null +++ b/tests/test_assets.py @@ -0,0 +1,213 @@ +import unittest +from unittest.mock import patch, MagicMock +import requests +import os +import tempfile +from immich_lib.api.assets import AssetsMixin + + +# Create a test class that inherits from AssetsMixin to create tests +class TestAssetsMixin(unittest.TestCase): + def setUp(self): + # Create a mock client instance + self.server_url = "http://localhost:2283" + self.api_key = "test-api-key" + # Create a minimal mock client that inherits from AssetsMixin + self.client = type("MockClient", (AssetsMixin,), {})() + self.client.server_url = self.server_url + self.client.api_url = f"{self.server_url}/api" + self.client.headers = {"x-api-key": self.api_key} + self.client.session = MagicMock() + + @patch("requests.Session.request") + def test_list_assets_success(self, mock_request): + """Test successful list assets with various filter parameters""" + mock_response = MagicMock() + mock_response.status_code = 200 + mock_response.headers = {"Content-Type": "application/json"} + mock_response.json.return_value = { + "assets": { + "items": [ + {"id": "asset1", "originalFileName": "test1.jpg"}, + {"id": "asset2", "originalFileName": "test2.jpg"}, + ] + } + } + mock_request.return_value = mock_response + + # Test with no filters + result = self.client.list_assets() + self.assertEqual(len(result), 2) + self.assertEqual(result[0]["id"], "asset1") + + # Test with filter parameters + result = self.client.list_assets(isFavorite=True, type="IMAGE") + self.assertEqual(len(result), 2) + + @patch("requests.Session.request") + def test_list_assets_empty_response(self, mock_request): + """Test list assets with empty response""" + mock_response = MagicMock() + mock_response.status_code = 200 + mock_response.headers = {"Content-Type": "application/json"} + mock_response.json.return_value = {"assets": {"items": []}} + mock_request.return_value = mock_response + + result = self.client.list_assets() + self.assertEqual(result, []) + + @patch("requests.Session.request") + def test_list_assets_no_assets_key(self, mock_request): + """Test list assets with missing assets key""" + mock_response = MagicMock() + mock_response.status_code = 200 + mock_response.headers = {"Content-Type": "application/json"} + mock_response.json.return_value = {"other": "data"} + mock_request.return_value = mock_response + + result = self.client.list_assets() + self.assertEqual(result, []) + + @patch("requests.Session.request") + def test_get_asset_info_success(self, mock_request): + """Test successful get asset info""" + mock_response = MagicMock() + mock_response.status_code = 200 + mock_response.headers = {"Content-Type": "application/json"} + mock_response.json.return_value = { + "id": "test123", + "originalFileName": "test.jpg", + } + mock_request.return_value = mock_response + + result = self.client.get_asset_info("test123") + self.assertEqual(result["id"], "test123") + + @patch("requests.Session.request") + def test_get_asset_info_error(self, mock_request): + """Test get asset info with error response""" + mock_response = MagicMock() + mock_response.status_code = 404 + mock_response.headers = {"Content-Type": "application/json"} + mock_response.json.return_value = {"message": "Asset not found"} + mock_response.raise_for_status.side_effect = requests.exceptions.HTTPError( + "Not Found", response=mock_response + ) + mock_request.return_value = mock_response + + with self.assertRaises(requests.exceptions.HTTPError): + self.client.get_asset_info("nonexistent") + + @patch("requests.Session.request") + def test_update_asset_success(self, mock_request): + """Test successful asset update""" + mock_response = MagicMock() + mock_response.status_code = 200 + mock_response.headers = {"Content-Type": "application/json"} + mock_response.json.return_value = {"id": "test123", "isFavorite": True} + mock_request.return_value = mock_response + + result = self.client.update_asset("test123", isFavorite=True) + self.assertEqual(result["isFavorite"], True) + + @patch("requests.Session.request") + def test_delete_assets_success(self, mock_request): + """Test successful asset deletion""" + mock_response = MagicMock() + mock_response.status_code = 204 + mock_request.return_value = mock_response + + result = self.client.delete_assets(["asset1", "asset2"]) + self.assertTrue(result) + + @patch("requests.Session.request") + def test_delete_assets_error(self, mock_request): + """Test asset deletion with error""" + mock_response = MagicMock() + mock_response.status_code = 500 + mock_response.raise_for_status.side_effect = requests.exceptions.HTTPError( + "Internal Server Error", response=mock_response + ) + mock_request.return_value = mock_response + + with self.assertRaises(requests.exceptions.HTTPError): + self.client.delete_assets(["asset1"]) + + @patch("requests.Session.request") + def test_download_asset_success_with_path(self, mock_request): + """Test successful asset download with file path""" + # Mock response for downloading the asset + mock_response = MagicMock() + mock_response.status_code = 200 + mock_response.headers = {"Content-Type": "image/jpeg", "content-length": "1024"} + mock_response.iter_content.return_value = [b"test data"] + + # Mock file operations + with patch("builtins.open", MagicMock()) as mock_open: + with patch("tqdm") as mock_tqdm: + mock_tqdm_instance = MagicMock() + mock_tqdm.return_value.__enter__.return_value = mock_tqdm_instance + + mock_request.return_value = mock_response + + # Create temporary directory and file + with tempfile.TemporaryDirectory() as tmpdir: + test_file = os.path.join(tmpdir, "test.jpg") + result = self.client.download_asset("asset123", test_file) + + # Should return True to indicate success + self.assertTrue(result) + + @patch("requests.Session.request") + def test_download_asset_success_no_path(self, mock_request): + """Test asset download without file path (returns response)""" + mock_response = MagicMock() + mock_response.status_code = 200 + mock_response.headers = {"Content-Type": "image/jpeg"} + mock_request.return_value = mock_response + + result = self.client.download_asset("asset123") + self.assertEqual(result, mock_response) + + @patch("requests.Session.request") + def test_view_asset_success(self, mock_request): + """Test successful asset thumbnail view""" + mock_response = MagicMock() + mock_response.status_code = 200 + mock_response.headers = {"Content-Type": "image/jpeg"} + mock_request.return_value = mock_response + + result = self.client.view_asset("asset123") + self.assertEqual(result, mock_response) + + @patch("requests.Session.request") + def test_upload_asset_success(self, mock_request): + """Test successful asset upload""" + mock_response = MagicMock() + mock_response.status_code = 200 + mock_response.headers = {"Content-Type": "application/json"} + mock_response.json.return_value = { + "id": "uploaded123", + "originalFileName": "new.jpg", + } + mock_request.return_value = mock_response + + # Create a temporary file for testing + with tempfile.NamedTemporaryFile(mode="w", delete=False) as tmp_file: + tmp_file.write("test content") + tmp_file_path = tmp_file.name + + try: + # Mock file open operation + with patch("builtins.open", MagicMock()): + mock_request.return_value = mock_response + + result = self.client.upload_asset(tmp_file_path, isFavorite=True) + self.assertEqual(result["id"], "uploaded123") + finally: + # Clean up temp file + os.unlink(tmp_file_path) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_folders.py b/tests/test_folders.py new file mode 100644 index 0000000..5136050 --- /dev/null +++ b/tests/test_folders.py @@ -0,0 +1,102 @@ +import unittest +from unittest.mock import patch, MagicMock +import requests +from immich_lib.api.folders import FoldersMixin + + +class TestFoldersMixin(unittest.TestCase): + def setUp(self): + # Create a mock client instance + self.server_url = "http://localhost:2283" + self.api_key = "test-api-key" + # Create a minimal mock client that inherits from FoldersMixin + self.client = type("MockClient", (FoldersMixin,), {})() + self.client.server_url = self.server_url + self.client.api_url = f"{self.server_url}/api" + self.client.headers = {"x-api-key": self.api_key} + self.client.session = MagicMock() + + @patch("requests.Session.request") + def test_list_folders_success(self, mock_request): + """Test successful list folders""" + mock_response = MagicMock() + mock_response.status_code = 200 + mock_response.headers = {"Content-Type": "application/json"} + mock_response.json.return_value = [ + {"id": "folder1", "importPath": "/path/to/folder1"}, + {"id": "folder2", "importPath": "/path/to/folder2"}, + ] + mock_request.return_value = mock_response + + result = self.client.list_folders() + self.assertEqual(len(result), 2) + self.assertEqual(result[0]["id"], "folder1") + + @patch("requests.Session.request") + def test_list_folders_empty_response(self, mock_request): + """Test list folders with empty response""" + mock_response = MagicMock() + mock_response.status_code = 200 + mock_response.headers = {"Content-Type": "application/json"} + mock_response.json.return_value = [] + mock_request.return_value = mock_response + + result = self.client.list_folders() + self.assertEqual(result, []) + + @patch("requests.Session.request") + def test_create_folder_success(self, mock_request): + """Test successful folder creation""" + mock_response = MagicMock() + mock_response.status_code = 200 + mock_response.headers = {"Content-Type": "application/json"} + mock_response.json.return_value = { + "id": "newfolder123", + "importPath": "/new/path", + } + mock_request.return_value = mock_response + + result = self.client.create_folder("/new/path") + self.assertEqual(result["id"], "newfolder123") + + @patch("requests.Session.request") + def test_create_folder_error(self, mock_request): + """Test folder creation with error response""" + mock_response = MagicMock() + mock_response.status_code = 400 + mock_response.headers = {"Content-Type": "application/json"} + mock_response.json.return_value = {"message": "Invalid path"} + mock_response.raise_for_status.side_effect = requests.exceptions.HTTPError( + "Bad Request", response=mock_response + ) + mock_request.return_value = mock_response + + with self.assertRaises(requests.exceptions.HTTPError): + self.client.create_folder("/invalid/path") + + @patch("requests.Session.request") + def test_delete_folder_success(self, mock_request): + """Test successful folder deletion""" + mock_response = MagicMock() + mock_response.status_code = 204 + mock_request.return_value = mock_response + + result = self.client.delete_folder("folder123") + self.assertTrue(result) + + @patch("requests.Session.request") + def test_delete_folder_error(self, mock_request): + """Test folder deletion with error""" + mock_response = MagicMock() + mock_response.status_code = 500 + mock_response.raise_for_status.side_effect = requests.exceptions.HTTPError( + "Internal Server Error", response=mock_response + ) + mock_request.return_value = mock_response + + with self.assertRaises(requests.exceptions.HTTPError): + self.client.delete_folder("folder123") + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_misc.py b/tests/test_misc.py new file mode 100644 index 0000000..e0f8f7c --- /dev/null +++ b/tests/test_misc.py @@ -0,0 +1,114 @@ +import unittest +from unittest.mock import patch, MagicMock +import requests +from immich_lib.api.misc import MiscellaneousMixin + + +class TestMiscellaneousMixin(unittest.TestCase): + def setUp(self): + # Create a mock client instance + self.server_url = "http://localhost:2283" + self.api_key = "test-api-key" + # Create a minimal mock client that inherits from MiscellaneousMixin + self.client = type("MockClient", (MiscellaneousMixin,), {})() + self.client.server_url = self.server_url + self.client.api_url = f"{self.server_url}/api" + self.client.headers = {"x-api-key": self.api_key} + self.client.session = MagicMock() + + @patch("requests.Session.request") + def test_get_timeline_success(self, mock_request): + """Test successful timeline retrieval""" + mock_response = MagicMock() + mock_response.status_code = 200 + mock_response.headers = {"Content-Type": "application/json"} + mock_response.json.return_value = [ + {"id": "bucket1", "assets": []}, + {"id": "bucket2", "assets": []}, + ] + mock_request.return_value = mock_response + + result = self.client.get_timeline() + self.assertEqual(len(result), 2) + + @patch("requests.Session.request") + def test_get_timeline_buckets_success(self, mock_request): + """Test successful timeline buckets retrieval""" + mock_response = MagicMock() + mock_response.status_code = 200 + mock_response.headers = {"Content-Type": "application/json"} + mock_response.json.return_value = [ + {"id": "bucket1", "name": "2023"}, + {"id": "bucket2", "name": "2024"}, + ] + mock_request.return_value = mock_response + + result = self.client.get_timeline_buckets(year=2023) + self.assertEqual(len(result), 2) + + @patch("requests.Session.request") + def test_list_api_keys_success(self, mock_request): + """Test successful API keys listing""" + mock_response = MagicMock() + mock_response.status_code = 200 + mock_response.headers = {"Content-Type": "application/json"} + mock_response.json.return_value = [ + {"id": "key1", "name": "Test Key 1"}, + {"id": "key2", "name": "Test Key 2"}, + ] + mock_request.return_value = mock_response + + result = self.client.list_api_keys() + self.assertEqual(len(result), 2) + + @patch("requests.Session.request") + def test_create_api_key_success(self, mock_request): + """Test successful API key creation""" + mock_response = MagicMock() + mock_response.status_code = 200 + mock_response.headers = {"Content-Type": "application/json"} + mock_response.json.return_value = { + "id": "newkey123", + "name": "New API Key", + "secretKey": "secret123", + } + mock_request.return_value = mock_response + + result = self.client.create_api_key("New API Key") + self.assertEqual(result["id"], "newkey123") + + @patch("requests.Session.request") + def test_delete_api_key_success(self, mock_request): + """Test successful API key deletion""" + mock_response = MagicMock() + mock_response.status_code = 204 + mock_request.return_value = mock_response + + result = self.client.delete_api_key("key123") + self.assertTrue(result) + + @patch("requests.Session.request") + def test_get_library_info_success(self, mock_request): + """Test successful library info retrieval""" + mock_response = MagicMock() + mock_response.status_code = 200 + mock_response.headers = {"Content-Type": "application/json"} + mock_response.json.return_value = {"id": "lib123", "stats": {"assetCount": 100}} + mock_request.return_value = mock_response + + result = self.client.get_library_info() + self.assertEqual(result["id"], "lib123") + + @patch("requests.Session.request") + def test_cleanup_library_success(self, mock_request): + """Test successful library cleanup""" + mock_response = MagicMock() + mock_response.status_code = 204 + mock_request.return_value = mock_response + + result = self.client.cleanup_library() + self.assertTrue(result) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_partners.py b/tests/test_partners.py new file mode 100644 index 0000000..3aaa775 --- /dev/null +++ b/tests/test_partners.py @@ -0,0 +1,92 @@ +import unittest +from unittest.mock import patch, MagicMock +import requests +from immich_lib.api.partners import PartnersMixin + + +class TestPartnersMixin(unittest.TestCase): + def setUp(self): + # Create a mock client instance + self.server_url = "http://localhost:2283" + self.api_key = "test-api-key" + # Create a minimal mock client that inherits from PartnersMixin + self.client = type("MockClient", (PartnersMixin,), {})() + self.client.server_url = self.server_url + self.client.api_url = f"{self.server_url}/api" + self.client.headers = {"x-api-key": self.api_key} + self.client.session = MagicMock() + + @patch("requests.Session.request") + def test_list_partners_success(self, mock_request): + """Test successful partners listing""" + mock_response = MagicMock() + mock_response.status_code = 200 + mock_response.headers = {"Content-Type": "application/json"} + mock_response.json.return_value = [ + {"id": "partner1", "userId": "user123", "name": "Partner 1"}, + {"id": "partner2", "userId": "user456", "name": "Partner 2"}, + ] + mock_request.return_value = mock_response + + result = self.client.list_partners("shared-with-me") + self.assertEqual(len(result), 2) + + @patch("requests.Session.request") + def test_list_partners_with_direction(self, mock_request): + """Test partners listing with different direction""" + mock_response = MagicMock() + mock_response.status_code = 200 + mock_response.headers = {"Content-Type": "application/json"} + mock_response.json.return_value = [ + {"id": "partner1", "userId": "user123", "name": "Partner 1"} + ] + mock_request.return_value = mock_response + + result = self.client.list_partners("shared-by-me") + self.assertEqual(len(result), 1) + + @patch("requests.Session.request") + def test_create_partner_success(self, mock_request): + """Test successful partner creation""" + mock_response = MagicMock() + mock_response.status_code = 200 + mock_response.headers = {"Content-Type": "application/json"} + mock_response.json.return_value = { + "id": "newpartner123", + "userId": "user456", + "name": "New Partner", + } + mock_request.return_value = mock_response + + result = self.client.create_partner("user456") + self.assertEqual(result["id"], "newpartner123") + + @patch("requests.Session.request") + def test_update_partner_success(self, mock_request): + """Test successful partner update""" + mock_response = MagicMock() + mock_response.status_code = 200 + mock_response.headers = {"Content-Type": "application/json"} + mock_response.json.return_value = { + "id": "partner123", + "userId": "user456", + "isArchived": True, + } + mock_request.return_value = mock_response + + result = self.client.update_partner("partner123", isArchived=True) + self.assertEqual(result["isArchived"], True) + + @patch("requests.Session.request") + def test_delete_partner_success(self, mock_request): + """Test successful partner deletion""" + mock_response = MagicMock() + mock_response.status_code = 204 + mock_request.return_value = mock_response + + result = self.client.delete_partner("partner123") + self.assertTrue(result) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_people.py b/tests/test_people.py new file mode 100644 index 0000000..58a3dd4 --- /dev/null +++ b/tests/test_people.py @@ -0,0 +1,110 @@ +import unittest +from unittest.mock import patch, MagicMock +import requests +from immich_lib.api.people import PeopleMixin + + +class TestPeopleMixin(unittest.TestCase): + def setUp(self): + # Create a mock client instance + self.server_url = "http://localhost:2283" + self.api_key = "test-api-key" + # Create a minimal mock client that inherits from PeopleMixin + self.client = type("MockClient", (PeopleMixin,), {})() + self.client.server_url = self.server_url + self.client.api_url = f"{self.server_url}/api" + self.client.headers = {"x-api-key": self.api_key} + self.client.session = MagicMock() + + @patch("requests.Session.request") + def test_get_all_people_success(self, mock_request): + """Test successful people listing""" + mock_response = MagicMock() + mock_response.status_code = 200 + mock_response.headers = {"Content-Type": "application/json"} + mock_response.json.return_value = [ + {"id": "person1", "name": "John Doe", "thumbnail": "/thumb1.jpg"}, + {"id": "person2", "name": "Jane Smith", "thumbnail": "/thumb2.jpg"}, + ] + mock_request.return_value = mock_response + + result = self.client.get_all_people() + self.assertEqual(len(result), 2) + + @patch("requests.Session.request") + def test_get_all_people_with_hidden(self, mock_request): + """Test people listing with hidden parameter""" + mock_response = MagicMock() + mock_response.status_code = 200 + mock_response.headers = {"Content-Type": "application/json"} + mock_response.json.return_value = [ + {"id": "person1", "name": "John Doe", "thumbnail": "/thumb1.jpg"} + ] + mock_request.return_value = mock_response + + result = self.client.get_all_people(with_hidden=True) + self.assertEqual(len(result), 1) + + @patch("requests.Session.request") + def test_get_person_success(self, mock_request): + """Test successful person retrieval""" + mock_response = MagicMock() + mock_response.status_code = 200 + mock_response.headers = {"Content-Type": "application/json"} + mock_response.json.return_value = { + "id": "person123", + "name": "John Doe", + "birthDate": "1980-01-01", + "thumbnail": "/thumb.jpg", + } + mock_request.return_value = mock_response + + result = self.client.get_person("person123") + self.assertEqual(result["name"], "John Doe") + + @patch("requests.Session.request") + def test_update_person_success(self, mock_request): + """Test successful person update""" + mock_response = MagicMock() + mock_response.status_code = 200 + mock_response.headers = {"Content-Type": "application/json"} + mock_response.json.return_value = { + "id": "person123", + "name": "Updated Name", + "birthDate": "1980-01-01", + } + mock_request.return_value = mock_response + + result = self.client.update_person("person123", name="Updated Name") + self.assertEqual(result["name"], "Updated Name") + + @patch("requests.Session.request") + def test_get_person_assets_success(self, mock_request): + """Test successful person assets retrieval""" + mock_response = MagicMock() + mock_response.status_code = 200 + mock_response.headers = {"Content-Type": "application/json"} + mock_response.json.return_value = [ + {"id": "asset1", "originalFileName": "photo1.jpg"}, + {"id": "asset2", "originalFileName": "photo2.jpg"}, + ] + mock_request.return_value = mock_response + + result = self.client.get_person_assets("person123") + self.assertEqual(len(result), 2) + + @patch("requests.Session.request") + def test_merge_people_success(self, mock_request): + """Test successful people merge""" + mock_response = MagicMock() + mock_response.status_code = 200 + mock_response.headers = {"Content-Type": "application/json"} + mock_response.json.return_value = ["person456", "person789"] + mock_request.return_value = mock_response + + result = self.client.merge_people("person123", ["person456", "person789"]) + self.assertEqual(len(result), 2) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_search.py b/tests/test_search.py new file mode 100644 index 0000000..d74a609 --- /dev/null +++ b/tests/test_search.py @@ -0,0 +1,100 @@ +import unittest +from unittest.mock import patch, MagicMock +import requests +from immich_lib.api.search import SearchMixin + + +class TestSearchMixin(unittest.TestCase): + def setUp(self): + # Create a mock client instance + self.server_url = "http://localhost:2283" + self.api_key = "test-api-key" + # Create a minimal mock client that inherits from SearchMixin + self.client = type("MockClient", (SearchMixin,), {})() + self.client.server_url = self.server_url + self.client.api_url = f"{self.server_url}/api" + self.client.headers = {"x-api-key": self.api_key} + self.client.session = MagicMock() + + @patch("requests.Session.request") + def test_search_metadata_success(self, mock_request): + """Test successful metadata search""" + mock_response = MagicMock() + mock_response.status_code = 200 + mock_response.headers = {"Content-Type": "application/json"} + mock_response.json.return_value = { + "assets": { + "items": [ + {"id": "asset1", "originalFileName": "test.jpg"}, + {"id": "asset2", "originalFileName": "photo.png"}, + ] + } + } + mock_request.return_value = mock_response + + # Test search with query and filters + result = self.client.search_metadata("sunset", isFavorite=True, type="IMAGE") + self.assertEqual(len(result["assets"]["items"]), 2) + + @patch("requests.Session.request") + def test_search_metadata_no_query(self, mock_request): + """Test metadata search without query""" + mock_response = MagicMock() + mock_response.status_code = 200 + mock_response.headers = {"Content-Type": "application/json"} + mock_response.json.return_value = { + "assets": {"items": [{"id": "asset1", "originalFileName": "test.jpg"}]} + } + mock_request.return_value = mock_response + + result = self.client.search_metadata(isFavorite=True) + self.assertEqual(len(result["assets"]["items"]), 1) + + @patch("requests.Session.request") + def test_search_places_success(self, mock_request): + """Test successful places search""" + mock_response = MagicMock() + mock_response.status_code = 200 + mock_response.headers = {"Content-Type": "application/json"} + mock_response.json.return_value = [ + {"id": "place1", "name": "Paris"}, + {"id": "place2", "name": "London"}, + ] + mock_request.return_value = mock_response + + result = self.client.search_places("Paris") + self.assertEqual(len(result), 2) + + @patch("requests.Session.request") + def test_search_smart_success(self, mock_request): + """Test successful smart search""" + mock_response = MagicMock() + mock_response.status_code = 200 + mock_response.headers = {"Content-Type": "application/json"} + mock_response.json.return_value = [ + {"id": "asset1", "originalFileName": "smart1.jpg"}, + {"id": "asset2", "originalFileName": "smart2.png"}, + ] + mock_request.return_value = mock_response + + result = self.client.search_smart("sunset at beach", limit=10) + self.assertEqual(len(result), 2) + + @patch("requests.Session.request") + def test_get_explore_data_success(self, mock_request): + """Test successful explore data retrieval""" + mock_response = MagicMock() + mock_response.status_code = 200 + mock_response.headers = {"Content-Type": "application/json"} + mock_response.json.return_value = { + "places": ["Paris", "London"], + "people": ["John", "Jane"], + } + mock_request.return_value = mock_response + + result = self.client.get_explore_data() + self.assertEqual(len(result["places"]), 2) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_stacks.py b/tests/test_stacks.py new file mode 100644 index 0000000..9a56bb0 --- /dev/null +++ b/tests/test_stacks.py @@ -0,0 +1,89 @@ +import unittest +from unittest.mock import patch, MagicMock +import requests +from immich_lib.api.stacks import StacksMixin + + +class TestStacksMixin(unittest.TestCase): + def setUp(self): + # Create a mock client instance + self.server_url = "http://localhost:2283" + self.api_key = "test-api-key" + # Create a minimal mock client that inherits from StacksMixin + self.client = type("MockClient", (StacksMixin,), {})() + self.client.server_url = self.server_url + self.client.api_url = f"{self.server_url}/api" + self.client.headers = {"x-api-key": self.api_key} + self.client.session = MagicMock() + + @patch("requests.Session.request") + def test_create_stack_success(self, mock_request): + """Test successful stack creation""" + mock_response = MagicMock() + mock_response.status_code = 200 + mock_response.headers = {"Content-Type": "application/json"} + mock_response.json.return_value = { + "id": "stack123", + "primaryAssetId": "asset1", + "assetIds": ["asset1", "asset2"], + } + mock_request.return_value = mock_response + + result = self.client.create_stack("asset1", ["asset2", "asset3"]) + self.assertEqual(result["id"], "stack123") + + @patch("requests.Session.request") + def test_get_stack_success(self, mock_request): + """Test successful stack retrieval""" + mock_response = MagicMock() + mock_response.status_code = 200 + mock_response.headers = {"Content-Type": "application/json"} + mock_response.json.return_value = { + "id": "stack123", + "primaryAssetId": "asset1", + "assetIds": ["asset1", "asset2"], + } + mock_request.return_value = mock_response + + result = self.client.get_stack("stack123") + self.assertEqual(result["id"], "stack123") + + @patch("requests.Session.request") + def test_update_stack_success(self, mock_request): + """Test successful stack update""" + mock_response = MagicMock() + mock_response.status_code = 200 + mock_response.headers = {"Content-Type": "application/json"} + mock_response.json.return_value = { + "id": "stack123", + "primaryAssetId": "asset2", + "assetIds": ["asset1", "asset2"], + } + mock_request.return_value = mock_response + + result = self.client.update_stack("stack123", "asset2") + self.assertEqual(result["primaryAssetId"], "asset2") + + @patch("requests.Session.request") + def test_delete_stack_success(self, mock_request): + """Test successful stack deletion""" + mock_response = MagicMock() + mock_response.status_code = 204 + mock_request.return_value = mock_response + + result = self.client.delete_stack("stack123") + self.assertTrue(result) + + @patch("requests.Session.request") + def test_remove_asset_from_stack_success(self, mock_request): + """Test successful asset removal from stack""" + mock_response = MagicMock() + mock_response.status_code = 204 + mock_request.return_value = mock_response + + result = self.client.remove_asset_from_stack("stack123", "asset1") + self.assertTrue(result) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_tags.py b/tests/test_tags.py new file mode 100644 index 0000000..c1b66fb --- /dev/null +++ b/tests/test_tags.py @@ -0,0 +1,119 @@ +import unittest +from unittest.mock import patch, MagicMock +import requests +from immich_lib.api.tags import TagsMixin + + +class TestTagsMixin(unittest.TestCase): + def setUp(self): + # Create a mock client instance + self.server_url = "http://localhost:2283" + self.api_key = "test-api-key" + # Create a minimal mock client that inherits from TagsMixin + self.client = type("MockClient", (TagsMixin,), {})() + self.client.server_url = self.server_url + self.client.api_url = f"{self.server_url}/api" + self.client.headers = {"x-api-key": self.api_key} + self.client.session = MagicMock() + + @patch("requests.Session.request") + def test_list_tags_success(self, mock_request): + """Test successful tags listing""" + mock_response = MagicMock() + mock_response.status_code = 200 + mock_response.headers = {"Content-Type": "application/json"} + mock_response.json.return_value = [ + {"id": "tag1", "name": "Vacation", "type": "TEXT"}, + {"id": "tag2", "name": "Family", "type": "TEXT"}, + ] + mock_request.return_value = mock_response + + result = self.client.list_tags() + self.assertEqual(len(result), 2) + + @patch("requests.Session.request") + def test_create_tag_success(self, mock_request): + """Test successful tag creation""" + mock_response = MagicMock() + mock_response.status_code = 200 + mock_response.headers = {"Content-Type": "application/json"} + mock_response.json.return_value = { + "id": "newtag123", + "name": "New Tag", + "type": "TEXT", + } + mock_request.return_value = mock_response + + result = self.client.create_tag("New Tag") + self.assertEqual(result["id"], "newtag123") + + @patch("requests.Session.request") + def test_get_tag_success(self, mock_request): + """Test successful tag retrieval""" + mock_response = MagicMock() + mock_response.status_code = 200 + mock_response.headers = {"Content-Type": "application/json"} + mock_response.json.return_value = { + "id": "tag123", + "name": "Vacation", + "type": "TEXT", + } + mock_request.return_value = mock_response + + result = self.client.get_tag("tag123") + self.assertEqual(result["name"], "Vacation") + + @patch("requests.Session.request") + def test_update_tag_success(self, mock_request): + """Test successful tag update""" + mock_response = MagicMock() + mock_response.status_code = 200 + mock_response.headers = {"Content-Type": "application/json"} + mock_response.json.return_value = { + "id": "tag123", + "name": "Updated Vacation", + "type": "TEXT", + } + mock_request.return_value = mock_response + + result = self.client.update_tag("tag123", "Updated Vacation") + self.assertEqual(result["name"], "Updated Vacation") + + @patch("requests.Session.request") + def test_delete_tag_success(self, mock_request): + """Test successful tag deletion""" + mock_response = MagicMock() + mock_response.status_code = 204 + mock_request.return_value = mock_response + + result = self.client.delete_tag("tag123") + self.assertTrue(result) + + @patch("requests.Session.request") + def test_tag_assets_success(self, mock_request): + """Test successful asset tagging""" + mock_response = MagicMock() + mock_response.status_code = 200 + mock_response.headers = {"Content-Type": "application/json"} + mock_response.json.return_value = [ + {"assetId": "asset1", "status": "success"}, + {"assetId": "asset2", "status": "success"}, + ] + mock_request.return_value = mock_response + + result = self.client.tag_assets("tag123", ["asset1", "asset2"]) + self.assertEqual(len(result), 2) + + @patch("requests.Session.request") + def test_untag_assets_success(self, mock_request): + """Test successful asset untagging""" + mock_response = MagicMock() + mock_response.status_code = 204 + mock_request.return_value = mock_response + + result = self.client.untag_assets("tag123", ["asset1", "asset2"]) + self.assertTrue(result) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_trash.py b/tests/test_trash.py new file mode 100644 index 0000000..9042e4f --- /dev/null +++ b/tests/test_trash.py @@ -0,0 +1,68 @@ +import unittest +from unittest.mock import patch, MagicMock +import requests +from immich_lib.api.trash import TrashMixin + + +class TestTrashMixin(unittest.TestCase): + def setUp(self): + # Create a mock client instance + self.server_url = "http://localhost:2283" + self.api_key = "test-api-key" + # Create a minimal mock client that inherits from TrashMixin + self.client = type("MockClient", (TrashMixin,), {})() + self.client.server_url = self.server_url + self.client.api_url = f"{self.server_url}/api" + self.client.headers = {"x-api-key": self.api_key} + self.client.session = MagicMock() + + @patch("requests.Session.request") + def test_get_trash_success(self, mock_request): + """Test successful trash retrieval""" + mock_response = MagicMock() + mock_response.status_code = 200 + mock_response.headers = {"Content-Type": "application/json"} + mock_response.json.return_value = [ + {"id": "asset1", "originalFileName": "deleted1.jpg"}, + {"id": "asset2", "originalFileName": "deleted2.png"}, + ] + mock_request.return_value = mock_response + + result = self.client.get_trash() + self.assertEqual(len(result), 2) + + @patch("requests.Session.request") + def test_empty_trash_success(self, mock_request): + """Test successful trash emptying""" + mock_response = MagicMock() + mock_response.status_code = 204 + mock_request.return_value = mock_response + + result = self.client.empty_trash() + self.assertTrue(result) + + @patch("requests.Session.request") + def test_restore_trash_success(self, mock_request): + """Test successful trash restore""" + mock_response = MagicMock() + mock_response.status_code = 204 + mock_request.return_value = mock_response + + result = self.client.restore_trash() + self.assertTrue(result) + + @patch("requests.Session.request") + def test_restore_assets_success(self, mock_request): + """Test successful individual asset restore""" + mock_response = MagicMock() + mock_response.status_code = 200 + mock_response.headers = {"Content-Type": "application/json"} + mock_response.json.return_value = {"status": "success"} + mock_request.return_value = mock_response + + result = self.client.restore_assets(["asset1", "asset2"]) + self.assertEqual(result["status"], "success") + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_users.py b/tests/test_users.py new file mode 100644 index 0000000..c24dd0e --- /dev/null +++ b/tests/test_users.py @@ -0,0 +1,112 @@ +import unittest +from unittest.mock import patch, MagicMock +import requests +from immich_lib.api.users import UsersMixin + + +class TestUsersMixin(unittest.TestCase): + def setUp(self): + # Create a mock client instance + self.server_url = "http://localhost:2283" + self.api_key = "test-api-key" + # Create a minimal mock client that inherits from UsersMixin + self.client = type("MockClient", (UsersMixin,), {})() + self.client.server_url = self.server_url + self.client.api_url = f"{self.server_url}/api" + self.client.headers = {"x-api-key": self.api_key} + self.client.session = MagicMock() + + @patch("requests.Session.request") + def test_list_users_success(self, mock_request): + """Test successful users listing""" + mock_response = MagicMock() + mock_response.status_code = 200 + mock_response.headers = {"Content-Type": "application/json"} + mock_response.json.return_value = [ + {"id": "user1", "email": "user1@example.com", "name": "User One"}, + {"id": "user2", "email": "user2@example.com", "name": "User Two"}, + ] + mock_request.return_value = mock_response + + result = self.client.list_users() + self.assertEqual(len(result), 2) + + @patch("requests.Session.request") + def test_create_user_success(self, mock_request): + """Test successful user creation""" + mock_response = MagicMock() + mock_response.status_code = 200 + mock_response.headers = {"Content-Type": "application/json"} + mock_response.json.return_value = { + "id": "newuser123", + "email": "newuser@example.com", + "name": "New User", + } + mock_request.return_value = mock_response + + result = self.client.create_user( + "newuser@example.com", "password123", "New User", is_admin=True + ) + self.assertEqual(result["id"], "newuser123") + + @patch("requests.Session.request") + def test_get_me_success(self, mock_request): + """Test successful current user retrieval""" + mock_response = MagicMock() + mock_response.status_code = 200 + mock_response.headers = {"Content-Type": "application/json"} + mock_response.json.return_value = { + "id": "currentuser123", + "email": "current@example.com", + "name": "Current User", + } + mock_request.return_value = mock_response + + result = self.client.get_me() + self.assertEqual(result["name"], "Current User") + + @patch("requests.Session.request") + def test_get_user_success(self, mock_request): + """Test successful specific user retrieval""" + mock_response = MagicMock() + mock_response.status_code = 200 + mock_response.headers = {"Content-Type": "application/json"} + mock_response.json.return_value = { + "id": "user123", + "email": "user@example.com", + "name": "User", + } + mock_request.return_value = mock_response + + result = self.client.get_user("user123") + self.assertEqual(result["name"], "User") + + @patch("requests.Session.request") + def test_update_user_success(self, mock_request): + """Test successful user update""" + mock_response = MagicMock() + mock_response.status_code = 200 + mock_response.headers = {"Content-Type": "application/json"} + mock_response.json.return_value = { + "id": "user123", + "email": "updated@example.com", + "name": "Updated User", + } + mock_request.return_value = mock_response + + result = self.client.update_user("user123", email="updated@example.com") + self.assertEqual(result["email"], "updated@example.com") + + @patch("requests.Session.request") + def test_delete_user_success(self, mock_request): + """Test successful user deletion""" + mock_response = MagicMock() + mock_response.status_code = 204 + mock_request.return_value = mock_response + + result = self.client.delete_user("user123") + self.assertTrue(result) + + +if __name__ == "__main__": + unittest.main() From b3df2a5b82641d8a3a6e330f9fd8ad0189a348f3 Mon Sep 17 00:00:00 2001 From: guanana Date: Tue, 20 Jan 2026 20:16:13 +0000 Subject: [PATCH 2/3] Fix most tests --- tests/test_assets.py | 62 ++++++++++++++++++++---------------------- tests/test_folders.py | 11 ++------ tests/test_misc.py | 11 ++------ tests/test_partners.py | 11 ++------ tests/test_people.py | 11 ++------ tests/test_search.py | 12 ++------ tests/test_stacks.py | 13 +++------ tests/test_tags.py | 11 ++------ tests/test_trash.py | 11 ++------ tests/test_users.py | 11 ++------ 10 files changed, 57 insertions(+), 107 deletions(-) diff --git a/tests/test_assets.py b/tests/test_assets.py index 82aac49..e23ab37 100644 --- a/tests/test_assets.py +++ b/tests/test_assets.py @@ -3,21 +3,16 @@ import requests import os import tempfile -from immich_lib.api.assets import AssetsMixin +from immich_lib.client import ImmichClient -# Create a test class that inherits from AssetsMixin to create tests +# Create a test class that uses the actual client with mocked methods class TestAssetsMixin(unittest.TestCase): def setUp(self): - # Create a mock client instance + # Create a proper client instance that will be used for testing self.server_url = "http://localhost:2283" self.api_key = "test-api-key" - # Create a minimal mock client that inherits from AssetsMixin - self.client = type("MockClient", (AssetsMixin,), {})() - self.client.server_url = self.server_url - self.client.api_url = f"{self.server_url}/api" - self.client.headers = {"x-api-key": self.api_key} - self.client.session = MagicMock() + self.client = ImmichClient(self.server_url, self.api_key) @patch("requests.Session.request") def test_list_assets_success(self, mock_request): @@ -133,30 +128,31 @@ def test_delete_assets_error(self, mock_request): with self.assertRaises(requests.exceptions.HTTPError): self.client.delete_assets(["asset1"]) - @patch("requests.Session.request") - def test_download_asset_success_with_path(self, mock_request): - """Test successful asset download with file path""" - # Mock response for downloading the asset - mock_response = MagicMock() - mock_response.status_code = 200 - mock_response.headers = {"Content-Type": "image/jpeg", "content-length": "1024"} - mock_response.iter_content.return_value = [b"test data"] - - # Mock file operations - with patch("builtins.open", MagicMock()) as mock_open: - with patch("tqdm") as mock_tqdm: - mock_tqdm_instance = MagicMock() - mock_tqdm.return_value.__enter__.return_value = mock_tqdm_instance - - mock_request.return_value = mock_response - - # Create temporary directory and file - with tempfile.TemporaryDirectory() as tmpdir: - test_file = os.path.join(tmpdir, "test.jpg") - result = self.client.download_asset("asset123", test_file) - - # Should return True to indicate success - self.assertTrue(result) +@patch("requests.Session.request") + def test_download_asset_success_with_path(self, mock_request): + """Test successful asset download with file path""" + # Mock response for downloading the asset + mock_response = MagicMock() + mock_response.status_code = 200 + mock_response.headers = {"Content-Type": "image/jpeg", "content-length": "1024"} + mock_response.iter_content.return_value = [b"test data"] + + # Mock file operations + with patch("builtins.open", MagicMock()) as mock_open: + # Mock tqdm class directly since it's imported in the client module + with patch("immich_lib.api.assets.tqdm") as mock_tqdm: + mock_tqdm_instance = MagicMock() + mock_tqdm.return_value.__enter__.return_value = mock_tqdm_instance + + mock_request.return_value = mock_response + + # Create temporary directory and file + with tempfile.TemporaryDirectory() as tmpdir: + test_file = os.path.join(tmpdir, "test.jpg") + result = self.client.download_asset("asset123", test_file) + + # Should return True to indicate success + self.assertTrue(result) @patch("requests.Session.request") def test_download_asset_success_no_path(self, mock_request): diff --git a/tests/test_folders.py b/tests/test_folders.py index 5136050..7899b8c 100644 --- a/tests/test_folders.py +++ b/tests/test_folders.py @@ -1,20 +1,15 @@ import unittest from unittest.mock import patch, MagicMock import requests -from immich_lib.api.folders import FoldersMixin +from immich_lib.client import ImmichClient class TestFoldersMixin(unittest.TestCase): def setUp(self): - # Create a mock client instance + # Create a proper client instance that will be used for testing self.server_url = "http://localhost:2283" self.api_key = "test-api-key" - # Create a minimal mock client that inherits from FoldersMixin - self.client = type("MockClient", (FoldersMixin,), {})() - self.client.server_url = self.server_url - self.client.api_url = f"{self.server_url}/api" - self.client.headers = {"x-api-key": self.api_key} - self.client.session = MagicMock() + self.client = ImmichClient(self.server_url, self.api_key) @patch("requests.Session.request") def test_list_folders_success(self, mock_request): diff --git a/tests/test_misc.py b/tests/test_misc.py index e0f8f7c..ad6493e 100644 --- a/tests/test_misc.py +++ b/tests/test_misc.py @@ -1,20 +1,15 @@ import unittest from unittest.mock import patch, MagicMock import requests -from immich_lib.api.misc import MiscellaneousMixin +from immich_lib.client import ImmichClient class TestMiscellaneousMixin(unittest.TestCase): def setUp(self): - # Create a mock client instance + # Create a proper client instance that will be used for testing self.server_url = "http://localhost:2283" self.api_key = "test-api-key" - # Create a minimal mock client that inherits from MiscellaneousMixin - self.client = type("MockClient", (MiscellaneousMixin,), {})() - self.client.server_url = self.server_url - self.client.api_url = f"{self.server_url}/api" - self.client.headers = {"x-api-key": self.api_key} - self.client.session = MagicMock() + self.client = ImmichClient(self.server_url, self.api_key) @patch("requests.Session.request") def test_get_timeline_success(self, mock_request): diff --git a/tests/test_partners.py b/tests/test_partners.py index 3aaa775..a023e56 100644 --- a/tests/test_partners.py +++ b/tests/test_partners.py @@ -1,20 +1,15 @@ import unittest from unittest.mock import patch, MagicMock import requests -from immich_lib.api.partners import PartnersMixin +from immich_lib.client import ImmichClient class TestPartnersMixin(unittest.TestCase): def setUp(self): - # Create a mock client instance + # Create a proper client instance that will be used for testing self.server_url = "http://localhost:2283" self.api_key = "test-api-key" - # Create a minimal mock client that inherits from PartnersMixin - self.client = type("MockClient", (PartnersMixin,), {})() - self.client.server_url = self.server_url - self.client.api_url = f"{self.server_url}/api" - self.client.headers = {"x-api-key": self.api_key} - self.client.session = MagicMock() + self.client = ImmichClient(self.server_url, self.api_key) @patch("requests.Session.request") def test_list_partners_success(self, mock_request): diff --git a/tests/test_people.py b/tests/test_people.py index 58a3dd4..1753b3b 100644 --- a/tests/test_people.py +++ b/tests/test_people.py @@ -1,20 +1,15 @@ import unittest from unittest.mock import patch, MagicMock import requests -from immich_lib.api.people import PeopleMixin +from immich_lib.client import ImmichClient class TestPeopleMixin(unittest.TestCase): def setUp(self): - # Create a mock client instance + # Create a proper client instance that will be used for testing self.server_url = "http://localhost:2283" self.api_key = "test-api-key" - # Create a minimal mock client that inherits from PeopleMixin - self.client = type("MockClient", (PeopleMixin,), {})() - self.client.server_url = self.server_url - self.client.api_url = f"{self.server_url}/api" - self.client.headers = {"x-api-key": self.api_key} - self.client.session = MagicMock() + self.client = ImmichClient(self.server_url, self.api_key) @patch("requests.Session.request") def test_get_all_people_success(self, mock_request): diff --git a/tests/test_search.py b/tests/test_search.py index d74a609..969a5ab 100644 --- a/tests/test_search.py +++ b/tests/test_search.py @@ -1,20 +1,14 @@ import unittest from unittest.mock import patch, MagicMock -import requests -from immich_lib.api.search import SearchMixin +from immich_lib.client import ImmichClient class TestSearchMixin(unittest.TestCase): def setUp(self): - # Create a mock client instance + # Create a proper client instance that will be used for testing self.server_url = "http://localhost:2283" self.api_key = "test-api-key" - # Create a minimal mock client that inherits from SearchMixin - self.client = type("MockClient", (SearchMixin,), {})() - self.client.server_url = self.server_url - self.client.api_url = f"{self.server_url}/api" - self.client.headers = {"x-api-key": self.api_key} - self.client.session = MagicMock() + self.client = ImmichClient(self.server_url, self.api_key) @patch("requests.Session.request") def test_search_metadata_success(self, mock_request): diff --git a/tests/test_stacks.py b/tests/test_stacks.py index 9a56bb0..ca07750 100644 --- a/tests/test_stacks.py +++ b/tests/test_stacks.py @@ -1,20 +1,15 @@ import unittest from unittest.mock import patch, MagicMock -import requests -from immich_lib.api.stacks import StacksMixin +from immich_lib.client import ImmichClient + class TestStacksMixin(unittest.TestCase): def setUp(self): - # Create a mock client instance + # Create a proper client instance that will be used for testing self.server_url = "http://localhost:2283" self.api_key = "test-api-key" - # Create a minimal mock client that inherits from StacksMixin - self.client = type("MockClient", (StacksMixin,), {})() - self.client.server_url = self.server_url - self.client.api_url = f"{self.server_url}/api" - self.client.headers = {"x-api-key": self.api_key} - self.client.session = MagicMock() + self.client = ImmichClient(self.server_url, self.api_key) @patch("requests.Session.request") def test_create_stack_success(self, mock_request): diff --git a/tests/test_tags.py b/tests/test_tags.py index c1b66fb..af23ea1 100644 --- a/tests/test_tags.py +++ b/tests/test_tags.py @@ -1,20 +1,15 @@ import unittest from unittest.mock import patch, MagicMock import requests -from immich_lib.api.tags import TagsMixin +from immich_lib.client import ImmichClient class TestTagsMixin(unittest.TestCase): def setUp(self): - # Create a mock client instance + # Create a proper client instance that will be used for testing self.server_url = "http://localhost:2283" self.api_key = "test-api-key" - # Create a minimal mock client that inherits from TagsMixin - self.client = type("MockClient", (TagsMixin,), {})() - self.client.server_url = self.server_url - self.client.api_url = f"{self.server_url}/api" - self.client.headers = {"x-api-key": self.api_key} - self.client.session = MagicMock() + self.client = ImmichClient(self.server_url, self.api_key) @patch("requests.Session.request") def test_list_tags_success(self, mock_request): diff --git a/tests/test_trash.py b/tests/test_trash.py index 9042e4f..09ad795 100644 --- a/tests/test_trash.py +++ b/tests/test_trash.py @@ -1,20 +1,15 @@ import unittest from unittest.mock import patch, MagicMock import requests -from immich_lib.api.trash import TrashMixin +from immich_lib.client import ImmichClient class TestTrashMixin(unittest.TestCase): def setUp(self): - # Create a mock client instance + # Create a proper client instance that will be used for testing self.server_url = "http://localhost:2283" self.api_key = "test-api-key" - # Create a minimal mock client that inherits from TrashMixin - self.client = type("MockClient", (TrashMixin,), {})() - self.client.server_url = self.server_url - self.client.api_url = f"{self.server_url}/api" - self.client.headers = {"x-api-key": self.api_key} - self.client.session = MagicMock() + self.client = ImmichClient(self.server_url, self.api_key) @patch("requests.Session.request") def test_get_trash_success(self, mock_request): diff --git a/tests/test_users.py b/tests/test_users.py index c24dd0e..52c6cbe 100644 --- a/tests/test_users.py +++ b/tests/test_users.py @@ -1,20 +1,15 @@ import unittest from unittest.mock import patch, MagicMock import requests -from immich_lib.api.users import UsersMixin +from immich_lib.client import ImmichClient class TestUsersMixin(unittest.TestCase): def setUp(self): - # Create a mock client instance + # Create a proper client instance that will be used for testing self.server_url = "http://localhost:2283" self.api_key = "test-api-key" - # Create a minimal mock client that inherits from UsersMixin - self.client = type("MockClient", (UsersMixin,), {})() - self.client.server_url = self.server_url - self.client.api_url = f"{self.server_url}/api" - self.client.headers = {"x-api-key": self.api_key} - self.client.session = MagicMock() + self.client = ImmichClient(self.server_url, self.api_key) @patch("requests.Session.request") def test_list_users_success(self, mock_request): From 970fcb742d4c9a7edbf913cab7593579bee8305a Mon Sep 17 00:00:00 2001 From: guanana Date: Tue, 20 Jan 2026 20:18:06 +0000 Subject: [PATCH 3/3] Fix last test --- tests/test_assets.py | 50 ++++++++++++++++++++++---------------------- 1 file changed, 25 insertions(+), 25 deletions(-) diff --git a/tests/test_assets.py b/tests/test_assets.py index e23ab37..9bf8ddc 100644 --- a/tests/test_assets.py +++ b/tests/test_assets.py @@ -128,31 +128,31 @@ def test_delete_assets_error(self, mock_request): with self.assertRaises(requests.exceptions.HTTPError): self.client.delete_assets(["asset1"]) -@patch("requests.Session.request") - def test_download_asset_success_with_path(self, mock_request): - """Test successful asset download with file path""" - # Mock response for downloading the asset - mock_response = MagicMock() - mock_response.status_code = 200 - mock_response.headers = {"Content-Type": "image/jpeg", "content-length": "1024"} - mock_response.iter_content.return_value = [b"test data"] - - # Mock file operations - with patch("builtins.open", MagicMock()) as mock_open: - # Mock tqdm class directly since it's imported in the client module - with patch("immich_lib.api.assets.tqdm") as mock_tqdm: - mock_tqdm_instance = MagicMock() - mock_tqdm.return_value.__enter__.return_value = mock_tqdm_instance - - mock_request.return_value = mock_response - - # Create temporary directory and file - with tempfile.TemporaryDirectory() as tmpdir: - test_file = os.path.join(tmpdir, "test.jpg") - result = self.client.download_asset("asset123", test_file) - - # Should return True to indicate success - self.assertTrue(result) + @patch("requests.Session.request") + def test_download_asset_success_with_path(self, mock_request): + """Test successful asset download with file path""" + # Mock response for downloading the asset + mock_response = MagicMock() + mock_response.status_code = 200 + mock_response.headers = {"Content-Type": "image/jpeg", "content-length": "1024"} + mock_response.iter_content.return_value = [b"test data"] + + # Mock file operations + with patch("builtins.open", MagicMock()) as mock_open: + # Mock tqdm class directly since it's imported in the client module + with patch("immich_lib.api.assets.tqdm") as mock_tqdm: + mock_tqdm_instance = MagicMock() + mock_tqdm.return_value.__enter__.return_value = mock_tqdm_instance + + mock_request.return_value = mock_response + + # Create temporary directory and file + with tempfile.TemporaryDirectory() as tmpdir: + test_file = os.path.join(tmpdir, "test.jpg") + result = self.client.download_asset("asset123", test_file) + + # Should return True to indicate success + self.assertTrue(result) @patch("requests.Session.request") def test_download_asset_success_no_path(self, mock_request):