(7/x) Refactor into a CompilationTestBase to simplify reading of tests

Remove the smoke test as this will be captured in a subsequent e2e test

Signed-off-by: Jesse Whitehouse <jesse.whitehouse@databricks.com>

Author: Jesse Whitehouse

src/databricks/sqlalchemy/test_local/test_types.py

@@ -1,7 +1,6 @@
 import enum
 
 import pytest
-from sqlalchemy.schema import Column, CreateTable, MetaData, Table
 from sqlalchemy.types import (
     BigInteger,
     Boolean,
@@ -29,11 +28,6 @@
 
 from databricks.sqlalchemy import DatabricksDialect
 
-# SchemaType is not tested because it's not used in table definitions.
-# It's used to extend behaviour of custom types.
-
-# MatchType is not tested because it cannot appear in table definitions.
-
 
 class DatabricksDataType(enum.Enum):
     """https://docs.databricks.com/en/sql/language-manual/sql-ref-datatypes.html"""
@@ -86,7 +80,28 @@ class DatabricksDataType(enum.Enum):
 _as_tuple_list = [(key, value) for key, value in camel_case_type_map.items()]
 
 
-class TestCamelCaseTypesCompilation:
+class CompilationTestBase:
+    dialect = DatabricksDialect()
+
+    def _assert_compiled_value(self, type_: TypeEngine, expected: DatabricksDataType):
+        """Assert that when type_ is compiled for the databricks dialect, it renders the DatabricksDataType name.
+
+        This method initialises the type_ with no arguments.
+        """
+        compiled_result = type_().compile(dialect=self.dialect)
+        assert compiled_result == expected.name
+
+    def _assert_compiled_value_explicit(self, type_: TypeEngine, expected: str):
+        """Assert that when type_ is compiled for the databricks dialect, it renders the expected string.
+
+        This method expects an initialised type_ so that we can test how a TypeEngine created with arguments
+        is compiled.
+        """
+        compiled_result = type_.compile(dialect=self.dialect)
+        assert compiled_result == expected
+
+
+class TestCamelCaseTypesCompilation(CompilationTestBase):
     """Per the sqlalchemy documentation[^1] here, the camel case members of sqlalchemy.types are
     are expected to work across all dialects. These tests verify that the types compile into valid
     Databricks SQL type strings. For example, the sqlalchemy.types.Integer() should compile as "INT".
@@ -97,19 +112,11 @@ class TestCamelCaseTypesCompilation:
     Note that these tests have to do with type **name** compiliation. Which is separate from actually
     mapping values between Python and Databricks.
 
+    Note: SchemaType and MatchType are not tested because it's not used in table definitions
+
     [1]: https://docs.sqlalchemy.org/en/20/core/type_basics.html#generic-camelcase-types
     """
 
-    dialect = DatabricksDialect()
-
-    def _assert_compiled_value(self, type_: TypeEngine, expected: DatabricksDataType):
-        compiled_result = type_().compile(dialect=self.dialect)
-        assert compiled_result == expected.name
-
-    def _assert_compiled_value_explicit(self, type_: TypeEngine, expected: str):
-        compiled_result = type_.compile(dialect=self.dialect)
-        assert compiled_result == expected
-
     @pytest.mark.parametrize("type_, expected", _as_tuple_list)
     def test_bare_camel_case_types_compile(self, type_, expected):
         self._assert_compiled_value(type_, expected)
@@ -119,79 +126,3 @@ def test_numeric_renders_as_decimal_with_precision(self):
 
     def test_numeric_renders_as_decimal_with_precision_and_scale(self):
         self._assert_compiled_value_explicit(Numeric(10, 2), "DECIMAL(10, 2)")
-
-    def test_create_table_with_all_types_smoke_test(self):
-        metadata = MetaData()
-        test_table = Table(
-            "abc123",
-            metadata,
-            Column("bigint_col", BigInteger()),
-            Column("boolean_col", Boolean()),
-            Column("date_col", Date()),
-            Column("datetime_col", DateTime()),
-            Column("double_col", Double()),
-            Column("enum_col", Enum("Option1", "Option2", "Option3")),
-            Column("float_col", Float()),
-            Column("integer_col", Integer()),
-            Column("interval_col", Interval()),
-            Column("large_binary_col", LargeBinary()),
-            Column("numeric_col", Numeric(precision=10, scale=2)),
-            Column("pickletype_col", PickleType()),
-            Column("smallinteger_col", SmallInteger()),
-            Column("string_col", String(length=255)),
-            Column("text_col", Text()),
-            Column("time_col", Time()),
-            Column("unicode_col", Unicode(length=255)),
-            Column("unicodetext_col", UnicodeText()),
-            Column("uuid_col", Uuid(as_uuid=True)),
-        )
-
-        create_construct = CreateTable(test_table)
-
-        generated_sql = str(create_construct.compile(dialect=self.dialect))
-
-        """
-        The generated SQL looks like this (captured 1 October 2023):
-        
-        CREATE TABLE abc123 (
-          bigint_col BIGINT, 
-          boolean_col BOOLEAN, 
-          date_col DATE, 
-          datetime_col TIMESTAMP, 
-          double_col DOUBLE, 
-          enum_col STRING, 
-          float_col FLOAT, 
-          integer_col INT, 
-          interval_col TIMESTAMP, 
-          large_binary_col BINARY, 
-          numeric_col DECIMAL(10, 2), 
-          pickletype_col BINARY, 
-          smallinteger_col SMALLINT, 
-          string_col STRING, 
-          text_col STRING, 
-          time_col STRING, 
-          unicode_col STRING, 
-          unicodetext_col STRING, 
-          uuid_col STRING
-        ) USING DELTA
-        """
-
-        assert "bigint_col BIGINT" in generated_sql
-        assert "boolean_col BOOLEAN" in generated_sql
-        assert "date_col DATE" in generated_sql
-        assert "datetime_col TIMESTAMP" in generated_sql
-        assert "double_col DOUBLE" in generated_sql
-        assert "enum_col STRING" in generated_sql
-        assert "float_col FLOAT" in generated_sql
-        assert "integer_col INT" in generated_sql
-        assert "interval_col TIMESTAMP" in generated_sql
-        assert "large_binary_col BINARY" in generated_sql
-        assert "numeric_col DECIMAL(10, 2)" in generated_sql
-        assert "pickletype_col BINARY" in generated_sql
-        assert "smallinteger_col SMALLINT" in generated_sql
-        assert "string_col STRING" in generated_sql
-        assert "text_col STRING" in generated_sql
-        assert "time_col STRING" in generated_sql
-        assert "unicode_col STRING" in generated_sql
-        assert "unicodetext_col STRING" in generated_sql
-        assert "uuid_col STRING" in generated_sql