add new

apps/tests/conftest.py

@@ -0,0 +1,56 @@
+import pytest
+from unittest.mock import MagicMock
+from flask import Flask
+
+
+@pytest.fixture
+def app():
+    """Create Flask test app"""
+    app = Flask(__name__)
+    app.config["TESTING"] = True
+    return app
+
+
+@pytest.fixture
+def client(app):
+    """Create Flask test client"""
+    return app.test_client()
+
+
+@pytest.fixture
+def mock_db_connection():
+    """Mock database connection"""
+    mock_conn = MagicMock()
+    mock_cursor = MagicMock()
+
+    mock_conn.__enter__ = MagicMock(return_value=mock_conn)
+    mock_conn.__exit__ = MagicMock(return_value=False)
+    mock_conn.cursor.return_value.__enter__ = MagicMock(return_value=mock_cursor)
+    mock_conn.cursor.return_value.__exit__ = MagicMock(return_value=False)
+
+    return mock_conn, mock_cursor
+
+
+@pytest.fixture
+def sample_user_data():
+    """Sample user data for testing"""
+    return {
+        "name": "John Doe",
+        "email": "john@example.com",
+        "dob": "1990-01-01",
+        "gender": "male"
+    }
+
+
+@pytest.fixture
+def sample_filter_params():
+    """Sample filter parameters for testing"""
+    return {
+        "page": 0,
+        "size": 8,
+        "asc": "false",
+        "filter[keyword]": "test",
+        "filter[name]": "John",
+        "filter[email]": "john@example.com",
+        "filter[gender]": "male",
+    }

apps/tests/test_filter_insert.py

@@ -0,0 +1,357 @@
+import pytest
+from unittest.mock import MagicMock, patch
+
+
+class TestMain:
+    """Test cases for the main() function"""
+
+    @patch("filter_insert.make_filter_request")
+    def test_main_get_method(self, mock_filter_request):
+        """Test main() with GET method calls make_filter_request()"""
+        from flask import Flask
+        from filter_insert import main
+
+        # Create a test app context
+        app = Flask(__name__)
+        with app.test_request_context("/ai/admin/users", method="GET"):
+            mock_filter_request.return_value = ({"data": "test"}, 200, {})
+            result = main()
+
+        mock_filter_request.assert_called_once()
+        assert result == ({"data": "test"}, 200, {})
+
+    @patch("filter_insert.make_insert_request")
+    def test_main_post_method(self, mock_insert_request):
+        """Test main() with POST method calls make_insert_request()"""
+        from flask import Flask
+        from filter_insert import main
+
+        app = Flask(__name__)
+        with app.test_request_context("/ai/admin/users", method="POST", json={"name": "Test", "email": "test@example.com"}):
+            mock_insert_request.return_value = ({"id": "123"}, 201, {})
+            result = main()
+
+        mock_insert_request.assert_called_once()
+        assert result == ({"id": "123"}, 201, {})
+
+    def test_main_method_not_allowed(self):
+        """Test main() with unsupported HTTP method returns 405"""
+        from flask import Flask
+        from filter_insert import main, CORS_HEADERS
+
+        app = Flask(__name__)
+        with app.test_request_context("/ai/admin/users", method="PUT"):
+            result = main()
+
+        expected = ({"error": "Method not allow"}, 405, CORS_HEADERS)
+        assert result == expected
+
+    def test_main_exception_handling(self):
+        """Test main() catches exceptions and returns 500"""
+        from flask import Flask
+        from filter_insert import main
+
+        app = Flask(__name__)
+
+        with patch("filter_insert.make_filter_request") as mock_filter:
+            mock_filter.side_effect = Exception("Database connection failed")
+            with app.test_request_context("/ai/admin/users", method="GET"):
+                result = main()
+
+        assert result[1] == 500
+        assert "error" in result[0]
+
+
+class TestMakeInsertRequest:
+    """Test cases for make_insert_request() function"""
+
+    @patch("filter_insert.init_db_connection")
+    @patch("filter_insert.request")
+    @patch("filter_insert.db_row_to_dict")
+    def test_make_insert_request_success(self, mock_db_row, mock_request, mock_init_db):
+        """Test successful user insertion"""
+        from flask import Flask
+        from filter_insert import make_insert_request, CORS_HEADERS
+
+        app = Flask(__name__)
+
+        mock_request.get_json.return_value = {
+            "name": "John Doe",
+            "email": "john@example.com",
+            "dob": "1990-01-01",
+            "gender": "male"
+        }
+
+        mock_conn = MagicMock()
+        mock_cursor = MagicMock()
+        mock_cursor.fetchone.return_value = ("uuid-123", "John Doe", "1990-01-01", "john@example.com", "male", "2024-01-01", "2024-01-01")
+        mock_cursor.description = [
+            MagicMock(name="id"),
+            MagicMock(name="name"),
+            MagicMock(name="dob"),
+            MagicMock(name="email"),
+            MagicMock(name="gender"),
+            MagicMock(name="created"),
+            MagicMock(name="modified"),
+        ]
+        mock_conn.__enter__ = MagicMock(return_value=mock_conn)
+        mock_conn.__exit__ = MagicMock(return_value=False)
+        mock_conn.cursor.return_value.__enter__ = MagicMock(return_value=mock_cursor)
+        mock_conn.cursor.return_value.__exit__ = MagicMock(return_value=False)
+        mock_init_db.return_value = mock_conn
+        mock_db_row.return_value = {"id": "uuid-123", "name": "John Doe"}
+
+        with app.test_request_context("/ai/admin/users", method="POST", json=mock_request.get_json.return_value):
+            result = make_insert_request()
+
+        assert result[1] == 201
+        assert result[2] == CORS_HEADERS
+
+    @patch("filter_insert.request")
+    def test_make_insert_request_validation_error(self, mock_request):
+        """Test make_insert_request() with invalid data returns 400"""
+        from flask import Flask
+        from filter_insert import make_insert_request, CORS_HEADERS
+
+        app = Flask(__name__)
+
+        # Invalid email format
+        mock_request.get_json.return_value = {
+            "name": "John Doe",
+            "email": "invalid-email"
+        }
+
+        with app.test_request_context("/ai/admin/users", method="POST", json=mock_request.get_json.return_value):
+            result = make_insert_request()
+
+        assert result[1] == 400
+        assert result[0].json["errorCode"] == "VALIDATION_ERROR"
+        assert result[2] == CORS_HEADERS
+
+    @patch("filter_insert.init_db_connection")
+    @patch("filter_insert.request")
+    def test_make_insert_request_duplicate_error(self, mock_request, mock_init_db):
+        """Test make_insert_request() with duplicate email returns 409"""
+        from flask import Flask
+        from filter_insert import make_insert_request, CORS_HEADERS
+        from psycopg2 import IntegrityError
+
+        app = Flask(__name__)
+
+        mock_request.get_json.return_value = {
+            "name": "John Doe",
+            "email": "john@example.com"
+        }
+
+        mock_conn = MagicMock()
+        mock_cursor = MagicMock()
+        mock_conn.__enter__ = MagicMock(return_value=mock_conn)
+        mock_conn.__exit__ = MagicMock(return_value=False)
+        mock_conn.cursor.return_value.__enter__ = MagicMock(return_value=mock_cursor)
+        mock_conn.cursor.return_value.__exit__ = MagicMock(return_value=False)
+        mock_init_db.return_value = mock_conn
+
+        # Simulate IntegrityError
+        mock_cursor.execute.side_effect = IntegrityError("duplicate key value violates unique constraint")
+
+        with app.test_request_context("/ai/admin/users", method="POST", json=mock_request.get_json.return_value):
+            result = make_insert_request()
+
+        assert result[1] == 409
+        assert result[0].json["errorCode"] == "DUPLICATE_TAG"
+        assert result[2] == CORS_HEADERS
+
+
+class TestMakeFilterRequest:
+    """Test cases for make_filter_request() function"""
+
+    @patch("filter_insert.init_db_connection")
+    @patch("filter_insert.request")
+    @patch("filter_insert.UserPage")
+    @patch("filter_insert.db_rows_to_array")
+    def test_make_filter_request_success(self, mock_db_rows, mock_page_class, mock_request, mock_init_db):
+        """Test successful filter request"""
+        from flask import Flask
+        from filter_insert import make_filter_request
+
+        app = Flask(__name__)
+
+        mock_paging = MagicMock()
+        mock_paging.size = 8
+        mock_paging.page = 0
+        mock_paging.filter = MagicMock()
+        mock_paging.filter.ids = None
+        mock_paging.filter.keyword = None
+        mock_paging.filter.name = None
+        mock_paging.filter.email = None
+        mock_paging.filter.created_from = None
+        mock_paging.filter.created_to = None
+        mock_paging.filter.modified_from = None
+        mock_paging.filter.modified_to = None
+        mock_paging.filter.dob_from = None
+        mock_paging.filter.dob_to = None
+        mock_paging.sortby = None
+        mock_paging.asc = None
+        mock_page_class.from_request_queries.return_value = mock_paging
+
+        mock_request.args.get.return_value = None
+
+        mock_conn = MagicMock()
+        mock_cursor = MagicMock()
+        mock_cursor.fetchall.return_value = []
+        mock_conn.cursor.return_value = mock_cursor
+        mock_init_db.return_value = mock_conn
+
+        mock_db_rows.return_value = []
+
+        with app.test_request_context("/ai/admin/users?page=0&size=8"):
+            result = make_filter_request()
+
+        assert result[1] == 200
+        mock_db_rows.assert_called_once()
+
+
+class TestUserFilter:
+    """Test cases for UserFilter.from_request_queries()"""
+
+    @patch("filter_insert.request")
+    def test_user_filter_from_queries(self, mock_request):
+        """Test UserFilter parses query parameters correctly"""
+        from filter_insert import UserFilter
+
+        mock_request.args.get.side_effect = lambda key, default=None: {
+            "filter[ids]": None,
+            "filter[keyword]": "test",
+            "filter[name]": "John",
+            "filter[email]": "john@example.com",
+            "filter[gender]": "male",
+            "filter[created_from]": "2024-01-01",
+            "filter[created_to]": "2024-12-31",
+            "filter[modified_from]": None,
+            "filter[modified_to]": None,
+            "filter[dob_from]": None,
+            "filter[dob_to]": None,
+        }.get(key, default)
+
+        mock_request.args.getlist.return_value = []
+
+        result = UserFilter.from_request_queries()
+
+        assert result.keyword == "test"
+        assert result.name == "John"
+        assert result.email == "john@example.com"
+        assert result.gender == "male"
+        assert result.created_from == "2024-01-01"
+        assert result.created_to == "2024-12-31"
+
+
+class TestPage:
+    """Test cases for Page.from_request_queries()"""
+
+    @patch("filter_insert.request")
+    def test_page_default_values(self, mock_request):
+        """Test Page uses default values when params not provided"""
+        from filter_insert import Page
+
+        mock_request.args.get.side_effect = lambda key, default=None, type=None: {
+            "page": 0,
+            "size": 8,
+            "asc": "false",
+        }.get(key, default)
+
+        result = Page.from_request_queries()
+
+        assert result.page == 0
+        assert result.size == 8
+        assert result.asc is False
+
+
+class TestUserPage:
+    """Test cases for UserPage.from_request_queries()"""
+
+    @patch("filter_insert.request")
+    def test_user_page_with_sortby(self, mock_request):
+        """Test UserPage parses sortby parameter correctly"""
+        from filter_insert import UserPage, UserSortField
+
+        # Simulate request.args.get behavior
+        def mock_get(key, default=None, type=None):
+            values = {
+                "page": 0,
+                "size": 8,
+                "asc": "true",
+                "sortby": "created",
+            }
+            return values.get(key, default)
+
+        mock_request.args.get = mock_get
+        mock_request.args.getlist.return_value = []
+
+        result = UserPage.from_request_queries()
+
+        assert result.sortby == UserSortField.CREATED
+        assert result.asc is True
+
+    @patch("filter_insert.request")
+    def test_user_page_invalid_sortby(self, mock_request):
+        """Test UserPage handles invalid sortby gracefully"""
+        from filter_insert import UserPage
+
+        def mock_get(key, default=None, type=None):
+            values = {
+                "page": 0,
+                "size": 8,
+                "asc": "false",
+                "sortby": "invalid_field",
+            }
+            return values.get(key, default)
+
+        mock_request.args.get = mock_get
+        mock_request.args.getlist.return_value = []
+
+        result = UserPage.from_request_queries()
+
+        assert result.sortby is None
+
+
+class TestUserSortField:
+    """Test cases for UserSortField enum"""
+
+    def test_user_sort_field_values(self):
+        """Test UserSortField has correct values"""
+        from filter_insert import UserSortField
+
+        assert UserSortField.CREATED.value == "created"
+        assert UserSortField.MODIFIED.value == "modified"
+
+
+class TestHelpers:
+    """Test cases for helper functions"""
+
+    def test_str_to_bool_true(self):
+        """Test str_to_bool with true values"""
+        from helpers import str_to_bool
+
+        assert str_to_bool("true") is True
+        assert str_to_bool("True") is True
+        assert str_to_bool("TRUE") is True
+
+    def test_str_to_bool_false(self):
+        """Test str_to_bool with false values"""
+        from helpers import str_to_bool
+
+        assert str_to_bool("false") is False
+        assert str_to_bool("False") is False
+        assert str_to_bool("FALSE") is False
+
+    def test_str_to_bool_none(self):
+        """Test str_to_bool with invalid values returns None"""
+        from helpers import str_to_bool
+
+        assert str_to_bool("invalid") is None
+        assert str_to_bool("") is None
+        assert str_to_bool(None) is None
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])