Add tests

tests/test_client.py

@@ -0,0 +1,147 @@
+import pytest
+import os
+import time
+import uuid
+from httpx import HTTPStatusError
+
+from nextcloud_mcp_server.client import NextcloudClient
+
+# Tests assume NEXTCLOUD_HOST, NEXTCLOUD_USERNAME, NEXTCLOUD_PASSWORD env vars are set
+
+@pytest.fixture(scope="module")
+def nc_client() -> NextcloudClient:
+    """
+    Fixture to create a NextcloudClient instance for integration tests.
+    Reads credentials from environment variables.
+    Scope is 'module' so the client is reused for all tests in this file.
+    """
+    # Basic check to ensure env vars seem present - tests will fail properly if not
+    assert os.getenv("NEXTCLOUD_HOST"), "NEXTCLOUD_HOST env var not set"
+    assert os.getenv("NEXTCLOUD_USERNAME"), "NEXTCLOUD_USERNAME env var not set"
+    assert os.getenv("NEXTCLOUD_PASSWORD"), "NEXTCLOUD_PASSWORD env var not set"
+    return NextcloudClient.from_env()
+
+@pytest.mark.integration
+def test_note_crud_integration(nc_client: NextcloudClient):
+    """
+    Integration test for the complete CRUD (Create, Read, Update, Delete)
+    lifecycle of a note.
+    """
+    # --- Create ---
+    unique_id = str(uuid.uuid4()) # To ensure note is unique for this test run
+    create_title = f"Integration Test Note {unique_id}"
+    create_content = f"Content for integration test {unique_id}"
+    create_category = "IntegrationTesting"
+
+    created_note = None # Initialize to ensure cleanup happens even if create fails mid-assert
+    try:
+        print(f"\nAttempting to create note: {create_title}")
+        created_note = nc_client.notes_create_note(
+            title=create_title, content=create_content, category=create_category
+        )
+        print(f"Note created: {created_note}")
+
+        assert created_note is not None
+        assert "id" in created_note
+        assert created_note["title"] == create_title
+        assert created_note["content"] == create_content
+        assert created_note["category"] == create_category
+        assert "etag" in created_note
+        note_id = created_note["id"]
+        etag = created_note["etag"]
+
+        # Add a small delay to allow Nextcloud to process if needed
+        time.sleep(1)
+
+        # --- Read (Verify Create) ---
+        print(f"Attempting to read note ID: {note_id}")
+        read_note = nc_client.notes_get_note(note_id=note_id)
+        print(f"Note read: {read_note}")
+        assert read_note["id"] == note_id
+        assert read_note["title"] == create_title
+        assert read_note["content"] == create_content
+        assert read_note["category"] == create_category
+        # Etag might change even on read in some systems, so don't assert etag equality here
+
+        # --- Update ---
+        update_title = f"Updated Test Note {unique_id}"
+        update_content = f"Updated content {unique_id}"
+        # Use the etag from the *creation* for the update's If-Match header
+        print(f"Attempting to update note ID: {note_id} with etag: {etag}")
+        updated_note = nc_client.notes_update_note(
+            note_id=note_id,
+            etag=etag,
+            title=update_title,
+            content=update_content,
+            # category=create_category # Keep category same or update if needed
+        )
+        print(f"Note updated: {updated_note}")
+        assert updated_note["id"] == note_id
+        assert updated_note["title"] == update_title
+        assert updated_note["content"] == update_content
+        assert updated_note["category"] == create_category # Category wasn't updated
+        assert "etag" in updated_note
+        assert updated_note["etag"] != etag # Etag must change on update
+        new_etag = updated_note["etag"]
+
+        # Add a small delay
+        time.sleep(1)
+
+        # --- Read (Verify Update) ---
+        print(f"Attempting to read updated note ID: {note_id}")
+        read_updated_note = nc_client.notes_get_note(note_id=note_id)
+        print(f"Updated note read: {read_updated_note}")
+        assert read_updated_note["id"] == note_id
+        assert read_updated_note["title"] == update_title
+        assert read_updated_note["content"] == update_content
+        # Don't assert etag equality here either
+
+        # --- Test Update Conflict (Precondition Failed) ---
+        print(f"Attempting to update note ID: {note_id} with OLD etag: {etag}")
+        with pytest.raises(HTTPStatusError) as excinfo:
+            nc_client.notes_update_note(
+                note_id=note_id,
+                etag=etag, # Use the OLD etag
+                title="This update should fail",
+            )
+        assert excinfo.value.response.status_code == 412 # Precondition Failed
+        print("Update with old etag correctly failed with 412.")
+
+    finally:
+        # --- Delete ---
+        if created_note and "id" in created_note:
+            note_id_to_delete = created_note["id"]
+            print(f"Attempting to delete note ID: {note_id_to_delete}")
+            try:
+                delete_response = nc_client.notes_delete_note(note_id=note_id_to_delete)
+                print(f"Delete response: {delete_response}")
+                # Check if delete returns the deleted object or just status
+                # Assuming it returns the object based on previous tests
+                assert delete_response["id"] == note_id_to_delete
+                print(f"Note ID: {note_id_to_delete} deleted successfully.")
+
+                # --- Verify Delete ---
+                print(f"Attempting to read deleted note ID: {note_id_to_delete}")
+                with pytest.raises(HTTPStatusError) as excinfo_del:
+                    nc_client.notes_get_note(note_id=note_id_to_delete)
+                assert excinfo_del.value.response.status_code == 404
+                print(f"Reading deleted note ID: {note_id_to_delete} correctly failed with 404.")
+
+            except HTTPStatusError as e:
+                # If deletion fails unexpectedly, log it but don't fail the test here
+                # as the primary goal was CRUD, and cleanup failure is secondary.
+                print(f"Error during cleanup (deleting note {note_id_to_delete}): {e}")
+            except Exception as e:
+                print(f"Unexpected error during cleanup: {e}")
+        else:
+            print("Skipping delete step as note creation might have failed or ID was not available.")
+
+@pytest.mark.integration
+def test_delete_nonexistent_note(nc_client: NextcloudClient):
+    """Test deleting a note that doesn't exist."""
+    non_existent_id = 999999999 # Use an ID highly unlikely to exist
+    print(f"\nAttempting to delete non-existent note ID: {non_existent_id}")
+    with pytest.raises(HTTPStatusError) as excinfo:
+        nc_client.notes_delete_note(note_id=non_existent_id)
+    assert excinfo.value.response.status_code == 404
+    print(f"Deleting non-existent note ID: {non_existent_id} correctly failed with 404.")