test: close test client after testing and make manifest_str be pytest.fixture (#830)

Author: grieve54706

ibis-server/tests/routers/test_ibis.py

@@ -13,24 +13,23 @@
             "columns": [
                 {"name": "orderkey", "expression": "o_orderkey", "type": "integer"}
             ],
-            "primaryKey": "orderkey",
         },
     ],
 }
 
 
 @pytest.fixture
-def manifest_hash(web_server):
+def manifest_str(web_server):
     return web_server.register_mdl(manifest)
 
 
 with TestClient(app) as client:
 
-    def test_dry_plan(manifest_hash):
+    def test_dry_plan(manifest_str):
         response = client.post(
             url="/v2/connector/dry-plan",
             json={
-                "manifestStr": manifest_hash,
+                "manifestStr": manifest_str,
                 "sql": 'SELECT orderkey FROM "Orders" LIMIT 1',
             },
         )

ibis-server/tests/routers/v2/connector/test_bigquery.py

@@ -270,6 +270,7 @@ def test_validate_with_unknown_rule(manifest_str):
                 "parameters": {"modelName": "Orders", "columnName": "orderkey"},
             },
         )
+
         assert response.status_code == 422
         assert (
             response.text

ibis-server/tests/routers/v2/connector/test_mssql.py

@@ -69,6 +69,13 @@
     ],
 }
 
+orig_manifest_str = base64.b64encode(orjson.dumps(manifest)).decode("utf-8")
+
+
+@pytest.fixture
+def manifest_str(web_server):
+    return web_server.register_mdl(manifest)
+
 
 @pytest.fixture(scope="module")
 def mssql(request) -> SqlServerContainer:
@@ -103,13 +110,6 @@ def mssql(request) -> SqlServerContainer:
     return mssql
 
 
-@pytest.fixture
-def manifest_str(web_server):
-    return web_server.register_mdl(manifest)
-
-
-orig_manifest_str = base64.b64encode(orjson.dumps(manifest)).decode("utf-8")
-
 with TestClient(app) as client:
 
     def test_query(manifest_str, mssql: SqlServerContainer):

ibis-server/tests/routers/v2/connector/test_mysql.py

@@ -78,6 +78,13 @@
     ],
 }
 
+orig_manifest_str = base64.b64encode(orjson.dumps(manifest)).decode("utf-8")
+
+
+@pytest.fixture
+def manifest_str(web_server):
+    return web_server.register_mdl(manifest)
+
 
 @pytest.fixture(scope="module")
 def mysql(request) -> MySqlContainer:
@@ -109,13 +116,6 @@ def mysql(request) -> MySqlContainer:
     return mysql
 
 
-@pytest.fixture
-def manifest_str(web_server):
-    return web_server.register_mdl(manifest)
-
-
-orig_manifest_str = base64.b64encode(orjson.dumps(manifest)).decode("utf-8")
-
 with TestClient(app) as client:
 
     def test_query(manifest_str, mysql: MySqlContainer):

ibis-server/tests/routers/v2/connector/test_postgres.py

@@ -82,6 +82,13 @@
     ],
 }
 
+orig_manifest_str = base64.b64encode(orjson.dumps(manifest)).decode("utf-8")
+
+
+@pytest.fixture
+def manifest_str(web_server):
+    return web_server.register_mdl(manifest)
+
 
 @pytest.fixture(scope="module")
 def postgres(request) -> PostgresContainer:
@@ -97,14 +104,6 @@ def postgres(request) -> PostgresContainer:
     return pg
 
 
-@pytest.fixture
-def manifest_str(web_server):
-    return web_server.register_mdl(manifest)
-
-
-orig_manifest_str = base64.b64encode(orjson.dumps(manifest)).decode("utf-8")
-
-
 with TestClient(app) as client:
 
     def test_query(manifest_str, postgres: PostgresContainer):
@@ -164,8 +163,7 @@ def test_query_with_connection_url(manifest_str, postgres: PostgresContainer):
         assert result["dtypes"] is not None
 
     def test_dry_run_with_connection_url_and_password_with_bracket_should_not_raise_value_error(
-        manifest_str,
-        postgres: PostgresContainer,
+        manifest_str, postgres: PostgresContainer
     ):
         connection_url = _to_connection_url(postgres)
         part = urlparse(connection_url)

ibis-server/tests/routers/v2/connector/test_snowflake.py

@@ -69,14 +69,14 @@
     ],
 }
 
+orig_manifest_str = base64.b64encode(orjson.dumps(manifest)).decode("utf-8")
+
 
 @pytest.fixture
 def manifest_str(web_server):
     return web_server.register_mdl(manifest)
 
 
-orig_manifest_str = base64.b64encode(orjson.dumps(manifest)).decode("utf-8")
-
 with TestClient(app) as client:
 
     def test_query(manifest_str):
@@ -326,12 +326,10 @@ def test_validate_rule_column_is_valid_without_one_parameter():
         assert response.status_code == 422
         assert response.text == "Missing required parameter: `modelName`"
 
+    @pytest.mark.skip(reason="Not implemented")
+    def test_metadata_list_tables():
+        pass
 
-@pytest.mark.skip(reason="Not implemented")
-def test_metadata_list_tables():
-    pass
-
-
-@pytest.mark.skip(reason="Not implemented")
-def test_metadata_list_constraints():
-    pass
+    @pytest.mark.skip(reason="Not implemented")
+    def test_metadata_list_constraints():
+        pass

ibis-server/tests/routers/v2/connector/test_trino.py

@@ -184,7 +184,7 @@ def test_query_with_limit(manifest_str, trino: TrinoContainer):
         result = response.json()
         assert len(result["data"]) == 1
 
-    def test_query_without_manifest(manifest_str, trino: TrinoContainer):
+    def test_query_without_manifest(trino: TrinoContainer):
         connection_info = _to_connection_info(trino)
         response = client.post(
             url=f"{base_url}/query",

ibis-server/tests/routers/v2/test_analysis.py

@@ -78,15 +78,18 @@
         },
     ],
 }
-with TestClient(app) as client:
 
-    @pytest.fixture
-    def manifest_hash(web_server):
-        return web_server.register_mdl(manifest)
 
-    def test_analysis_sql_select_all_customer(manifest_hash):
+@pytest.fixture
+def manifest_str(web_server):
+    return web_server.register_mdl(manifest)
+
+
+with TestClient(app) as client:
+
+    def test_analysis_sql_select_all_customer(manifest_str):
         result = get_sql_analysis(
-            {"manifestStr": manifest_hash, "sql": "SELECT * FROM customer"}
+            {"manifestStr": manifest_str, "sql": "SELECT * FROM customer"}
         )
         assert len(result) == 1
         assert result[0]["relation"]["tableName"] == "customer"
@@ -106,10 +109,10 @@ def test_analysis_sql_select_all_customer(manifest_hash):
         assert result[0]["relation"]["tableName"] == "customer"
         assert result[0]["relation"]["nodeLocation"] == {"line": 1, "column": 15}
 
-    def test_analysis_sql_group_by_customer(manifest_hash):
+    def test_analysis_sql_group_by_customer(manifest_str):
         result = get_sql_analysis(
             {
-                "manifestStr": manifest_hash,
+                "manifestStr": manifest_str,
                 "sql": "SELECT custkey, count(*) FROM customer GROUP BY 1",
             }
         )
@@ -135,10 +138,10 @@ def test_analysis_sql_group_by_customer(manifest_hash):
             ],
         }
 
-    def test_analysis_sql_join_customer_orders(manifest_hash):
+    def test_analysis_sql_join_customer_orders(manifest_str):
         result = get_sql_analysis(
             {
-                "manifestStr": manifest_hash,
+                "manifestStr": manifest_str,
                 "sql": "SELECT * FROM customer c JOIN orders o ON c.custkey = o.custkey",
             }
         )
@@ -181,10 +184,10 @@ def test_analysis_sql_join_customer_orders(manifest_hash):
             },
         ]
 
-    def test_analysis_sql_where_clause(manifest_hash):
+    def test_analysis_sql_where_clause(manifest_str):
         result = get_sql_analysis(
             {
-                "manifestStr": manifest_hash,
+                "manifestStr": manifest_str,
                 "sql": "SELECT * FROM customer WHERE custkey = 1 OR (name = 'test' AND address = 'test')",
             }
         )
@@ -205,10 +208,10 @@ def test_analysis_sql_where_clause(manifest_hash):
         ]
         assert result[0]["filter"]["right"]["type"] == "AND"
 
-    def test_analysis_sql_group_by_multiple_columns(manifest_hash):
+    def test_analysis_sql_group_by_multiple_columns(manifest_str):
         result = get_sql_analysis(
             {
-                "manifestStr": manifest_hash,
+                "manifestStr": manifest_str,
                 "sql": "SELECT custkey, count(*), name FROM customer GROUP BY 1, 3, nationkey",
             }
         )
@@ -251,10 +254,10 @@ def test_analysis_sql_group_by_multiple_columns(manifest_hash):
             ],
         }
 
-    def test_analysis_sql_order_by(manifest_hash):
+    def test_analysis_sql_order_by(manifest_str):
         result = get_sql_analysis(
             {
-                "manifestStr": manifest_hash,
+                "manifestStr": manifest_str,
                 "sql": "SELECT custkey, name FROM customer ORDER BY 1 ASC, 2 DESC",
             }
         )
@@ -275,10 +278,10 @@ def test_analysis_sql_order_by(manifest_hash):
         assert result[0]["sortings"][1]["ordering"] == "DESCENDING"
         assert result[0]["sortings"][1]["nodeLocation"] == {"line": 1, "column": 52}
 
-    def test_analysis_sqls(manifest_hash):
+    def test_analysis_sqls(manifest_str):
         result = get_sql_analysis_batch(
             {
-                "manifestStr": manifest_hash,
+                "manifestStr": manifest_str,
                 "sqls": [
                     "SELECT * FROM customer",
                     "SELECT custkey, count(*) FROM customer GROUP BY 1",