Initial commit

tests/test_ddl.py

@@ -0,0 +1,182 @@
+"""Tests for DDL operations."""
+
+from sqlalchemy import select
+from sqlalchemy.engine import Engine
+
+from sqlalchemy_pgview import (
+    CreateMaterializedView,
+    CreateView,
+    DropMaterializedView,
+    DropView,
+    MaterializedView,
+    RefreshMaterializedView,
+    View,
+)
+
+
+class TestCreateView:
+    """Tests for CreateView DDL."""
+
+    def test_create_view_sql(self, pg_engine: Engine, sample_tables: tuple) -> None:
+        """Test CREATE VIEW SQL generation."""
+        users, _ = sample_tables
+        view = View(
+            "active_users",
+            select(users.c.id, users.c.name),
+        )
+
+        stmt = CreateView(view)
+        compiled = stmt.compile(dialect=pg_engine.dialect)
+        sql = str(compiled)
+
+        assert "CREATE VIEW active_users AS" in sql
+        assert "users.id" in sql
+        assert "users.name" in sql
+
+    def test_create_or_replace_view_sql(
+        self, pg_engine: Engine, sample_tables: tuple
+    ) -> None:
+        """Test CREATE OR REPLACE VIEW SQL generation."""
+        users, _ = sample_tables
+        view = View(
+            "active_users",
+            select(users.c.id),
+        )
+
+        stmt = CreateView(view, or_replace=True)
+        compiled = stmt.compile(dialect=pg_engine.dialect)
+        sql = str(compiled)
+
+        assert "CREATE OR REPLACE VIEW" in sql
+
+    def test_create_view_with_schema(
+        self, pg_engine: Engine, sample_tables: tuple
+    ) -> None:
+        """Test CREATE VIEW with schema."""
+        users, _ = sample_tables
+        view = View(
+            "active_users",
+            select(users.c.id),
+            schema="analytics",
+        )
+
+        stmt = CreateView(view)
+        compiled = stmt.compile(dialect=pg_engine.dialect)
+        sql = str(compiled)
+
+        assert "analytics.active_users" in sql
+
+
+class TestDropView:
+    """Tests for DropView DDL."""
+
+    def test_drop_view_sql(self, pg_engine: Engine) -> None:
+        """Test DROP VIEW SQL generation."""
+        stmt = DropView("test_view")
+        compiled = stmt.compile(dialect=pg_engine.dialect)
+        sql = str(compiled)
+
+        assert sql == "DROP VIEW test_view"
+
+    def test_drop_view_if_exists(self, pg_engine: Engine) -> None:
+        """Test DROP VIEW IF EXISTS."""
+        stmt = DropView("test_view", if_exists=True)
+        compiled = stmt.compile(dialect=pg_engine.dialect)
+        sql = str(compiled)
+
+        assert sql == "DROP VIEW IF EXISTS test_view"
+
+    def test_drop_view_cascade(self, pg_engine: Engine) -> None:
+        """Test DROP VIEW CASCADE."""
+        stmt = DropView("test_view", cascade=True)
+        compiled = stmt.compile(dialect=pg_engine.dialect)
+        sql = str(compiled)
+
+        assert sql == "DROP VIEW test_view CASCADE"
+
+    def test_drop_view_with_schema(self, pg_engine: Engine) -> None:
+        """Test DROP VIEW with schema."""
+        stmt = DropView("test_view", schema="analytics", if_exists=True)
+        compiled = stmt.compile(dialect=pg_engine.dialect)
+        sql = str(compiled)
+
+        assert sql == "DROP VIEW IF EXISTS analytics.test_view"
+
+
+class TestCreateMaterializedView:
+    """Tests for CreateMaterializedView DDL."""
+
+    def test_create_materialized_view_sql(
+        self, pg_engine: Engine, sample_tables: tuple
+    ) -> None:
+        """Test CREATE MATERIALIZED VIEW SQL generation."""
+        users, _ = sample_tables
+        mview = MaterializedView(
+            "user_cache",
+            select(users.c.id, users.c.name),
+            with_data=True,
+        )
+
+        stmt = CreateMaterializedView(mview)
+        compiled = stmt.compile(dialect=pg_engine.dialect)
+        sql = str(compiled)
+
+        assert "CREATE MATERIALIZED VIEW user_cache AS" in sql
+        assert "WITH DATA" in sql
+
+    def test_create_materialized_view_without_data(
+        self, pg_engine: Engine, sample_tables: tuple
+    ) -> None:
+        """Test CREATE MATERIALIZED VIEW WITH NO DATA."""
+        users, _ = sample_tables
+        mview = MaterializedView(
+            "user_cache",
+            select(users.c.id),
+            with_data=False,
+        )
+
+        stmt = CreateMaterializedView(mview)
+        compiled = stmt.compile(dialect=pg_engine.dialect)
+        sql = str(compiled)
+
+        assert "WITH NO DATA" in sql
+
+
+class TestDropMaterializedView:
+    """Tests for DropMaterializedView DDL."""
+
+    def test_drop_materialized_view_sql(self, pg_engine: Engine) -> None:
+        """Test DROP MATERIALIZED VIEW SQL generation."""
+        stmt = DropMaterializedView("test_mview", if_exists=True, cascade=True)
+        compiled = stmt.compile(dialect=pg_engine.dialect)
+        sql = str(compiled)
+
+        assert sql == "DROP MATERIALIZED VIEW IF EXISTS test_mview CASCADE"
+
+
+class TestRefreshMaterializedView:
+    """Tests for RefreshMaterializedView DDL."""
+
+    def test_refresh_materialized_view_sql(self, pg_engine: Engine) -> None:
+        """Test REFRESH MATERIALIZED VIEW SQL generation."""
+        stmt = RefreshMaterializedView("test_mview")
+        compiled = stmt.compile(dialect=pg_engine.dialect)
+        sql = str(compiled)
+
+        assert sql == "REFRESH MATERIALIZED VIEW test_mview WITH DATA"
+
+    def test_refresh_concurrently(self, pg_engine: Engine) -> None:
+        """Test REFRESH MATERIALIZED VIEW CONCURRENTLY."""
+        stmt = RefreshMaterializedView("test_mview", concurrently=True)
+        compiled = stmt.compile(dialect=pg_engine.dialect)
+        sql = str(compiled)
+
+        assert "CONCURRENTLY" in sql
+
+    def test_refresh_without_data(self, pg_engine: Engine) -> None:
+        """Test REFRESH MATERIALIZED VIEW WITH NO DATA."""
+        stmt = RefreshMaterializedView("test_mview", with_data=False)
+        compiled = stmt.compile(dialect=pg_engine.dialect)
+        sql = str(compiled)
+
+        assert "WITH NO DATA" in sql