iris-vector-graph 4.4.0__tar.gz → 4.4.1__tar.gz

{iris_vector_graph-4.4.0 → iris_vector_graph-4.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: iris-vector-graph
-Version: 4.4.0
+Version: 4.4.1
 Summary: Native graph database layer for InterSystems IRIS — openCypher, hybrid vector search, temporal property graph, RDF export, SHACL validation
 Project-URL: Homepage, https://github.com/intersystems-community/iris-vector-graph
 Project-URL: Documentation, https://github.com/intersystems-community/iris-vector-graph/tree/main/docs

{iris_vector_graph-4.4.0 → iris_vector_graph-4.4.1}/iris_src/src/Graph/KG/ArnoAccel.cls

@@ -54,11 +54,34 @@ ClassMethod CallFn(fn As %String, a1 As %String = "", a2 As %String = "", a3 As
 	If dllid = 0 $$$ThrowStatus($$$ERROR($$$GeneralError,"arno not loaded"))
 	Set fid = $Get(^ArnoAccel("fid", fn), 0)
 	If fid = 0 $$$ThrowStatus($$$ERROR($$$GeneralError,"arno function not found: "_fn))
-	If a1 = "" Return $ZF(-5, dllid, fid)
-	If a2 = "" Return $ZF(-5, dllid, fid, a1)
-	If a3 = "" Return $ZF(-5, dllid, fid, a1, a2)
-	If a4 = "" Return $ZF(-5, dllid, fid, a1, a2, a3)
-	Return $ZF(-5, dllid, fid, a1, a2, a3, a4)
+	// the library's readers leave the process in USER: put the caller's namespace back, or every later step on this
+	// connection runs against USER (4.4.0 E2E gate; spec 236 R3 did the same for Load and Build2HopExactStats)
+	Set tNs = $NAMESPACE
+	Try {
+		If a1 = "" {
+			Set tOut = $ZF(-5, dllid, fid)
+		} ElseIf a2 = "" {
+			Set tOut = $ZF(-5, dllid, fid, a1)
+		} ElseIf a3 = "" {
+			Set tOut = $ZF(-5, dllid, fid, a1, a2)
+		} ElseIf a4 = "" {
+			Set tOut = $ZF(-5, dllid, fid, a1, a2, a3)
+		} Else {
+			Set tOut = $ZF(-5, dllid, fid, a1, a2, a3, a4)
+		}
+	} Catch tEx {
+		Set $NAMESPACE = tNs
+		Throw tEx
+	}
+	Set $NAMESPACE = tNs
+	Quit tOut
+}
+
+/// The library's kg_khop_sample, kg_random_walk and kg_neighbor_agg read USER's graph whatever namespace calls them;
+/// elsewhere the answer would be USER's, so they are refused there.
+ClassMethod ReadsUser() As %Boolean [ Private ]
+{
+	Quit $NAMESPACE = "USER"
 }
 
 /// Reader revisions of the loaded callout build, as a JSON object {"<reader>": <int>}.
@@ -251,6 +274,7 @@ ClassMethod SubgraphJson(seedJson As %String, hops As %Integer = 2, edgeTypesJso
 /// Returns JSON: {"layers": [[{src,dst},...], ...], "seeds": [...]}
 ClassMethod KhopSampleJson(seedJson As %String, hops As %Integer = 2, fanout As %Integer = 16) As %String
 {
+	Quit:'..ReadsUser() "{""layers"":[], ""error"": ""arno reads USER only, not "_$NAMESPACE_"""}"
 	Try {
 		Do ..CacheGraphJson("KG")
 		Set result = ..CallFn("kg_khop_sample", "KG", seedJson, hops, fanout)
@@ -263,6 +287,7 @@ ClassMethod KhopSampleJson(seedJson As %String, hops As %Integer = 2, fanout As
 /// Random walk (DeepWalk/node2vec-style). Returns JSON array of walk sequences.
 ClassMethod RandomWalkJson(seedJson As %String, walkLength As %Integer = 20, numWalks As %Integer = 10) As %String
 {
+	Quit:'..ReadsUser() "[]"
 	Try {
 		Do ..CacheGraphJson("KG")
 		Set result = ..CallFn("kg_random_walk", "KG", seedJson, walkLength, numWalks)
@@ -275,6 +300,7 @@ ClassMethod RandomWalkJson(seedJson As %String, walkLength As %Integer = 20, num
 /// GraphSAGE-style mean neighbor aggregation. Returns JSON: {node: {agg_feat, degree}, ...}
 ClassMethod NeighborAggJson(seedJson As %String, hops As %Integer = 2) As %String
 {
+	Quit:'..ReadsUser() "{}"
 	Try {
 		Do ..CacheGraphJson("KG")
 		Set result = ..CallFn("kg_neighbor_agg", "KG", seedJson, hops)

{iris_vector_graph-4.4.0 → iris_vector_graph-4.4.1}/iris_src/src/Graph/KG/NKGAccelTraversal.cls

@@ -644,6 +644,9 @@ ClassMethod StructuralGuard(nodeIdx As %Integer, requiredPreds As %List) As %Boo
 
 ClassMethod Build2HopExact() As %Boolean
 {
+    // the library's kg_build_2hop_exact_stream reads USER's ^NKG and leaves the process in USER, so the sketch below
+    // would be written into USER's ^KG: refused elsewhere (4.4.0 E2E gate; the merged sketch is a USER-only store)
+    Quit:$NAMESPACE'="USER" 0
     If '##class(Graph.KG.NKGAccelLoader).IsLoaded() {
         Do ##class(Graph.KG.NKGAccelLoader).Load("/tmp/libarno_callout.so")
         If '##class(Graph.KG.NKGAccelLoader).IsLoaded() {

{iris_vector_graph-4.4.0 → iris_vector_graph-4.4.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "iris-vector-graph"
-version = "4.4.0"
+version = "4.4.1"
 description = "Native graph database layer for InterSystems IRIS — openCypher, hybrid vector search, temporal property graph, RDF export, SHACL validation"
 readme = "README.md"
 license = "MIT"

{iris_vector_graph-4.4.0 → iris_vector_graph-4.4.1}/tests/e2e/conftest.py

@@ -7,7 +7,7 @@ Uses iris-devtester for database connection management per Constitution II.
 
 import os
 import time
-from typing import Any, Generator
+from typing import Generator
 
 import pytest
 from fastapi.testclient import TestClient
@@ -16,6 +16,33 @@ from fastapi.testclient import TestClient
 # The iris_connection fixture is already defined in tests/conftest.py
 
 
+PAROS_NAMESPACE = os.environ.get("IVG_PAROS_NAMESPACE", "IVGPAROS")
+
+
+@pytest.fixture(scope="module")
+def paros_connection(iris_connection):
+    """A connection to the scratch namespace the degree-cache tests empty and rebuild `^KG` in (IVGPAROS, or
+    IVG_PAROS_NAMESPACE), on the server `iris_connection` reaches, whatever namespace that is in. They asserted
+    IVG_NAMESPACE was that namespace, so a run elsewhere errored 26 tests; they now connect to it themselves, and skip
+    where the server has no such namespace. Nothing here touches the run's own namespace."""
+    import iris
+
+    if os.environ.get("SKIP_IRIS_TESTS", "false").lower() == "true":
+        pytest.fail("the degree-cache tests assert ^KG on the server; SKIP_IRIS_TESTS=true is not acceptable")
+    if getattr(iris_connection, "namespace", None) == PAROS_NAMESPACE:
+        yield iris_connection
+        return
+    try:
+        conn = iris.connect(
+            hostname=iris_connection.hostname, port=iris_connection.port, namespace=PAROS_NAMESPACE,
+            username="_SYSTEM", password="SYS",
+        )
+    except Exception as ex:
+        pytest.skip(f"no scratch namespace {PAROS_NAMESPACE} on this server ({type(ex).__name__}); create it to run these")
+    yield conn
+    conn.close()
+
+
 @pytest.fixture(scope="module")
 def api_client(iris_connection) -> Generator[TestClient, None, None]:
     """

iris_vector_graph-4.4.1/tests/e2e/test_arno_namespace_kept_e2e.py

@@ -0,0 +1,78 @@
+"""A call into the Arno library leaves the process in the caller's namespace (found 2026-10-25, 4.4.0 E2E gate).
+
+The library's readers read USER's globals and leave the process in USER. `ArnoAccel.Load`, `NativeResult` and
+`TraversalBuild.Build2HopExactStats` already put the namespace back or refuse, but `ArnoAccel.CallFn` (behind
+`KhopSampleJson`, `RandomWalkJson`, `NeighborAggJson`) and a direct `NKGAccelTraversal.Build2HopExact` did not. One
+such call in a non-USER namespace moved the shared Native API process to USER, and everything after it on that
+connection read and wrote USER: 135 E2E failures in a run with `IVG_NAMESPACE=IVGFIX`, all passing in USER. Outside
+USER these entry points now refuse (they would answer from, or write into, USER's graph) and the namespace stays.
+
+Needs a non-USER namespace with the classes deployed (IVG_NAMESPACE, IVG_SECONDARY_NAMESPACE, or the IVGPAROS
+scratch namespace, the first that is not USER and exists) and the Arno library on the container.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+
+import pytest
+
+SKIP_IRIS_TESTS = os.environ.get("SKIP_IRIS_TESTS", "false").lower() == "true"
+pytestmark = [pytest.mark.e2e, pytest.mark.skipif(SKIP_IRIS_TESTS, reason="SKIP_IRIS_TESTS=true")]
+
+
+@pytest.fixture(scope="module")
+def other_ns():
+    import iris
+
+    port = int(os.environ.get("IVG_PORT", "31972"))
+    names = [os.environ.get(v, "") for v in ("IVG_NAMESPACE", "IVG_SECONDARY_NAMESPACE")]
+    names.append(os.environ.get("IVG_PAROS_NAMESPACE", "IVGPAROS"))  # the scratch namespace BuildKG may rebuild
+    conn = None
+    for ns in (n for n in names if n and n.upper() != "USER"):
+        try:
+            conn = iris.connect("localhost", port, ns, "_SYSTEM", "SYS")
+            break
+        except Exception:
+            continue
+    if conn is None:
+        pytest.skip("needs a non-USER namespace: IVG_NAMESPACE, IVG_SECONDARY_NAMESPACE or IVGPAROS")
+    native = iris.createIRIS(conn)
+    user = iris.createIRIS(iris.connect("localhost", port, "USER", "_SYSTEM", "SYS"))
+    lib = user.get("ArnoAccel", "lib_path")
+    if not lib or not native.classMethodValue("%File", "Exists", lib):
+        pytest.skip("the Arno library is not installed on this container")
+    assert native.classMethodValue("Graph.KG.ArnoAccel", "Load", lib) == 1
+    native.classMethodValue("Graph.KG.NKGAccelLoader", "Load", lib)
+    yield ns, native
+    conn.close()
+
+
+CALLS = [
+    ("ArnoAccel", "KhopSampleJson", '["a"]', 2, 5),
+    ("ArnoAccel", "RandomWalkJson", '["a"]', 5, 4),
+    ("ArnoAccel", "NeighborAggJson", '["a"]', 2),
+    ("NKGAccelTraversal", "Build2HopExact"),
+    ("NKGAccel", "Build2HopExact"),
+    ("Traversal", "BuildKG"),
+    ("NKGAccelTraversal", "BFSJson", "a", "[]", 3, 0),
+    ("NKGAccelTraversal", "CountDistinctKHop", "a", "", 2, "both"),
+]
+
+
+@pytest.mark.parametrize("call", CALLS, ids=[f"{c[0]}.{c[1]}" for c in CALLS])
+def test_the_process_stays_in_the_callers_namespace(other_ns, call):
+    ns, native = other_ns
+    native.classMethodValue(f"Graph.KG.{call[0]}", call[1], *call[2:])
+    assert native.classMethodValue("%SYSTEM.SYS", "NameSpace") == ns
+
+
+def test_the_user_only_readers_refuse_outside_user(other_ns):
+    """They read USER's graph: elsewhere they answer as unavailable, never with USER's nodes."""
+    ns, native = other_ns
+    khop = json.loads(str(native.classMethodValue("Graph.KG.ArnoAccel", "KhopSampleJson", '["a"]', 2, 5)))
+    assert khop["layers"] == [] and "USER" in khop.get("error", ""), khop
+    assert json.loads(str(native.classMethodValue("Graph.KG.ArnoAccel", "RandomWalkJson", '["a"]', 5, 4))) == []
+    assert json.loads(str(native.classMethodValue("Graph.KG.ArnoAccel", "NeighborAggJson", '["a"]', 2))) == {}
+    assert int(native.classMethodValue("Graph.KG.NKGAccelTraversal", "Build2HopExact")) == 0

{iris_vector_graph-4.4.0 → iris_vector_graph-4.4.1}/tests/e2e/test_build2hop_exact_arno.py

@@ -18,6 +18,10 @@ REQUIRE = os.environ.get("IVG_REQUIRE_ARNO") == "1"
 
 @pytest.fixture
 def arno_graph(iris_connection):
+    ns = getattr(iris_connection, "namespace", "USER")
+    if ns != "USER":
+        # the library reads USER's globals; elsewhere these entry points refuse (test_arno_namespace_kept_e2e)
+        pytest.skip(f"the Arno library's readers read USER only; this run is in {ns}")
     eng = IRISGraphEngine(iris_connection, embedding_dimension=768)
     obj = eng._store._iris_obj()
     lib = obj.get("ArnoAccel", "lib_path")

{iris_vector_graph-4.4.0 → iris_vector_graph-4.4.1}/tests/e2e/test_degree_cache_live.py

@@ -23,9 +23,8 @@ What this proves, live:
   recount after every step.
 
 Runs in a scratch namespace only: BuildKG and EraseAll rebuild or empty `^KG`. By default
-that is IVGPAROS (override with IVG_PAROS_NAMESPACE):
-
-    IVG_NAMESPACE=IVGPAROS pytest tests/e2e/test_degree_cache_live.py
+that is IVGPAROS (override with IVG_PAROS_NAMESPACE); the tests connect to it themselves
+(`paros_connection`), whatever IVG_NAMESPACE the run uses, and skip where it does not exist.
 """
 
 from __future__ import annotations
@@ -50,15 +49,9 @@ Q = "LIKES"
 
 
 @pytest.fixture(scope="module")
-def target(iris_connection):
-    if os.environ.get("SKIP_IRIS_TESTS", "false").lower() == "true":
-        pytest.fail("spec 248 asserts ^KG on the server; SKIP_IRIS_TESTS=true is not acceptable")
-    ns = getattr(iris_connection, "namespace", None)
-    assert ns == SCRATCH, (
-        f"connected to {ns!r}, not the scratch namespace {SCRATCH!r}: BuildKG and EraseAll "
-        "empty ^KG. Run with IVG_NAMESPACE=" + SCRATCH
-    )
-    return iris_connection
+def target(paros_connection):
+    assert getattr(paros_connection, "namespace", None) == SCRATCH
+    return paros_connection
 
 
 def _connect(target):

{iris_vector_graph-4.4.0 → iris_vector_graph-4.4.1}/tests/e2e/test_degree_warm_stamp_live.py

@@ -2,9 +2,8 @@
 
 While the stamp holds, bulk readers (centrality, the NKG and two-hop builds, KHopCount) read one global per node and treat an
 absent cache entry as zero. It must therefore turn off on ANY write that could change an answer, and a reader must give the
-same answer as a recount whether the stamp holds or not. Runs only in the scratch namespace (see test_degree_cache_live.py):
-
-    IVG_NAMESPACE=IVGPAROS pytest tests/e2e/test_degree_warm_stamp_live.py
+same answer as a recount whether the stamp holds or not. Runs only in the scratch namespace, which it connects to itself
+(`paros_connection`; see test_degree_cache_live.py).
 """
 
 from __future__ import annotations
@@ -20,12 +19,11 @@ G = "warm248"
 
 
 @pytest.fixture
-def native(iris_connection):
-    ns = getattr(iris_connection, "namespace", None)
-    assert ns == SCRATCH, f"connected to {ns!r}, not the scratch namespace {SCRATCH!r}; set IVG_NAMESPACE={SCRATCH}"
+def native(paros_connection):
+    assert getattr(paros_connection, "namespace", None) == SCRATCH
     import iris
 
-    handle = iris.createIRIS(iris_connection)
+    handle = iris.createIRIS(paros_connection)
     _clear(handle)
     yield handle
     _clear(handle)

{iris_vector_graph-4.4.0 → iris_vector_graph-4.4.1}/tests/e2e/test_derived_oracle_property.py

@@ -142,20 +142,10 @@ def engine_and_host(iris_connection):
 @pytest.mark.parametrize(
     "allowed_advisory",
     [
-        pytest.param(
-            ADVISORY_KINDS,
-            id="exact",
-            marks=pytest.mark.xfail(
-                reason=(
-                    "OPEN: inside pytest the rollback and failed-batch steps leave ghost out/in entries, but a hand "
-                    "replay of seed 1's first steps (outside pytest) shows rows and adjacency agree. Either the "
-                    "fixture connection or a real engine/connection interaction; not yet isolated. (Before spec 249 "
-                    "this test also had a strict mode that failed on the ghost deg/degp counters; with no counters "
-                    "there is only this one.)"
-                ),
-                strict=False,
-            ),
-        ),
+        # was xfail ("ghost out/in entries inside pytest, not yet isolated"). It failed in a full IVGFIX run on
+        # 2026-10-24 and passes in full IVGFIX and USER runs since an earlier test's Arno call stopped moving the shared
+        # Native API process to USER (KNOWN_ISSUES, 2026-10-25); kept unmarked so a return shows as a failure
+        pytest.param(ADVISORY_KINDS, id="exact"),
     ],
 )
 def test_adjacency_matches_rows_after_every_random_step(seed, allowed_advisory, engine_and_host, graph_name):

iris_vector_graph-4.4.1/tests/tck/features

@@ -0,0 +1 @@
+../../vendor/opencypher/tck/features

iris_vector_graph-4.4.0/tests/tck/features/clauses/call/Call1.feature

@@ -1,236 +0,0 @@
-#
-# Copyright (c) "Neo4j"
-# Neo4j Sweden AB [https://neo4j.com]
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-# Attribution Notice under the terms of the Apache License 2.0
-#
-# This work was created by the collective efforts of the openCypher community.
-# Without limiting the terms of Section 6, any Derivative Work that is not
-# approved by the public consensus process of the openCypher Implementers Group
-# should not be described as “Cypher” (and Cypher® is a registered trademark of
-# Neo4j Inc.) or as "openCypher". Extensions by implementers or prototypes or
-# proposals for change that have been documented or implemented should only be
-# described as "implementation extensions to Cypher" or as "proposed changes to
-# Cypher that are not yet approved by the openCypher community".
-#
-
-#encoding: utf-8
-
-Feature: Call1 - Basic procedure calling
-
-  Scenario: [1] Standalone call to procedure that takes no arguments and yields no results
-    Given an empty graph
-    And there exists a procedure test.doNothing() :: ():
-      |
-    When executing query:
-      """
-      CALL test.doNothing()
-      """
-    Then the result should be empty
-    And no side effects
-
-  Scenario: [2] Standalone call to procedure that takes no arguments and yields no results, called with implicit arguments
-    Given an empty graph
-    And there exists a procedure test.doNothing() :: ():
-      |
-    When executing query:
-      """
-      CALL test.doNothing
-      """
-    Then the result should be empty
-    And no side effects
-
-  Scenario: [3] In-query call to procedure that takes no arguments and yields no results
-    Given an empty graph
-    And there exists a procedure test.doNothing() :: ():
-      |
-    When executing query:
-      """
-      MATCH (n)
-      CALL test.doNothing()
-      RETURN n
-      """
-    Then the result should be, in any order:
-      | n |
-    And no side effects
-
-  Scenario: [4] In-query call to procedure that takes no arguments and yields no results and consumes no rows
-    Given an empty graph
-    And there exists a procedure test.doNothing() :: ():
-      |
-    And having executed:
-      """
-      CREATE (:A {name: 'a'})
-      CREATE (:B {name: 'b'})
-      CREATE (:C {name: 'c'})
-      """
-    When executing query:
-      """
-      MATCH (n)
-      CALL test.doNothing()
-      RETURN n.name AS `name`
-      """
-    Then the result should be, in any order:
-      | name |
-      | 'a'  |
-      | 'b'  |
-      | 'c'  |
-    And no side effects
-
-  Scenario: [5] Standalone call to STRING procedure that takes no arguments
-    Given an empty graph
-    And there exists a procedure test.labels() :: (label :: STRING?):
-      | label |
-      | 'A'   |
-      | 'B'   |
-      | 'C'   |
-    When executing query:
-      """
-      CALL test.labels()
-      """
-    Then the result should be, in order:
-      | label |
-      | 'A'   |
-      | 'B'   |
-      | 'C'   |
-    And no side effects
-
-  Scenario: [6] In-query call to STRING procedure that takes no arguments
-    Given an empty graph
-    And there exists a procedure test.labels() :: (label :: STRING?):
-      | label |
-      | 'A'   |
-      | 'B'   |
-      | 'C'   |
-    When executing query:
-      """
-      CALL test.labels() YIELD label
-      RETURN label
-      """
-    Then the result should be, in order:
-      | label |
-      | 'A'   |
-      | 'B'   |
-      | 'C'   |
-    And no side effects
-
-  Scenario: [7] Standalone call to procedure should fail if explicit argument is missing
-    Given an empty graph
-    And there exists a procedure test.my.proc(name :: STRING?, in :: INTEGER?) :: (out :: INTEGER?):
-      | name | in | out |
-    When executing query:
-      """
-      CALL test.my.proc('Dobby')
-      """
-    Then a SyntaxError should be raised at compile time: InvalidNumberOfArguments
-
-  Scenario: [8] In-query call to procedure should fail if explicit argument is missing
-    Given an empty graph
-    And there exists a procedure test.my.proc(name :: STRING?, in :: INTEGER?) :: (out :: INTEGER?):
-      | name | in | out |
-    When executing query:
-      """
-      CALL test.my.proc('Dobby') YIELD out
-      RETURN out
-      """
-    Then a SyntaxError should be raised at compile time: InvalidNumberOfArguments
-
-  Scenario: [9] Standalone call to procedure should fail if too many explicit argument are given
-    Given an empty graph
-    And there exists a procedure test.my.proc(in :: INTEGER?) :: (out :: INTEGER?):
-      | in | out |
-    When executing query:
-      """
-      CALL test.my.proc(1, 2, 3, 4)
-      """
-    Then a SyntaxError should be raised at compile time: InvalidNumberOfArguments
-
-  Scenario: [10] In-query call to procedure should fail if too many explicit argument are given
-    Given an empty graph
-    And there exists a procedure test.my.proc(in :: INTEGER?) :: (out :: INTEGER?):
-      | in | out |
-    When executing query:
-      """
-      CALL test.my.proc(1, 2, 3, 4) YIELD out
-      RETURN out
-      """
-    Then a SyntaxError should be raised at compile time: InvalidNumberOfArguments
-
-  Scenario: [11] Standalone call to procedure should fail if implicit argument is missing
-    Given an empty graph
-    And there exists a procedure test.my.proc(name :: STRING?, in :: INTEGER?) :: (out :: INTEGER?):
-      | name | in | out |
-    And parameters are:
-      | name | 'Stefan' |
-    When executing query:
-      """
-      CALL test.my.proc
-      """
-    Then a ParameterMissing should be raised at compile time: MissingParameter
-
-  Scenario: [12] In-query call to procedure that has outputs fails if no outputs are yielded
-    Given an empty graph
-    And there exists a procedure test.my.proc(in :: INTEGER?) :: (out :: INTEGER?):
-      | in | out |
-    When executing query:
-      """
-      CALL test.my.proc(1)
-      RETURN out
-      """
-    Then a SyntaxError should be raised at compile time: UndefinedVariable
-
-  Scenario: [13] Standalone call to unknown procedure should fail
-    Given an empty graph
-    When executing query:
-      """
-      CALL test.my.proc
-      """
-    Then a ProcedureError should be raised at compile time: ProcedureNotFound
-
-  Scenario: [14] In-query call to unknown procedure should fail
-    Given an empty graph
-    When executing query:
-      """
-      CALL test.my.proc() YIELD out
-      RETURN out
-      """
-    Then a ProcedureError should be raised at compile time: ProcedureNotFound
-
-  Scenario: [15] In-query procedure call should fail if shadowing an already bound variable
-    Given an empty graph
-    And there exists a procedure test.labels() :: (label :: STRING?):
-      | label |
-      | 'A'   |
-      | 'B'   |
-      | 'C'   |
-    When executing query:
-      """
-      WITH 'Hi' AS label
-      CALL test.labels() YIELD label
-      RETURN *
-      """
-    Then a SyntaxError should be raised at compile time: VariableAlreadyBound
-
-  Scenario: [16] In-query procedure call should fail if one of the argument expressions uses an aggregation function
-    Given an empty graph
-    And there exists a procedure test.labels(in :: INTEGER?) :: (label :: STRING?):
-      | in | label |
-    When executing query:
-      """
-      MATCH (n)
-      CALL test.labels(count(n)) YIELD label
-      RETURN label
-      """
-    Then a SyntaxError should be raised at compile time: InvalidAggregation