Merge pull request #5 from MaterializeInc/fix-tests

Fix failing Materialize backend tests

Author: jasonhernandez

ibis/backends/materialize/tests/conftest.py

@@ -150,13 +150,13 @@ def temp_table(con) -> str:  # noqa: ARG001
 
 
 @pytest.fixture
-def assert_sql(con):  # noqa: ARG001
+def assert_sql(con):
     """Fixture for asserting SQL compilation."""
-    from ibis import to_sql
 
     def check_sql(expr):
-        """Check that expression can be compiled to SQL."""
-        sql = to_sql(expr, dialect="postgres")  # Materialize uses postgres dialect
+        """Check that expression can be compiled to SQL using Materialize backend."""
+        # Use the Materialize backend's compiler, not the generic postgres dialect
+        sql = con.compile(expr)
         assert sql is not None
         assert isinstance(sql, str)
         assert len(sql) > 0

ibis/backends/materialize/tests/test_compiler.py

@@ -164,24 +164,31 @@ def test_date_literal_cast(assert_sql):
 
 
 def test_timestamp_from_unix_seconds(simple_table, assert_sql):
-    """Test timestamp from Unix seconds uses to_timestamp()."""
-    expr = simple_table.mutate(ts=simple_table.id.to_timestamp())
+    """Test timestamp from Unix seconds uses to_timestamp().
+
+    Uses as_timestamp('s') method to convert Unix timestamps.
+    """
+    expr = simple_table.mutate(ts=simple_table.id.as_timestamp("s"))
     assert_sql(expr)
 
 
 def test_timestamp_from_unix_milliseconds(simple_table, assert_sql):
-    """Test timestamp from Unix milliseconds converts to seconds."""
-    expr = simple_table.mutate(ts=simple_table.id.to_timestamp(unit="ms"))
+    """Test timestamp from Unix milliseconds converts to seconds.
+
+    Uses as_timestamp('ms') method which divides by 1000 before calling to_timestamp().
+    """
+    expr = simple_table.mutate(ts=simple_table.id.as_timestamp("ms"))
     assert_sql(expr)
 
 
-def test_json_extract_with_path_operator(assert_sql):
-    """Test JSON extraction uses #>> operator for text.
+def test_json_extract_with_cast_to_string(assert_sql):
+    """Test JSON extraction can be converted to text using cast.
 
-    Materialize doesn't have json_extract_path_text, so we use the #>> operator.
+    Materialize doesn't have json_extract_path_text, but we can use
+    bracket notation and cast to string.
     """
     t = ibis.table({"json_col": "json"}, name="json_table")
-    expr = t.mutate(extracted=t.json_col["field1"]["field2"].as_text())
+    expr = t.mutate(extracted=t.json_col["field1"]["field2"].cast("string"))
     assert_sql(expr)
 
 
@@ -247,17 +254,23 @@ def test_date_now_operation(simple_table, assert_sql):
 
 
 def test_interval_from_integer_days(simple_table, assert_sql):
-    """Test creating interval from integer (days)."""
+    """Test creating interval from integer (days).
+
+    Uses as_interval('D') method to convert integers to day intervals.
+    """
     expr = simple_table.mutate(
-        future=simple_table.date_col + simple_table.id.to_interval(unit="D")
+        future=simple_table.date_col + simple_table.id.as_interval("D")
     )
     assert_sql(expr)
 
 
 def test_interval_from_integer_hours(simple_table, assert_sql):
-    """Test creating interval from integer (hours)."""
+    """Test creating interval from integer (hours).
+
+    Uses as_interval('h') method to convert integers to hour intervals.
+    """
     expr = simple_table.mutate(
-        future=simple_table.timestamp_col + simple_table.id.to_interval(unit="h")
+        future=simple_table.timestamp_col + simple_table.id.as_interval("h")
     )
     assert_sql(expr)
 

ibis/backends/materialize/tests/test_mz_now.py

@@ -6,8 +6,8 @@
 
 import ibis
 import ibis.expr.datatypes as dt
-from ibis.backends.materialize.api import mz_now
 from ibis.backends.materialize import operations as mz_ops
+from ibis.backends.materialize.api import mz_now
 
 
 class TestMzNowOperation:
@@ -112,17 +112,18 @@ def test_execute_mz_now(self, con):
         assert isinstance(result, (pd.Timestamp, str))
 
     def test_mz_now_vs_now(self, con):
-        """Test that mz_now() and now() return different values."""
+        """Test that mz_now() and now() return different timestamps."""
         mz_now_result = con.execute(mz_now())
         now_result = con.execute(ibis.now())
 
         # Both should return timestamps
         assert mz_now_result is not None
         assert now_result is not None
 
-        # The docstring should clarify they're different
-        assert "logical" in con.mz_now.__doc__.lower()
-        assert "system clock" in con.mz_now.__doc__.lower()
+        # The mz_now() function docstring should clarify they're different
+        assert "logical" in mz_now.__doc__.lower()
+        # The docstring explains it's different from now() (system clock)
+        assert "now()" in mz_now.__doc__.lower()
 
     def test_mz_now_in_table_query(self, con):
         """Test mz_now() in a table query."""

ibis/backends/materialize/tests/test_sources.py

@@ -64,7 +64,7 @@ def test_create_auction_source_with_all_tables(self, con):
             assert source_name in con.list_sources()
 
             # Wait for data to generate (auction needs more time than counter)
-            time.sleep(1.5)
+            time.sleep(3.0)
 
             # Query the bids subsource
             bids = con.table("bids")