fix: handle queries on non-existing table gracefully

test/io/test_big_schema.py

@@ -7,8 +7,8 @@ from util import *
 from postgrest import *
 
 
-def test_requests_wait_for_schema_cache_reload(defaultenv):
-    "requests that use the schema cache (e.g. resource embedding) wait for the schema cache to reload"
+def test_requests_with_resource_embedding_wait_for_schema_cache_reload(defaultenv):
+    "requests that use the schema cache with resource embedding wait long for the schema cache to reload"
 
     env = {
         **defaultenv,
@@ -34,6 +34,33 @@ def test_requests_wait_for_schema_cache_reload(defaultenv):
         assert plan_dur > 10000.0
 
 
+def test_requests_without_resource_embedding_wait_for_schema_cache_reload(defaultenv):
+    "requests that use the schema cache without resource embedding wait less for the schema cache to reload"
+
+    env = {
+        **defaultenv,
+        "PGRST_DB_SCHEMAS": "apflora",
+        "PGRST_DB_POOL": "2",
+        "PGRST_DB_ANON_ROLE": "postgrest_test_anonymous",
+        "PGRST_SERVER_TIMING_ENABLED": "true",
+    }
+
+    with run(env=env, wait_max_seconds=30) as postgrest:
+        # reload the schema cache
+        response = postgrest.session.get("/rpc/notify_pgrst")
+        assert response.status_code == 204
+
+        postgrest.wait_until_scache_starts_loading()
+
+        response = postgrest.session.get("/tpopmassn")
+        assert response.status_code == 200
+
+        plan_dur = parse_server_timings_header(response.headers["Server-Timing"])[
+            "plan"
+        ]
+        assert plan_dur < 10000.0
+
+
 # TODO: This test fails now because of https://github.com/PostgREST/postgrest/pull/2122
 # The stack size of 1K(-with-rtsopts=-K1K) is not enough and this fails with "stack overflow"
 # A stack size of 200K seems to be enough for succeess
@@ -65,6 +92,6 @@ def test_should_not_fail_with_stack_overflow(defaultenv):
 
     with run(env=env, wait_max_seconds=30) as postgrest:
         response = postgrest.session.get("/unknown-table?select=unknown-rel(*)")
-        assert response.status_code == 400
+        assert response.status_code == 404
         data = response.json()
-        assert data["code"] == "PGRST200"
+        assert data["code"] == "PGRST205"

test/io/test_io.py

@@ -973,11 +973,10 @@ def test_log_level(level, defaultenv):
                 r'- - postgrest_test_anonymous \[.+\] "GET /unknown HTTP/1.1" 404 - "" "python-requests/.+"',
                 output[2],
             )
+
+            assert len(output) == 5
             assert "Connection" and "is available" in output[3]
-            assert "Connection" and "is available" in output[4]
-            assert "Connection" and "is used" in output[5]
-            assert "Connection" and "is used" in output[6]
-            assert len(output) == 7
+            assert "Connection" and "is used" in output[4]
 
 
 @pytest.mark.parametrize("level", ["crit", "error", "warn", "info", "debug"])
@@ -999,15 +998,11 @@ def test_log_query(level, defaultenv):
         response = postgrest.session.get("/projects")
         assert response.status_code == 200
 
-        response = postgrest.session.get("/unknown")
-        assert response.status_code == 404
-
         response = postgrest.session.get("/infinite_recursion")
         assert response.status_code == 500
 
         root_2xx_regx = r'.+: WITH pgrst_source AS.+SELECT "public"\."root"\(\) pgrst_scalar.+_postgrest_t'
         get_2xx_regx = r'.+: WITH pgrst_source AS.+SELECT "public"\."projects"\.\* FROM "public"\."projects".+_postgrest_t'
-        unknown_4xx_regx = r'.+: WITH pgrst_source AS.+SELECT "public"\."unknown"\.\* FROM "public"\."unknown".+_postgrest_t'
         infinite_recursion_5xx_regx = r'.+: WITH pgrst_source AS.+SELECT "public"\."infinite_recursion"\.\* FROM "public"\."infinite_recursion".+_postgrest_t'
 
         if level == "crit":
@@ -1018,26 +1013,23 @@ def test_log_query(level, defaultenv):
             assert re.match(infinite_recursion_5xx_regx, output[1])
             assert len(output) == 3
         elif level == "warn":
-            output = postgrest.read_stdout(nlines=6)
-            assert re.match(unknown_4xx_regx, output[0])
-            assert re.match(infinite_recursion_5xx_regx, output[3])
-            assert len(output) == 5
+            output = postgrest.read_stdout(nlines=2)
+            assert re.match(infinite_recursion_5xx_regx, output[1])
+            assert len(output) == 2
         elif level == "info":
-            output = postgrest.read_stdout(nlines=10)
+            output = postgrest.read_stdout(nlines=6)
             assert re.match(root_2xx_regx, output[0])
             assert re.match(get_2xx_regx, output[2])
-            assert re.match(unknown_4xx_regx, output[4])
-            assert re.match(infinite_recursion_5xx_regx, output[7])
-            assert len(output) == 9
+            assert re.match(infinite_recursion_5xx_regx, output[5])
+            assert len(output) == 6
         elif level == "debug":
             output_ok = postgrest.read_stdout(nlines=8)
             assert re.match(root_2xx_regx, output_ok[2])
             assert re.match(get_2xx_regx, output_ok[6])
             assert len(output_ok) == 8
-            output_err = postgrest.read_stdout(nlines=10)
-            assert re.match(unknown_4xx_regx, output_err[2])
-            assert re.match(infinite_recursion_5xx_regx, output_err[7])
-            assert len(output_err) == 9
+            output_err = postgrest.read_stdout(nlines=4)
+            assert re.match(infinite_recursion_5xx_regx, output_err[3])
+            assert len(output_err) == 4
 
 
 def test_no_pool_connection_required_on_bad_http_logic(defaultenv):