Skip to content

[Refactor] e2e Test Cases #103

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
colinthebomb1 merged 1 commit into from
Mar 31, 2026
Merged

[Refactor] e2e Test Cases #103

Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
328 changes: 317 additions & 11 deletions tests/test_parser_formatter_e2e.py
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,5 +1,6 @@
from core.query_formatter import QueryFormatter
from core.query_parser import QueryParser
from data.queries import get_query
from mo_sql_parsing import parse

formatter = QueryFormatter()
Expand All @@ -17,21 +18,326 @@ def test_basic_e2e():
"""
parsed_ast = parser.parse(original_sql)
formatted_sql = formatter.format(parsed_ast)

# test our output is semantically equivalent to input using mo_sql_parsing
assert parse(formatted_sql) == parse(original_sql)


def test_subquery_e2e():
original_sql = """
SELECT empno, firstnme, lastname, phoneno
FROM employee
WHERE workdept IN
(SELECT deptno
FROM department
WHERE deptname = 'OPERATIONS')
AND 1=1
"""
query = get_query(9)
original_sql = query["pattern"]
parsed_ast = parser.parse(original_sql)
formatted_sql = formatter.format(parsed_ast)
assert parse(formatted_sql) == parse(original_sql)


def test_query_1():
query = get_query(1)
original_sql = query["pattern"]
parsed_ast = parser.parse(original_sql)
formatted_sql = formatter.format(parsed_ast)
assert parse(formatted_sql) == parse(original_sql)


def test_query_2():
query = get_query(2)
original_sql = query["rewrite"]
parsed_ast = parser.parse(original_sql)
formatted_sql = formatter.format(parsed_ast)
assert parse(formatted_sql) == parse(original_sql)


# query 3 has the exact same query as query 2, so the query was skipped


def test_query_4():
query = get_query(4)
original_sql = query["rewrite"]
parsed_ast = parser.parse(original_sql)
formatted_sql = formatter.format(parsed_ast)
assert parse(formatted_sql) == parse(original_sql)


# query 5 has the exact same query as query 4, so the query was skipped


def test_query_6():
query = get_query(6)
original_sql = query["pattern"]
parsed_ast = parser.parse(original_sql)
formatted_sql = formatter.format(parsed_ast)
assert parse(formatted_sql) == parse(original_sql)


def test_query_7():
query = get_query(7)
original_sql = query["pattern"]
parsed_ast = parser.parse(original_sql)
formatted_sql = formatter.format(parsed_ast)
assert parse(formatted_sql) == parse(original_sql)


def test_query_8():
query = get_query(8)
original_sql = query["pattern"]
parsed_ast = parser.parse(original_sql)
formatted_sql = formatter.format(parsed_ast)
assert parse(formatted_sql) == parse(original_sql)


# query 9 is used in test_subquery_e2e


def test_query_10():
query = get_query(10)
original_sql = query["pattern"]
parsed_ast = parser.parse(original_sql)
formatted_sql = formatter.format(parsed_ast)
assert parse(formatted_sql) == parse(original_sql)


def test_query_11():
query = get_query(11)
original_sql = query["rewrite"]
parsed_ast = parser.parse(original_sql)
formatted_sql = formatter.format(parsed_ast)
assert parse(formatted_sql) == parse(original_sql)


def test_query_12():
query = get_query(12)
original_sql = query["pattern"]
parsed_ast = parser.parse(original_sql)
formatted_sql = formatter.format(parsed_ast)
assert parse(formatted_sql) == parse(original_sql)


def test_query_13():
query = get_query(13)
original_sql = query["pattern"]
parsed_ast = parser.parse(original_sql)
formatted_sql = formatter.format(parsed_ast)
assert parse(formatted_sql) == parse(original_sql)


def test_query_14():
query = get_query(14)
original_sql = query["pattern"]
parsed_ast = parser.parse(original_sql)
formatted_sql = formatter.format(parsed_ast)
assert parse(formatted_sql) == parse(original_sql)


# TODO: Query 15 uses UNION, which is not supported by parser yet


def test_query_16():
query = get_query(16)
original_sql = query["pattern"]
parsed_ast = parser.parse(original_sql)
formatted_sql = formatter.format(parsed_ast)
assert parse(formatted_sql) == parse(original_sql)


def test_query_17():
query = get_query(17)
original_sql = query["pattern"]
parsed_ast = parser.parse(original_sql)
formatted_sql = formatter.format(parsed_ast)
assert parse(formatted_sql) == parse(original_sql)


def test_query_18():
query = get_query(18)
original_sql = query["pattern"]
parsed_ast = parser.parse(original_sql)
formatted_sql = formatter.format(parsed_ast)
assert parse(formatted_sql) == parse(original_sql)


def test_query_19():
query = get_query(19)
original_sql = query["pattern"]
parsed_ast = parser.parse(original_sql)
formatted_sql = formatter.format(parsed_ast)
assert parse(formatted_sql) == parse(original_sql)


def test_query_20():
query = get_query(20)
original_sql = query["pattern"]
parsed_ast = parser.parse(original_sql)
formatted_sql = formatter.format(parsed_ast)
assert parse(formatted_sql) == parse(original_sql)


def test_query_21():
query = get_query(21)
original_sql = query["pattern"]
parsed_ast = parser.parse(original_sql)
formatted_sql = formatter.format(parsed_ast)
assert parse(formatted_sql) == parse(original_sql)


def test_query_22():
query = get_query(22)
original_sql = query["pattern"]
parsed_ast = parser.parse(original_sql)
formatted_sql = formatter.format(parsed_ast)
assert parse(formatted_sql) == parse(original_sql)


def test_query_23():
query = get_query(23)
original_sql = query["pattern"]
parsed_ast = parser.parse(original_sql)
formatted_sql = formatter.format(parsed_ast)
assert parse(formatted_sql) == parse(original_sql)


def test_query_24():
query = get_query(24)
original_sql = query["pattern"]
parsed_ast = parser.parse(original_sql)
formatted_sql = formatter.format(parsed_ast)
assert parse(formatted_sql) == parse(original_sql)


def test_query_25():
query = get_query(25)
original_sql = query["pattern"]
parsed_ast = parser.parse(original_sql)
formatted_sql = formatter.format(parsed_ast)
assert parse(formatted_sql) == parse(original_sql)


def test_query_26():
query = get_query(26)
original_sql = query["pattern"]
parsed_ast = parser.parse(original_sql)
formatted_sql = formatter.format(parsed_ast)
assert parse(formatted_sql) == parse(original_sql)


def test_query_27():
query = get_query(27)
original_sql = query["pattern"]
parsed_ast = parser.parse(original_sql)
formatted_sql = formatter.format(parsed_ast)
assert parse(formatted_sql) == parse(original_sql)


def test_query_28():
query = get_query(28)
original_sql = query["pattern"]
parsed_ast = parser.parse(original_sql)
formatted_sql = formatter.format(parsed_ast)
assert parse(formatted_sql) == parse(original_sql)


# TODO: Query 29: Full Matching: UNION not supported by parser


def test_query_30():
query = get_query(30)
original_sql = query["pattern"]
parsed_ast = parser.parse(original_sql)
formatted_sql = formatter.format(parsed_ast)
assert parse(formatted_sql) == parse(original_sql)


def test_query_31():
query = get_query(31)
original_sql = query["pattern"]
parsed_ast = parser.parse(original_sql)
formatted_sql = formatter.format(parsed_ast)
assert parse(formatted_sql) == parse(original_sql)


# TODO: Query 32: UNION not supported by parser


def test_query_33():
query = get_query(33)
original_sql = query["pattern"]
parsed_ast = parser.parse(original_sql)
formatted_sql = formatter.format(parsed_ast)
assert parse(formatted_sql) == parse(original_sql)


def test_query_34():
query = get_query(34)
original_sql = query["pattern"]
parsed_ast = parser.parse(original_sql)
formatted_sql = formatter.format(parsed_ast)
assert parse(formatted_sql) == parse(original_sql)


def test_query_35():
query = get_query(35)
original_sql = query["pattern"]
parsed_ast = parser.parse(original_sql)
formatted_sql = formatter.format(parsed_ast)
assert parse(formatted_sql) == parse(original_sql)


def test_query_36():
query = get_query(36)
original_sql = query["pattern"]
parsed_ast = parser.parse(original_sql)
formatted_sql = formatter.format(parsed_ast)
assert parse(formatted_sql) == parse(original_sql)


def test_query_37():
query = get_query(37)
original_sql = query["pattern"]
parsed_ast = parser.parse(original_sql)
formatted_sql = formatter.format(parsed_ast)
assert parse(formatted_sql) == parse(original_sql)


def test_query_38():
query = get_query(38)
original_sql = query["pattern"]
parsed_ast = parser.parse(original_sql)
formatted_sql = formatter.format(parsed_ast)
assert parse(formatted_sql) == parse(original_sql)


def test_query_39():
query = get_query(39)
original_sql = query["pattern"]
parsed_ast = parser.parse(original_sql)
formatted_sql = formatter.format(parsed_ast)
assert parse(formatted_sql) == parse(original_sql)


def test_query_40():
query = get_query(40)
original_sql = query["pattern"]
parsed_ast = parser.parse(original_sql)
formatted_sql = formatter.format(parsed_ast)
assert parse(formatted_sql) == parse(original_sql)


def test_query_41():
query = get_query(41)
original_sql = query["pattern"]
parsed_ast = parser.parse(original_sql)
formatted_sql = formatter.format(parsed_ast)
assert parse(formatted_sql) == parse(original_sql)


def test_query_42():
query = get_query(42)
original_sql = query["pattern"]
parsed_ast = parser.parse(original_sql)
formatted_sql = formatter.format(parsed_ast)
assert parse(formatted_sql) == parse(original_sql)


def test_query_43():
query = get_query(43)
original_sql = query["pattern"]
parsed_ast = parser.parse(original_sql)
formatted_sql = formatter.format(parsed_ast)
assert parse(formatted_sql) == parse(original_sql)
Loading