test: add unit tests for continents data and endpoints

Author: lin-raymond-dev

data/tests/test_continents.py

@@ -0,0 +1,159 @@
+"""
+Tests for the continents data module.
+"""
+import pytest
+from unittest.mock import patch, MagicMock
+from data import continents
+
+
+class TestContinents:
+    """Test class for continents module."""
+
+    def test_get_continents(self):
+        """Test getting all continents."""
+        with patch('data.db_connect.read') as mock_read:
+            mock_read.return_value = [continents.TEST_CONTINENT]
+            result = continents.get_continents()
+            mock_read.assert_called_once_with(continents.CONTINENTS_COLLECT)
+            assert result == [continents.TEST_CONTINENT]
+
+    def test_get_continent_by_name_found(self):
+        """Test getting a continent by name when it exists."""
+        with patch('data.db_connect.read_one') as mock_read_one:
+            mock_read_one.return_value = continents.TEST_CONTINENT
+            result = continents.get_continent_by_name('North America')
+            mock_read_one.assert_called_once_with(
+                continents.CONTINENTS_COLLECT,
+                {continents.CONTINENT_NAME: 'North America'}
+            )
+            assert result == continents.TEST_CONTINENT
+
+    def test_get_continent_by_name_not_found(self):
+        """Test getting a continent by name when it does not exist."""
+        with patch('data.db_connect.read_one') as mock_read_one:
+            mock_read_one.return_value = None
+            result = continents.get_continent_by_name('Atlantis')
+            assert result is None
+
+    def test_add_continent_success(self):
+        """Test successfully adding a new continent."""
+        with patch('data.continents.get_continent_by_name') as mock_get, \
+             patch('data.db_connect.create') as mock_create:
+            mock_get.return_value = None
+            mock_result = MagicMock()
+            mock_result.acknowledged = True
+            mock_create.return_value = mock_result
+
+            data = {continents.CONTINENT_NAME: 'North America'}
+            result = continents.add_continent(data)
+
+            assert result is True
+            mock_create.assert_called_once()
+            doc = mock_create.call_args[0][1]
+            assert 'created_at' in doc and 'updated_at' in doc
+            import datetime as _dt
+            assert isinstance(doc['created_at'], _dt.datetime)
+            assert isinstance(doc['updated_at'], _dt.datetime)
+
+    def test_add_continent_missing_required_field(self):
+        """Test adding a continent without continent_name raises ValueError."""
+        with pytest.raises(ValueError, match="Missing required field"):
+            continents.add_continent({})
+
+    def test_add_continent_invalid_name(self):
+        """Test adding a continent with an invalid name raises ValueError."""
+        with pytest.raises(ValueError, match="Invalid continent"):
+            continents.add_continent({continents.CONTINENT_NAME: 'Atlantis'})
+
+    def test_add_continent_already_exists(self):
+        """Test adding a continent that already exists raises ValueError."""
+        with patch('data.continents.get_continent_by_name') as mock_get:
+            mock_get.return_value = continents.TEST_CONTINENT
+            with pytest.raises(ValueError, match="already exists"):
+                continents.add_continent({continents.CONTINENT_NAME: 'North America'})
+
+    def test_add_continent_strips_timestamps(self):
+        """Test that client-supplied timestamps are overwritten."""
+        with patch('data.continents.get_continent_by_name') as mock_get, \
+             patch('data.db_connect.create') as mock_create:
+            mock_get.return_value = None
+            ack = MagicMock()
+            ack.acknowledged = True
+            mock_create.return_value = ack
+
+            data = {
+                continents.CONTINENT_NAME: 'Asia',
+                'created_at': '1999-01-01',
+                'updated_at': '1999-01-01',
+            }
+            continents.add_continent(data)
+
+            doc = mock_create.call_args[0][1]
+            assert doc['created_at'] != '1999-01-01'
+            assert doc['updated_at'] != '1999-01-01'
+
+    def test_update_continent_success(self):
+        """Test successfully updating a continent."""
+        with patch('data.continents.get_continent_by_name') as mock_get, \
+             patch('data.db_connect.update') as mock_update:
+            mock_get.return_value = continents.TEST_CONTINENT
+            mock_result = MagicMock()
+            mock_result.modified_count = 1
+            mock_update.return_value = mock_result
+
+            result = continents.update_continent('North America', {})
+            assert result is True
+            mock_update.assert_called_once()
+
+    def test_update_continent_not_found(self):
+        """Test updating a continent that does not exist returns False."""
+        with patch('data.continents.get_continent_by_name') as mock_get:
+            mock_get.return_value = None
+            result = continents.update_continent('Atlantis', {})
+            assert result is False
+
+    def test_update_continent_name_not_changed(self):
+        """Test that update_continent keeps the original name regardless of input."""
+        with patch('data.continents.get_continent_by_name') as mock_get, \
+             patch('data.db_connect.update') as mock_update:
+            mock_get.return_value = continents.TEST_CONTINENT
+            mock_result = MagicMock()
+            mock_result.modified_count = 1
+            mock_update.return_value = mock_result
+
+            continents.update_continent('North America', {continents.CONTINENT_NAME: 'Asia'})
+
+            doc = mock_update.call_args[0][2]
+            assert doc[continents.CONTINENT_NAME] == 'North America'
+
+    def test_delete_continent_success(self):
+        """Test successfully deleting a continent with no dependent countries."""
+        with patch('data.countries.get_countries_by_continent') as mock_countries, \
+             patch('data.db_connect.delete') as mock_delete:
+            mock_countries.return_value = []
+            mock_delete.return_value = 1
+
+            result = continents.delete_continent('Antarctica')
+            assert result is True
+            mock_delete.assert_called_once_with(
+                continents.CONTINENTS_COLLECT,
+                {continents.CONTINENT_NAME: 'Antarctica'}
+            )
+
+    def test_delete_continent_not_found(self):
+        """Test deleting a continent that does not exist returns False."""
+        with patch('data.countries.get_countries_by_continent') as mock_countries, \
+             patch('data.db_connect.delete') as mock_delete:
+            mock_countries.return_value = []
+            mock_delete.return_value = 0
+
+            result = continents.delete_continent('Antarctica')
+            assert result is False
+
+    def test_delete_continent_with_countries(self):
+        """Test that deleting a continent with countries raises ValueError."""
+        with patch('data.countries.get_countries_by_continent') as mock_countries:
+            mock_countries.return_value = [{'country_name': 'Canada'}, {'country_name': 'USA'}]
+
+            with pytest.raises(ValueError, match="Cannot delete"):
+                continents.delete_continent('North America')

server/tests/test_continents_endpoints.py

@@ -0,0 +1,193 @@
+"""
+Tests for continents API endpoints.
+"""
+import json
+import pytest
+from unittest.mock import patch
+from http import HTTPStatus
+from server.app import create_app
+from data import continents
+
+
+class TestContinentsEndpoints:
+    """Test class for continents API endpoints."""
+
+    @pytest.fixture
+    def client(self):
+        """Create a test client."""
+        app = create_app()
+        app.config['TESTING'] = True
+        with app.test_client() as client:
+            yield client
+
+    @pytest.fixture
+    def sample_continent(self):
+        return {'continent_name': 'Asia'}
+
+    # --- GET /continents ---
+
+    def test_get_all_continents_success(self, client):
+        """GET /continents returns list of all continents."""
+        with patch('data.continents.get_continents') as mock_get:
+            mock_get.return_value = [continents.TEST_CONTINENT]
+            response = client.get('/continents')
+            assert response.status_code == HTTPStatus.OK
+            data = response.get_json()
+            assert isinstance(data, list)
+            assert len(data) == 1
+            mock_get.assert_called_once()
+
+    def test_get_all_continents_with_pagination(self, client):
+        """GET /continents supports limit and offset query parameters."""
+        two_continents = [
+            {'continent_name': 'Africa'},
+            {'continent_name': 'Asia'},
+        ]
+        with patch('data.continents.get_continents') as mock_get:
+            mock_get.return_value = two_continents
+            response = client.get('/continents?limit=1&offset=1')
+            assert response.status_code == HTTPStatus.OK
+            data = response.get_json()
+            assert len(data) == 1
+            assert data[0]['continent_name'] == 'Asia'
+
+    def test_get_all_continents_invalid_limit(self, client):
+        """GET /continents?limit=-1 returns 400."""
+        response = client.get('/continents?limit=-1')
+        assert response.status_code == HTTPStatus.BAD_REQUEST
+
+    def test_get_all_continents_db_error(self, client):
+        """GET /continents returns 500 on database error."""
+        with patch('data.continents.get_continents') as mock_get:
+            mock_get.side_effect = Exception('DB connection failed')
+            response = client.get('/continents')
+            assert response.status_code == HTTPStatus.INTERNAL_SERVER_ERROR
+
+    # --- POST /continents ---
+
+    def test_create_continent_success(self, client, sample_continent):
+        """POST /continents creates a new continent and returns 201."""
+        with patch('data.continents.add_continent') as mock_add:
+            mock_add.return_value = True
+            response = client.post(
+                '/continents',
+                data=json.dumps(sample_continent),
+                content_type='application/json'
+            )
+            assert response.status_code == HTTPStatus.CREATED
+            data = response.get_json()
+            assert data['continent_name'] == 'Asia'
+            mock_add.assert_called_once_with(sample_continent)
+
+    def test_create_continent_invalid_name(self, client):
+        """POST /continents with invalid continent_name returns 400."""
+        response = client.post(
+            '/continents',
+            data=json.dumps({'continent_name': 'Atlantis'}),
+            content_type='application/json'
+        )
+        assert response.status_code == HTTPStatus.BAD_REQUEST
+
+    def test_create_continent_already_exists(self, client, sample_continent):
+        """POST /continents with duplicate name returns 409."""
+        with patch('data.continents.add_continent') as mock_add:
+            mock_add.side_effect = ValueError("Continent 'Asia' already exists")
+            response = client.post(
+                '/continents',
+                data=json.dumps(sample_continent),
+                content_type='application/json'
+            )
+            assert response.status_code == HTTPStatus.CONFLICT
+
+    def test_create_continent_db_error(self, client, sample_continent):
+        """POST /continents returns 500 on unexpected database error."""
+        with patch('data.continents.add_continent') as mock_add:
+            mock_add.side_effect = Exception('DB write failed')
+            response = client.post(
+                '/continents',
+                data=json.dumps(sample_continent),
+                content_type='application/json'
+            )
+            assert response.status_code == HTTPStatus.INTERNAL_SERVER_ERROR
+
+    # --- GET /continents/<name> ---
+
+    def test_get_continent_success(self, client):
+        """GET /continents/<name> returns the continent."""
+        with patch('data.continents.get_continent_by_name') as mock_get:
+            mock_get.return_value = continents.TEST_CONTINENT
+            response = client.get('/continents/North America')
+            assert response.status_code == HTTPStatus.OK
+            data = response.get_json()
+            assert data['continent_name'] == continents.TEST_CONTINENT['continent_name']
+
+    def test_get_continent_not_found(self, client):
+        """GET /continents/<name> returns 404 when not found."""
+        with patch('data.continents.get_continent_by_name') as mock_get:
+            mock_get.return_value = None
+            response = client.get('/continents/Atlantis')
+            assert response.status_code == HTTPStatus.NOT_FOUND
+
+    def test_get_continent_db_error(self, client):
+        """GET /continents/<name> returns 500 on database error."""
+        with patch('data.continents.get_continent_by_name') as mock_get:
+            mock_get.side_effect = Exception('DB error')
+            response = client.get('/continents/Asia')
+            assert response.status_code == HTTPStatus.INTERNAL_SERVER_ERROR
+
+    # --- PUT /continents/<name> ---
+
+    def test_update_continent_success(self, client):
+        """PUT /continents/<name> returns 204 on success."""
+        with patch('data.continents.update_continent') as mock_update:
+            mock_update.return_value = True
+            response = client.put('/continents/Asia')
+            assert response.status_code == HTTPStatus.NO_CONTENT
+
+    def test_update_continent_not_found(self, client):
+        """PUT /continents/<name> returns 404 when continent does not exist."""
+        with patch('data.continents.update_continent') as mock_update:
+            mock_update.return_value = False
+            response = client.put('/continents/Atlantis')
+            assert response.status_code == HTTPStatus.NOT_FOUND
+
+    def test_update_continent_db_error(self, client):
+        """PUT /continents/<name> returns 500 on database error."""
+        with patch('data.continents.update_continent') as mock_update:
+            mock_update.side_effect = Exception('DB error')
+            response = client.put('/continents/Asia')
+            assert response.status_code == HTTPStatus.INTERNAL_SERVER_ERROR
+
+    # --- DELETE /continents/<name> ---
+
+    def test_delete_continent_success(self, client):
+        """DELETE /continents/<name> returns 204 on success."""
+        with patch('data.continents.delete_continent') as mock_delete:
+            mock_delete.return_value = True
+            response = client.delete('/continents/Antarctica')
+            assert response.status_code == HTTPStatus.NO_CONTENT
+
+    def test_delete_continent_not_found(self, client):
+        """DELETE /continents/<name> returns 404 when not found."""
+        with patch('data.continents.delete_continent') as mock_delete:
+            mock_delete.return_value = False
+            response = client.delete('/continents/Atlantis')
+            assert response.status_code == HTTPStatus.NOT_FOUND
+
+    def test_delete_continent_with_countries(self, client):
+        """DELETE /continents/<name> returns 409 when countries reference it."""
+        with patch('data.continents.delete_continent') as mock_delete:
+            mock_delete.side_effect = ValueError(
+                'Cannot delete: 3 country/countries reference this continent'
+            )
+            response = client.delete('/continents/Africa')
+            assert response.status_code == HTTPStatus.CONFLICT
+            data = response.get_json()
+            assert 'Cannot delete' in data['message']
+
+    def test_delete_continent_db_error(self, client):
+        """DELETE /continents/<name> returns 500 on unexpected error."""
+        with patch('data.continents.delete_continent') as mock_delete:
+            mock_delete.side_effect = Exception('DB error')
+            response = client.delete('/continents/Asia')
+            assert response.status_code == HTTPStatus.INTERNAL_SERVER_ERROR