repository
├── other_folders
├── transform
│   ├── models
│   │   └── model_a.sql
│   ├── target
│   │   ├── compiled
│   │   │   └── <project_name>
│   │   │   │   └── models
│   │   │   │   │   └── model_a.sql
│   │   └── manifest.json
│   └── dbt_project.yml
└── other_files

@dbt_source_meta(source_name="postgres", table_name="car_owner")
class PostgresCarOwner(BigQueryMockTable):
    id = col.Int(default=1)
    person_id = col.Int(default=1)
    company_id = col.Int(default=1)
    request_id = col.Int(default=1)

    plate = col.String(default="test1")

@dbt_model_meta(model_name="stg_postgres__car_owner")
class StgPostgresCarOwner(BigQueryMockTable):
    owner_id = col.Int(default=1)
    person_id = col.Int(default=1)
    company_id = col.Int(default=1)
    request_id = col.Int(default=1)

    plate = col.String(default="test1")

class TestStgPostgresCarOwner:
    def test_stg_postgres__car_owner(self):
        source_data = [{"id": 1}, {"id": 2}, {"id": 3}]
        expected_output = [{"owner_id": 1}, {"owner_id": 2}, {"owner_id": 3}]

        source = PostgresCarOwner.from_dicts(source_data)
        final = StgPostgresCarOwner.from_mocks(input_data=[source])

        final.assert_equal(expected_output)

parkdepot/.venv/lib/python3.9/site-packages/_pytest/assertion/rewrite.py:178: in exec_module
    exec(co, module.__dict__)
parkdepot/repository_parkdepot_tests/dbt/staging/postgres/test_stg_postgres__car_owner.py:2: in <module>
    from repository_parkdepot_tests.dbt.staging.postgres.mocked_stg_postgres__car_owner import StgPostgresCarOwner
parkdepot/repository_parkdepot_tests/dbt/staging/postgres/mocked_stg_postgres__car_owner.py:7: in <module>
    class StgPostgresCarOwner(BigQueryMockTable):
parkdepot/.venv/lib/python3.9/site-packages/sql_mock/dbt.py:101: in decorator
    dbt_meta = _get_model_metadata_from_dbt_manifest(manifest_path=path, model_name=model_name)
parkdepot/.venv/lib/python3.9/site-packages/sql_mock/dbt.py:31: in _get_model_metadata_from_dbt_manifest
    "table_ref": node["relation_name"],
E   KeyError: 'relation_name'

class StringArray(col.ClickhouseColumnMock):
    dtype = "Array(String)"

    def to_sql(self, column_name: str, value=NO_INPUT) -> str:
        # Note: Compare against NO_INPUT instead of checking for None since None could be a valid input for nullable columns
        val = value if not isinstance(value, NoInput) else self.default
        # In case the val is None, we convert it to NULL
        if val is None:
            return f"cast(NULL AS {self.dtype}) AS {column_name}"
        return f"cast({val} AS {self.dtype}) AS {column_name}" 

self = <sqlglot.generator.Generator object at 0x107920d60>
expression = ('argMax', 'If'), key = None, comment = True

    def sql(
        self,
        expression: t.Optional[str | exp.Expression],
        key: t.Optional[str] = None,
        comment: bool = True,
    ) -> str:
        if not expression:
            return ""
    
        if isinstance(expression, str):
            return expression
    
        if key:
            value = expression.args.get(key)
            if value:
                return self.sql(value)
            return ""
    
        transform = self.TRANSFORMS.get(expression.__class__)
    
        if callable(transform):
            sql = transform(self, expression)
        elif transform:
            sql = transform
        elif isinstance(expression, exp.Expression):
            exp_handler_name = f"{expression.key}_sql"
    
            if hasattr(self, exp_handler_name):
                sql = getattr(self, exp_handler_name)(expression)
            elif isinstance(expression, exp.Func):
                sql = self.function_fallback_sql(expression)
            elif isinstance(expression, exp.Property):
                sql = self.property_sql(expression)
            else:
                raise ValueError(f"Unsupported expression type {expression.__class__.__name__}")
        else:
>           raise ValueError(f"Expected an Expression. Received {type(expression)}: {expression}")
E           ValueError: Expected an Expression. Received <class 'tuple'>: ('argMax', 'If')

# assuming we've successfully ran TableMock.from_mocks() we currently do

TableMock.assert_equal(expected_dict)

# I propose the following which allows de the developer to use other assertion tools
res_dict = TableMock.generate_result()

query = TableMock._sql_mock_data.last_query # I can inspect the query even before it fails if I want to

unittest.TestCase.assertDictEqual(res_dict, expected_dict) # I do my own assertion with whatever library I chose

.../sql_mock/table_mocks.py:315: in assert_equal
    self._assert_equal(
.../sql_mock/table_mocks.py:259: in _assert_equal
>           expected = sorted(expected, key=lambda d: sorted(d.items()))
E           TypeError: '<' not supported between instances of 'str' and 'NoneType'
.../sql_mock/table_mocks.py:259: TypeError

expected_output = [{'foo': 'bar'}, {'foo': None}]
mock_table.assert_equal(expected) # raises TypeError (see above)

QUERY_SIMPLE = """
SELECT col1
FROM bee as b 
JOIN a ON a.col1 = b.col1
"""

@table_meta(table_ref="a")
class aMock(ClickHouseTableMock):
    col1 = col.String(default="1")

@table_meta(table_ref="bee")
class bMock(ClickHouseTableMock):
    col1 = col.String(default="1")

@table_meta(query=QUERY_SIMPLE)
class BugTableMock(ClickHouseTableMock):
    col1 = col.String(default="1")

and test:

    def test_working():
    input_table_mock_1 = aMock()
    input_table_mock_2 = bMock()

    res = BugTableMock.from_mocks(input_data=[
        input_table_mock_1, input_table_mock_2])

    expected = [{'col1': '1'}]
    res.assert_equal(expected)

Yields error ` Cannot get JOIN keys from JOIN ON section: 'a.col1 = col1', found keys: [Left keys: [] Right keys [] Condition columns: 'equals(a.col1, col1)', '']. (INVALID_JOIN_ON_EXPRESSION) (version 23.8.4.69 (official build))`

Internal sql_mock cte is:

   WITH sql_mock__a AS (
 SELECT
   CAST('1' AS String) AS col1
 FROM (
   SELECT
     1
 )
 WHERE
   FALSE
), sql_mock__bee AS (
 SELECT
   CAST('1' AS String) AS col1
 FROM (
   SELECT
     1
 )
 WHERE
   FALSE
), result AS (
 SELECT
   col1
 FROM sql_mock__bee AS b /* bee */
 JOIN sql_mock__a /* a */
   ON a.col1 = b.col1
)
SELECT
 CAST(col1 AS String) AS col1
FROM result