mustrd 0.2.6.1__py3-none-any.whl → 0.2.6.3__py3-none-any.whl

mustrd/mustrdTestPlugin.py

@@ -22,22 +22,38 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 """
 
+import logging
 from dataclasses import dataclass
 import pytest
 import os
-from pathlib import Path
+from pathlib import Path, PosixPath
 from rdflib.namespace import Namespace
 from rdflib import Graph, RDF
 from pytest import Session
 
+from mustrd import logger_setup
 from mustrd.TestResult import ResultList, TestResult, get_result_list
 from mustrd.utils import get_mustrd_root
-from mustrd.mustrd import get_triple_store_graph, get_triple_stores
-from mustrd.mustrd import Specification, SpecSkipped, validate_specs, get_specs, SpecPassed, run_spec
+from mustrd.mustrd import (
+    write_result_diff_to_log,
+    get_triple_store_graph,
+    get_triple_stores,
+)
+from mustrd.mustrd import (
+    Specification,
+    SpecSkipped,
+    validate_specs,
+    get_specs,
+    SpecPassed,
+    run_spec,
+)
 from mustrd.namespace import MUST, TRIPLESTORE, MUSTRDTEST
 from typing import Union
 from pyshacl import validate
 
+import pathlib
+import traceback
+
 spnamespace = Namespace("https://semanticpartners.com/data/test/")
 
 mustrd_root = get_mustrd_root()
@@ -82,55 +98,87 @@ def pytest_addoption(parser):
 
 def pytest_configure(config) -> None:
     # Read configuration file
-    if config.getoption("mustrd"):
-        test_configs = parse_config(config.getoption("configpath"))
-        config.pluginmanager.register(MustrdTestPlugin(config.getoption("mdpath"),
-                                                       test_configs, config.getoption("secrets")))
+    if config.getoption("mustrd") and config.getoption("configpath"):
+        config.pluginmanager.register(
+            MustrdTestPlugin(
+                config.getoption("mdpath"),
+                Path(config.getoption("configpath")),
+                config.getoption("secrets"),
+            )
+        )
 
 
 def parse_config(config_path):
     test_configs = []
     config_graph = Graph().parse(config_path)
-    shacl_graph = Graph().parse(Path(os.path.join(mustrd_root, "model/mustrdTestShapes.ttl")))
-    ont_graph = Graph().parse(Path(os.path.join(mustrd_root, "model/mustrdTestOntology.ttl")))
+    shacl_graph = Graph().parse(
+        Path(os.path.join(mustrd_root, "model/mustrdTestShapes.ttl"))
+    )
+    ont_graph = Graph().parse(
+        Path(os.path.join(mustrd_root, "model/mustrdTestOntology.ttl"))
+    )
     conforms, results_graph, results_text = validate(
-            data_graph=config_graph,
-            shacl_graph=shacl_graph,
-            ont_graph=ont_graph,
-            advanced=True,
-            inference='none'
-        )
+        data_graph=config_graph,
+        shacl_graph=shacl_graph,
+        ont_graph=ont_graph,
+        advanced=True,
+        inference="none",
+    )
     if not conforms:
-        raise ValueError(f"Mustrd test configuration not conform to the shapes. SHACL report: {results_text}",
-                         results_graph)
+        raise ValueError(
+            f"Mustrd test configuration not conform to the shapes. SHACL report: {results_text}",
+            results_graph,
+        )
 
-    for test_config_subject in config_graph.subjects(predicate=RDF.type, object=MUSTRDTEST.MustrdTest):
-        spec_path = get_config_param(config_graph, test_config_subject, MUSTRDTEST.hasSpecPath, str)
-        data_path = get_config_param(config_graph, test_config_subject, MUSTRDTEST.hasDataPath, str)
-        triplestore_spec_path = get_config_param(config_graph, test_config_subject, MUSTRDTEST.triplestoreSpecPath, str)
-        pytest_path = get_config_param(config_graph, test_config_subject, MUSTRDTEST.hasPytestPath, str)
-        filter_on_tripleStore = list(config_graph.objects(subject=test_config_subject,
-                                                          predicate=MUSTRDTEST.filterOnTripleStore))
+    for test_config_subject in config_graph.subjects(
+        predicate=RDF.type, object=MUSTRDTEST.MustrdTest
+    ):
+        spec_path = get_config_param(
+            config_graph, test_config_subject, MUSTRDTEST.hasSpecPath, str
+        )
+        data_path = get_config_param(
+            config_graph, test_config_subject, MUSTRDTEST.hasDataPath, str
+        )
+        triplestore_spec_path = get_config_param(
+            config_graph, test_config_subject, MUSTRDTEST.triplestoreSpecPath, str
+        )
+        pytest_path = get_config_param(
+            config_graph, test_config_subject, MUSTRDTEST.hasPytestPath, str
+        )
+        filter_on_tripleStore = tuple(
+            config_graph.objects(
+                subject=test_config_subject, predicate=MUSTRDTEST.filterOnTripleStore
+            )
+        )
 
         # Root path is the mustrd test config path
         root_path = Path(config_path).parent
         spec_path = root_path / Path(spec_path) if spec_path else None
         data_path = root_path / Path(data_path) if data_path else None
-        triplestore_spec_path = root_path / Path(triplestore_spec_path) if triplestore_spec_path else None
+        triplestore_spec_path = (
+            root_path / Path(triplestore_spec_path) if triplestore_spec_path else None
+        )
 
-        test_configs.append(TestConfig(spec_path=spec_path, data_path=data_path,
-                                       triplestore_spec_path=triplestore_spec_path,
-                                       pytest_path=pytest_path,
-                                       filter_on_tripleStore=filter_on_tripleStore))
+        test_configs.append(
+            TestConfig(
+                spec_path=spec_path,
+                data_path=data_path,
+                triplestore_spec_path=triplestore_spec_path,
+                pytest_path=pytest_path,
+                filter_on_tripleStore=filter_on_tripleStore,
+            )
+        )
     return test_configs
 
 
 def get_config_param(config_graph, config_subject, config_param, convert_function):
-    raw_value = config_graph.value(subject=config_subject, predicate=config_param, any=True)
+    raw_value = config_graph.value(
+        subject=config_subject, predicate=config_param, any=True
+    )
     return convert_function(raw_value) if raw_value else None
 
 
-@dataclass
+@dataclass(frozen=True)
 class TestConfig:
     spec_path: Path
     data_path: Path
@@ -139,105 +187,92 @@ class TestConfig:
     filter_on_tripleStore: str = None
 
 
-@dataclass
+@dataclass(frozen=True)
 class TestParamWrapper:
+    id: str
     test_config: TestConfig
     unit_test: Union[Specification, SpecSkipped]
 
 
+# Configure logging
+logger = logger_setup.setup_logger(__name__)
+
+
 class MustrdTestPlugin:
     md_path: str
-    test_configs: list
+    test_config_file: Path
+    selected_tests: list
     secrets: str
     unit_tests: Union[Specification, SpecSkipped]
     items: list
+    path_filter: str
+    collect_error: BaseException
 
-    def __init__(self, md_path, test_configs, secrets):
+    def __init__(self, md_path, test_config_file, secrets):
         self.md_path = md_path
-        self.test_configs = test_configs
+        self.test_config_file = test_config_file
         self.secrets = secrets
         self.items = []
 
     @pytest.hookimpl(tryfirst=True)
     def pytest_collection(self, session):
+        logger.info("Starting test collection")
         self.unit_tests = []
         args = session.config.args
-        if len(args) > 0:
-            file_name = self.get_file_name_from_arg(args[0])
-            # Filter test to collect only specified path
-            config_to_collect = list(filter(lambda config:
-                                            # Case we want to collect everything
-                                            MUSTRD_PYTEST_PATH not in args[0]
-                                            # Case we want to collect a test or sub test
-                                            or (config.pytest_path or "") in args[0]
-                                            # Case we want to collect a whole test folder
-                                            or args[0].replace(f"./{MUSTRD_PYTEST_PATH}", "") in config.pytest_path,
-                                            self.test_configs))
-
-            # Redirect everything to test_mustrd.py,
-            # no need to filter on specified test: Only specified test will be collected anyway
-            session.config.args[0] = os.path.join(mustrd_root, "test/test_mustrd.py")
-        # Collecting only relevant tests
-
-        for one_test_config in config_to_collect:
-            triple_stores = self.get_triple_stores_from_file(one_test_config)
-
-            if one_test_config.filter_on_tripleStore and not triple_stores:
-                self.unit_tests.extend(list(map(
-                    lambda triple_store:
-                        TestParamWrapper(test_config=one_test_config,
-                                         unit_test=SpecSkipped(MUST.TestSpec, triple_store, "No triplestore found")),
-                        one_test_config.filter_on_tripleStore)))
-            else:
-                specs = self.generate_tests_for_config({"spec_path": one_test_config.spec_path,
-                                                        "data_path": one_test_config.data_path},
-                                                       triple_stores, file_name)
-                self.unit_tests.extend(list(map(
-                    lambda spec: TestParamWrapper(test_config=one_test_config, unit_test=spec), specs)))
+        logger.info("Used arguments: " + str(args))
+        self.selected_tests = list(
+            map(
+                lambda arg: Path(arg.split("::")[0]),
+                # By default the current directory is given as argument
+                # Remove it as it is not a test
+                filter(lambda arg: arg != os.getcwd() and "::" in arg, args),
+            )
+        )
+        logger.info(f"selected_tests is: {self.selected_tests}")
+
+        self.path_filter = (
+            args[0]
+            if len(args) == 1 and args[0] != os.getcwd() and not "::" in args[0]
+            else None
+        )
+        logger.info(f"path_filter is: {self.path_filter}")
+
+        session.config.args = [str(self.test_config_file.resolve())]
 
     def get_file_name_from_arg(self, arg):
-        if arg and len(arg) > 0 and "[" in arg and ".mustrd.ttl@" in arg:
-            return arg[arg.index("[") + 1: arg.index(".mustrd.ttl@")]
+        if arg and len(arg) > 0 and "[" in arg and ".mustrd.ttl " in arg:
+            return arg[arg.index("[") + 1 : arg.index(".mustrd.ttl ")]
         return None
 
-    @pytest.hookimpl(hookwrapper=True)
-    def pytest_pycollect_makeitem(self, collector, name, obj):
-        report = yield
-        if name == "test_unit":
-            items = report.get_result()
-            new_results = []
-            for item in items:
-                virtual_path = MUSTRD_PYTEST_PATH + (item.callspec.params["unit_tests"].test_config.pytest_path or "default")
-                item.fspath = Path(virtual_path)
-                item._nodeid = virtual_path + "::" + item.name
-                self.items.append(item)
-                new_results.append(item)
-            return new_results
-
-    # Hook called at collection time: reads the configuration of the tests, and generate pytests from it
-    def pytest_generate_tests(self, metafunc):
-        if len(metafunc.fixturenames) > 0:
-            if metafunc.function.__name__ == "test_unit":
-                # Create the test in itself
-                if self.unit_tests:
-                    metafunc.parametrize(metafunc.fixturenames[0], self.unit_tests,
-                                         ids=lambda test_param: (test_param.unit_test.spec_file_name or "") + "@" +
-                                         (test_param.test_config.pytest_path or ""))
-            else:
-                metafunc.parametrize(metafunc.fixturenames[0],
-                                     [SpecSkipped(MUST.TestSpec, None, "No triplestore found")],
-                                     ids=lambda x: "No configuration found for this test")
+    @pytest.hookimpl
+    def pytest_collect_file(self, parent, path):
+        logger.debug(f"Collecting file: {path}")
+        mustrd_file = MustrdFile.from_parent(parent, path=pathlib.Path(path), mustrd_plugin=self)
+        mustrd_file.mustrd_plugin = self
+        return mustrd_file
 
     # Generate test for each triple store available
     def generate_tests_for_config(self, config, triple_stores, file_name):
-
-        shacl_graph = Graph().parse(Path(os.path.join(mustrd_root, "model/mustrdShapes.ttl")))
+        logger.debug(f"generate_tests_for_config {config=} {self=} {dir(self)}")
+        shacl_graph = Graph().parse(
+            Path(os.path.join(mustrd_root, "model/mustrdShapes.ttl"))
+        )
         ont_graph = Graph().parse(Path(os.path.join(mustrd_root, "model/ontology.ttl")))
-        valid_spec_uris, spec_graph, invalid_spec_results = validate_specs(config, triple_stores,
-                                                                           shacl_graph, ont_graph, file_name or "*")
+        logger.debug("Generating tests for config: " + str(config))
+        logger.debug(f"selected_tests {self.selected_tests}")
+
+        valid_spec_uris, spec_graph, invalid_spec_results = validate_specs(
+            config,
+            triple_stores,
+            shacl_graph,
+            ont_graph,
+            file_name or "*",
+            selected_test_files=self.selected_tests,
+        )
 
-        specs, skipped_spec_results = \
-            get_specs(valid_spec_uris, spec_graph, triple_stores, config)
+        specs, skipped_spec_results = get_specs(
+            valid_spec_uris, spec_graph, triple_stores, config
+        )
 
         # Return normal specs + skipped results
         return specs + skipped_spec_results + invalid_spec_results
@@ -248,28 +283,43 @@ class MustrdTestPlugin:
         if isinstance(spec, SpecSkipped):
             triple_store = spec.triple_store
         else:
-            triple_store = spec.triple_store['type']
+            triple_store = spec.triple_store["type"]
+
         triple_store_name = triple_store.replace("https://mustrd.com/model/", "")
         test_name = spec.spec_uri.replace(spnamespace, "").replace("_", " ")
-        return triple_store_name + ": " + test_name
+        return spec.spec_file_name + " : " + triple_store_name + ": " + test_name
 
     # Get triple store configuration or default
     def get_triple_stores_from_file(self, test_config):
         if test_config.triplestore_spec_path:
             try:
-                triple_stores = get_triple_stores(get_triple_store_graph(test_config.triplestore_spec_path,
-                                                                         self.secrets))
+                triple_stores = get_triple_stores(
+                    get_triple_store_graph(
+                        test_config.triplestore_spec_path, self.secrets
+                    )
+                )
             except Exception as e:
-                print(f"""Triplestore configuration parsing failed {test_config.triplestore_spec_path}.
-                    Only rdflib will be executed""", e)
-                triple_stores = [{'type': TRIPLESTORE.RdfLib, 'uri': TRIPLESTORE.RdfLib}]
+                print(
+                    f"""Triplestore configuration parsing failed {test_config.triplestore_spec_path}.
+                    Only rdflib will be executed""",
+                    e,
+                )
+                triple_stores = [
+                    {"type": TRIPLESTORE.RdfLib, "uri": TRIPLESTORE.RdfLib}
+                ]
         else:
             print("No triple store configuration required: using embedded rdflib")
-            triple_stores = [{'type': TRIPLESTORE.RdfLib, 'uri': TRIPLESTORE.RdfLib}]
+            triple_stores = [{"type": TRIPLESTORE.RdfLib, "uri": TRIPLESTORE.RdfLib}]
 
         if test_config.filter_on_tripleStore:
-            triple_stores = list(filter(lambda triple_store: (triple_store["uri"] in test_config.filter_on_tripleStore),
-                                        triple_stores))
+            triple_stores = list(
+                filter(
+                    lambda triple_store: (
+                        triple_store["uri"] in test_config.filter_on_tripleStore
+                    ),
+                    triple_stores,
+                )
+            )
         return triple_stores
 
     # Hook function. Initialize the list of result in session
@@ -284,7 +334,7 @@ class MustrdTestPlugin:
         outcome = yield
         result = outcome.get_result()
 
-        if result.when == 'call':
+        if result.when == "call":
             # Add the result of the test to the session
             item.session.results[item] = result
 
@@ -300,7 +350,11 @@ class MustrdTestPlugin:
             if test_conf.originalname != test_conf.name:
                 module_name = test_conf.parent.name
                 class_name = test_conf.originalname
-                test_name = test_conf.name.replace(class_name, "").replace("[", "").replace("]", "")
+                test_name = (
+                    test_conf.name.replace(class_name, "")
+                    .replace("[", "")
+                    .replace("]", "")
+                )
                 is_mustrd = True
             # Case normal unit tests
             else:
@@ -309,26 +363,128 @@ class MustrdTestPlugin:
                 test_name = test_conf.originalname
                 is_mustrd = False
 
-            test_results.append(TestResult(test_name, class_name, module_name, result.outcome, is_mustrd))
-
-        result_list = ResultList(None, get_result_list(test_results,
-                                                       lambda result: result.type,
-                                                       lambda result: is_mustrd and result.test_name.split("@")[1]),
-                                 False)
+            test_results.append(
+                TestResult(
+                    test_name, class_name, module_name, result.outcome, is_mustrd
+                )
+            )
+
+        result_list = ResultList(
+            None,
+            get_result_list(
+                test_results,
+                lambda result: result.type,
+                lambda result: is_mustrd and result.test_name.split("@")[1],
+            ),
+            False,
+        )
 
         md = result_list.render()
-        with open(self.md_path, 'w') as file:
+        with open(self.md_path, "w") as file:
             file.write(md)
 
 
+class MustrdFile(pytest.File):
+    mustrd_plugin: MustrdTestPlugin
+
+    def __init__(self, *args, mustrd_plugin, **kwargs):
+        self.mustrd_plugin = mustrd_plugin
+        super(pytest.File, self).__init__(*args, **kwargs)
+
+    def collect(self):
+        try:
+            logger.debug(f"Collecting tests from file: {self.fspath}")
+            test_configs = parse_config(self.fspath)
+            for test_config in test_configs:
+                # Skip if there is a path filter and it is not in the pytest path
+                if (
+                    self.mustrd_plugin.path_filter is not None
+                    and self.mustrd_plugin.path_filter not in test_config.pytest_path
+                ):
+                    continue
+                triple_stores = self.mustrd_plugin.get_triple_stores_from_file(
+                    test_config
+                )
+
+                if test_config.filter_on_tripleStore and not triple_stores:
+                    specs = list(
+                        map(
+                            lambda triple_store: SpecSkipped(
+                                MUST.TestSpec, triple_store, "No triplestore found"
+                            ),
+                            test_config.filter_on_tripleStore,
+                        )
+                    )
+                else:
+                    specs = self.mustrd_plugin.generate_tests_for_config(
+                        {
+                            "spec_path": test_config.spec_path,
+                            "data_path": test_config.data_path,
+                        },
+                        triple_stores,
+                        None,
+                    )
+                for spec in specs:
+                    item = MustrdItem.from_parent(
+                        self,
+                        name=test_config.pytest_path + "/" + spec.spec_file_name,
+                        spec=spec,
+                    )
+                    self.mustrd_plugin.items.append(item)
+                    yield item
+        except Exception as e:
+            # Catch error here otherwise it will be lost
+            self.mustrd_plugin.collect_error = e
+            logger.error(f"Error during collection: {e}")
+            raise e
+
+
+class MustrdItem(pytest.Item):
+    def __init__(self, name, parent, spec):
+        logging.info(f"Creating item: {name}")
+        super().__init__(name, parent)
+        self.spec = spec
+        self.fspath = spec.spec_source_file
+
+    def runtest(self):
+        result = run_test_spec(self.spec)
+        if not result:
+            raise AssertionError(f"Test {self.name} failed")
+
+    def repr_failure(self, excinfo):
+        # excinfo.value is the exception instance
+        # You can add more context here
+        tb_lines = traceback.format_exception(excinfo.type, excinfo.value, excinfo.tb)
+        tb_str = "".join(tb_lines)
+        return (
+            f"{self.name} failed:\n"
+            f"Spec: {self.spec.spec_uri}\n"
+            f"File: {self.spec.spec_source_file}\n"
+            f"Dir: {dir(self.spec)}\n"
+            f"Error: {excinfo.value}\n"
+            f"Traceback:\n{tb_str}"
+        )
+    
+    def reportinfo(self):
+        r = "", 0, f"mustrd test: {self.name}"
+        return r
+
+
 # Function called in the test to actually run it
 def run_test_spec(test_spec):
     if isinstance(test_spec, SpecSkipped):
         pytest.skip(f"Invalid configuration, error : {test_spec.message}")
     result = run_spec(test_spec)
-
     result_type = type(result)
     if result_type == SpecSkipped:
         # FIXME: Better exception management
         pytest.skip("Unsupported configuration")
+    if result_type != SpecPassed:
+        write_result_diff_to_log(result, logger.info)
+        log_lines = []
+        def log_to_string(message):
+            log_lines.append(message)
+        write_result_diff_to_log(result, log_to_string)
+        raise AssertionError("Test failed: " + "\n".join(log_lines))
+
     return result_type == SpecPassed

mustrd/spec_component.py

@@ -65,6 +65,7 @@ class WhenSpec(SpecComponent):
 class AnzoWhenSpec(WhenSpec):
     paramQuery: str = None
     queryTemplate: str = None
+    spec_component_details: any = None
 
 
 @dataclass
@@ -108,6 +109,7 @@ def parse_spec_component(subject: URIRef,
     for spec_component_node in spec_component_nodes:
         data_source_types = get_data_source_types(subject, predicate, spec_graph, spec_component_node)
         for data_source_type in data_source_types:
+            log.debug(f"parse_spec_component {spec_component_node} {data_source_type} {mustrd_triple_store=}")
             spec_component_details = SpecComponentDetails(
                 subject=subject,
                 predicate=predicate,
@@ -117,6 +119,8 @@ def parse_spec_component(subject: URIRef,
                 data_source_type=data_source_type,
                 run_config=run_config,
                 root_paths=get_components_roots(spec_graph, subject, run_config))
+            
+            # get_spec_component potentially talks to anzo for EVERY spec, massively slowing things down, can we defer it to run time? 
             spec_component = get_spec_component(spec_component_details)
             if isinstance(spec_component, list):
                 spec_components += spec_component
@@ -433,10 +437,11 @@ def _get_spec_component_AnzoGraphmartDataset(spec_component_details: SpecCompone
                                                             predicate=MUST.graphmart)
         layer = spec_component_details.spec_graph.value(subject=spec_component_details.spec_component_node,
                                                         predicate=MUST.layer)
-        spec_component.value = get_spec_component_from_graphmart(
-            triple_store=spec_component_details.mustrd_triple_store,
-            graphmart=graphmart,
-            layer=layer)
+        spec_component.spec_component_details = spec_component_details
+        # return get_spec_component_from_graphmart(
+        #     triple_store=spec_component_details.mustrd_triple_store,
+        #     graphmart=graphmart,
+        #     layer=layer)
     else:
         raise ValueError(f"You must define {TRIPLESTORE.Anzo} to use {MUST.AnzoGraphmartDataset}")
 
@@ -468,14 +473,16 @@ def _get_spec_component_AnzoQueryBuilderSparqlSource(spec_component_details: Spe
 
 @get_spec_component.method((MUST.AnzoGraphmartStepSparqlSource, MUST.when))
 def _get_spec_component_AnzoGraphmartStepSparqlSource(spec_component_details: SpecComponentDetails) -> SpecComponent:
-    spec_component = init_spec_component(spec_component_details.predicate)
+    spec_component = AnzoWhenSpec()
 
     # Get WHEN specComponent from query builder
     if spec_component_details.mustrd_triple_store["type"] == TRIPLESTORE.Anzo:
         query_step_uri = spec_component_details.spec_graph.value(subject=spec_component_details.spec_component_node,
                                                                  predicate=MUST.anzoQueryStep)
-        spec_component.value = get_query_from_step(triple_store=spec_component_details.mustrd_triple_store,
-                                                   query_step_uri=query_step_uri)
+        spec_component.spec_component_details = spec_component_details
+        spec_component.query_step_uri = query_step_uri
+        # spec_component.value = get_query_from_step(triple_store=spec_component_details.mustrd_triple_store,
+        #                                            query_step_uri=query_step_uri)
     # If anzo specific function is called but no anzo defined
     else:
         raise ValueError(f"You must define {TRIPLESTORE.Anzo} to use {MUST.AnzoGraphmartStepSparqlSource}")
@@ -529,6 +536,7 @@ def _get_spec_component_AnzoGraphmartLayerSparqlSource(spec_component_details: S
         spec_component.value = query.get("query")
         spec_component.paramQuery = query.get("param_query")
         spec_component.queryTemplate = query.get("query_template")
+        spec_component.spec_component_details = spec_component_details
         if spec_component.value:
             spec_component.queryType = spec_component_details.spec_graph.value(
                 subject=spec_component_details.spec_component_node,
@@ -547,6 +555,7 @@ def _get_spec_component_default(spec_component_details: SpecComponentDetails) ->
 
 
 def init_spec_component(predicate: URIRef, triple_store_type: URIRef = None) -> GivenSpec | WhenSpec | ThenSpec | TableThenSpec: # noqa
+    log.info(f"init_spec_component {predicate} {triple_store_type}")
     if predicate == MUST.given:
         spec_component = GivenSpec()
     elif predicate == MUST.when:

mustrd/steprunner.py

@@ -31,7 +31,7 @@ from rdflib import Graph, URIRef
 from .mustrdRdfLib import execute_select as execute_select_rdflib
 from .mustrdRdfLib import execute_construct as execute_construct_rdflib
 from .mustrdRdfLib import execute_update as execute_update_rdflib
-from .mustrdAnzo import upload_given as upload_given_anzo
+from .mustrdAnzo import get_query_from_step, upload_given as upload_given_anzo
 from .mustrdAnzo import execute_update as execute_update_anzo
 from .mustrdAnzo import execute_construct as execute_construct_anzo
 from .mustrdAnzo import execute_select as execute_select_anzo
@@ -40,8 +40,9 @@ from .mustrdGraphDb import execute_update as execute_update_graphdb
 from .mustrdGraphDb import execute_construct as execute_construct_graphdb
 from .mustrdGraphDb import execute_select as execute_select_graphdb
 from .spec_component import AnzoWhenSpec, WhenSpec
+import logging
 
-log = logger_setup.setup_logger(__name__)
+log = logging.getLogger(__name__)
 
 
 def dispatch_upload_given(triple_store: dict, given: Graph):
@@ -80,7 +81,16 @@ run_when = MultiMethod('run_when', dispatch_run_when)
 
 @run_when.method((TRIPLESTORE.Anzo, MUST.UpdateSparql))
 def _anzo_run_when_update(spec_uri: URIRef, triple_store: dict, when: AnzoWhenSpec):
-    return execute_update_anzo(triple_store, when.value, when.bindings)
+    log.debug(f"_anzo_run_when_update {spec_uri} {triple_store} {when} {type(when)}")
+    if when.value is None:
+        # fetch the query from the query step on anzo
+        query = get_query_from_step(triple_store=when.spec_component_details.mustrd_triple_store,
+                                                    query_step_uri=when.query_step_uri)
+    else: 
+        # we must already have the query
+        query = when.value
+    log.debug(f"_anzo_run_when_update.query {query}")
+    return execute_update_anzo(triple_store, query, when.bindings)
 
 
 @run_when.method((TRIPLESTORE.Anzo, MUST.ConstructSparql))
@@ -95,7 +105,8 @@ def _anzo_run_when_select(spec_uri: URIRef, triple_store: dict, when: AnzoWhenSp
 
 @run_when.method((TRIPLESTORE.GraphDb, MUST.UpdateSparql))
 def _graphdb_run_when_update(spec_uri: URIRef, triple_store: dict, when: WhenSpec):
-    return execute_update_graphdb(triple_store, when.value, when.bindings)
+    
+    return execute_update_graphdb(triple_store, query, when.bindings)
 
 
 @run_when.method((TRIPLESTORE.GraphDb, MUST.ConstructSparql))
@@ -152,6 +163,7 @@ def _multi_run_when_anzo_query_driven_update(spec_uri: URIRef, triple_store: dic
 
 @run_when.method(Default)
 def _multi_run_when_default(spec_uri: URIRef, triple_store: dict, when: WhenSpec):
+    log.error(f"run_when not implemented for {spec_uri} {triple_store} {when}")
     if when.queryType == MUST.AskSparql:
         log.warning(f"Skipping {spec_uri}, SPARQL ASK not implemented.")
         msg = "SPARQL ASK not implemented."