mustrd 0.1.6__py3-none-any.whl → 0.1.8__py3-none-any.whl

mustrd/mustrdTestPlugin.py

@@ -27,81 +27,207 @@ import pytest
 import os
 from pathlib import Path
 from rdflib.namespace import Namespace
-from rdflib import Graph
+from rdflib import Graph, RDF
 from pytest import Session
-from typing import Dict
 
 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, SpecSkipped, validate_specs, get_specs, SpecPassed, run_spec
-from mustrd.namespace import MUST
+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.namespace import MUST, TRIPLESTORE, MUSTRDTEST
+from typing import Union
+from pyshacl import validate
 
 spnamespace = Namespace("https://semanticpartners.com/data/test/")
 
 mustrd_root = get_mustrd_root()
 
+MUSTRD_PYTEST_PATH = "mustrd_tests/"
+
+
+def pytest_addoption(parser):
+    group = parser.getgroup("mustrd option")
+    group.addoption(
+        "--mustrd",
+        action="store_true",
+        dest="mustrd",
+        help="Activate/deactivate mustrd test generation.",
+    )
+    group.addoption(
+        "--md",
+        action="store",
+        dest="mdpath",
+        metavar="pathToMdSummary",
+        default=None,
+        help="create md summary file at that path.",
+    )
+    group.addoption(
+        "--config",
+        action="store",
+        dest="configpath",
+        metavar="pathToTestConfig",
+        default=None,
+        help="Ttl file containing the list of test to construct.",
+    )
+    group.addoption(
+        "--secrets",
+        action="store",
+        dest="secrets",
+        metavar="Secrets",
+        default=None,
+        help="Give the secrets by command line in order to be able to store secrets safely in CI tools",
+    )
+    return
+
+
+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")))
+    
+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")))
+    conforms, results_graph, results_text = validate(
+            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)
+        
+    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))
+
+        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)
+    return convert_function(raw_value) if raw_value else None
+
 
 @dataclass
 class TestConfig:
-    test_function: str
     spec_path: str
     data_path: str
     triplestore_spec_path: str
-    filter_on_tripleStore: str
-
-    def __init__(self, test_function: str, spec_path: str, data_path: str, triplestore_spec_path: str,
-                 filter_on_tripleStore: str = None):
-        self.test_function = test_function
-        self.spec_path = spec_path
-        self.data_path = data_path
-        self.triplestore_spec_path = triplestore_spec_path
-        self.filter_on_tripleStore = filter_on_tripleStore
+    pytest_path: str
+    filter_on_tripleStore: str = None
+        
 
+@dataclass
+class TestParamWrapper:
+    test_config: TestConfig
+    unit_test: Union[Specification, SpecSkipped]
 
 class MustrdTestPlugin:
     md_path: str
-    test_configs: Dict[str, TestConfig]
+    test_configs: list
     secrets: str
+    unit_tests: Union[Specification, SpecSkipped]
+    items: list
 
     def __init__(self, md_path, test_configs, secrets):
         self.md_path = md_path
         self.test_configs = test_configs
         self.secrets = secrets
+        self.items = []
+    
+    @pytest.hookimpl(tryfirst=True)
+    def pytest_collection(self, session):
+        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": Path(one_test_config.spec_path),
+                                                            "data_path": 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)))
+        
+    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@")]
+        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__ in self.test_configs:
-                one_test_config = self.test_configs[metafunc.function.__name__]
-
-                triple_stores = self.get_triple_stores_from_file(one_test_config)
-
-                unit_tests = []
-                if one_test_config.filter_on_tripleStore and not triple_stores:
-                    unit_tests = list(map(lambda triple_store:
-                                      SpecSkipped(MUST.TestSpec, triple_store, "No triplestore found"),
-                                      one_test_config.filter_on_tripleStore))
-                else:
-                    unit_tests = self.generate_tests_for_config({"spec_path": Path(one_test_config.spec_path),
-                                                                "data_path": Path(one_test_config.data_path)},
-                                                                triple_stores)
-
+            if metafunc.function.__name__  == "test_unit":
                 # Create the test in itself
-                if unit_tests:
-                    metafunc.parametrize(metafunc.fixturenames[0], unit_tests, ids=self.get_test_name)
+                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")
+    
+                
+            
 
     # Generate test for each triple store available
-    def generate_tests_for_config(self, config, triple_stores):
+    def generate_tests_for_config(self, config, triple_stores, file_name):
 
         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)
+                                                                           shacl_graph, ont_graph, file_name or "*")
 
         specs, skipped_spec_results = \
             get_specs(valid_spec_uris, spec_graph, triple_stores, config)
@@ -124,17 +250,18 @@ class MustrdTestPlugin:
     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(Path(test_config.triplestore_spec_path), self.secrets))
+                triple_stores = get_triple_stores(get_triple_store_graph(Path(test_config.triplestore_spec_path),
+                                                                         self.secrets))
             except Exception as e:
-                print(f"""No triple store configuration found at {test_config.triplestore_spec_path}.
-                    Fall back: only embedded rdflib will be executed""", e)
-                triple_stores = [{'type': MUST.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': MUST.RdfLib}]
+            triple_stores = [{'type': TRIPLESTORE.RdfLib, 'uri': TRIPLESTORE.RdfLib}]
 
         if test_config.filter_on_tripleStore:
-            triple_stores = list(filter(lambda triple_store: (triple_store["type"] in test_config.filter_on_tripleStore),
+            triple_stores = list(filter(lambda triple_store: (triple_store["uri"] in test_config.filter_on_tripleStore),
                                         triple_stores))
         return triple_stores
 

mustrd/namespace.py

@@ -25,18 +25,10 @@ SOFTWARE.
 from rdflib import URIRef
 from rdflib.namespace import DefinedNamespace, Namespace
 
-
+# Namespace for the test specifications
 class MUST(DefinedNamespace):
     _NS = Namespace("https://mustrd.com/model/")
-
-    # test configuration
-    TestConfig: URIRef
-    hasTestFunction: URIRef
-    hasSpecPath: URIRef
-    hasDataPath: URIRef
-    triplestoreSpecPath: URIRef
-    filterOnTripleStore: URIRef
-
+    
     # Specification classes
     TestSpec: URIRef
     SelectSparql: URIRef
@@ -50,8 +42,6 @@ class MUST(DefinedNamespace):
     given: URIRef
     when: URIRef
     then: URIRef
-    inputGraph: URIRef 
-    outputGraph: URIRef # anzo specials? 
     dataSource: URIRef
     file: URIRef
     fileName: URIRef
@@ -84,22 +74,10 @@ class MUST(DefinedNamespace):
     fileSource: URIRef
     loadedFromFile: URIRef
     specSourceFile: URIRef
+    specFileName: URIRef
 
     # Triple store config parameters
-    url: URIRef
-    port: URIRef
-    username: URIRef
-    password: URIRef
-    inputGraph: URIRef
-    repository: URIRef
-
-    # RDFLib
-    RdfLib: URIRef
-    RdfLibConfig: URIRef
-
     # Anzo
-    Anzo: URIRef
-    AnzoConfig: URIRef
     AnzoGraphmartDataset: URIRef
     AnzoQueryBuilderSparqlSource: URIRef
     AnzoGraphmartStepSparqlSource: URIRef
@@ -107,12 +85,41 @@ class MUST(DefinedNamespace):
     AnzoGraphmartQueryDrivenTemplatedStepSparqlSource: URIRef
     anzoQueryStep: URIRef
     anzoGraphmartLayer: URIRef
-
     
     graphmart: URIRef
     layer: URIRef
-    gqeURI: URIRef
 
-    # GraphDb
+    
+    # FIXME: There is nothing to do that by default?
+    @classmethod
+    def get_local_name(cls, uri: URIRef):
+        return str(uri).split(cls._NS)[1]
+
+# Namespace for triplestores
+class TRIPLESTORE(DefinedNamespace):
+    _NS = Namespace("https://mustrd.com/triplestore/")
+    RdfLib: URIRef
     GraphDb: URIRef
-    GraphDbConfig: URIRef
+    Anzo: URIRef
+    ExternalTripleStore: URIRef
+    InternalTripleStore: URIRef
+    
+    gqeURI: URIRef
+    inputGraph: URIRef 
+    outputGraph: URIRef # anzo specials?     # Triple store config parameters
+    url: URIRef
+    port: URIRef
+    username: URIRef
+    password: URIRef
+    repository: URIRef
+
+# namespace for pytest_mustrd config
+class MUSTRDTEST(DefinedNamespace):
+    _NS = Namespace("https://mustrd.com/mustrdTest/")
+    MustrdTest: URIRef
+    hasSpecPath: URIRef
+    hasDataPath: URIRef
+    triplestoreSpecPath: URIRef
+    hasPytestPath: URIRef
+    filterOnTripleStore: URIRef
+    

mustrd/run.py

@@ -29,7 +29,7 @@ import os
 from rdflib import Graph
 from .mustrd import get_triple_store_graph, run_specs, get_triple_stores, review_results, validate_specs, get_specs
 from pathlib import Path
-from .namespace import MUST
+from .namespace import TRIPLESTORE
 from .utils import get_project_root
 import logging 
 log = logger_setup.setup_logger(__name__)
@@ -68,7 +68,7 @@ def main(argv):
         triple_stores = get_triple_stores(get_triple_store_graph(triplestore_spec_path))
     else:
         log.info(f"No triple store configuration added, running default configuration")
-        triple_stores = [{'type': MUST.RdfLib}]
+        triple_stores = [{'type': TRIPLESTORE.RdfLib}]
     log.info("Triple Stores: " + str(triple_stores))
     if args.data:
         run_config["data_path"] = Path(args.data)

mustrd/spec_component.py

@@ -37,7 +37,7 @@ import logging
 
 from . import logger_setup
 from .mustrdAnzo import get_queries_for_layer, get_queries_from_templated_step, get_spec_component_from_graphmart, get_query_from_querybuilder, get_query_from_step
-from .namespace import MUST
+from .namespace import MUST, TRIPLESTORE
 from multimethods import MultiMethod, Default
 
 log = logger_setup.setup_logger(__name__)
@@ -417,7 +417,7 @@ def _get_spec_component_StatementsDataset(spec_component_details: SpecComponentD
 def _get_spec_component_AnzoGraphmartDataset(spec_component_details: SpecComponentDetails) -> SpecComponent:
     spec_component = init_spec_component(spec_component_details.predicate)
 
-    if spec_component_details.mustrd_triple_store["type"] == MUST.Anzo:
+    if spec_component_details.mustrd_triple_store["type"] == TRIPLESTORE.Anzo:
         # Get GIVEN or THEN from anzo graphmart
         graphmart = spec_component_details.spec_graph.value(subject=spec_component_details.spec_component_node,
                                                             predicate=MUST.graphmart)
@@ -428,7 +428,7 @@ def _get_spec_component_AnzoGraphmartDataset(spec_component_details: SpecCompone
             graphmart=graphmart,
             layer=layer)
     else:
-        raise ValueError(f"You must define {MUST.AnzoConfig} to use {MUST.AnzoGraphmartDataset}")
+        raise ValueError(f"You must define {TRIPLESTORE.Anzo} to use {MUST.AnzoGraphmartDataset}")
 
     return spec_component
 
@@ -438,7 +438,7 @@ def _get_spec_component_AnzoQueryBuilderSparqlSource(spec_component_details: Spe
     spec_component = init_spec_component(spec_component_details.predicate)
 
     # Get WHEN specComponent from query builder
-    if spec_component_details.mustrd_triple_store["type"] == MUST.Anzo:
+    if spec_component_details.mustrd_triple_store["type"] == TRIPLESTORE.Anzo:
         query_folder = spec_component_details.spec_graph.value(subject=spec_component_details.spec_component_node,
                                                                predicate=MUST.queryFolder)
         query_name = spec_component_details.spec_graph.value(subject=spec_component_details.spec_component_node,
@@ -448,7 +448,7 @@ def _get_spec_component_AnzoQueryBuilderSparqlSource(spec_component_details: Spe
                                                            query_name=query_name)
     # If anzo specific function is called but no anzo defined
     else:
-        raise ValueError(f"You must define {MUST.AnzoConfig} to use {MUST.AnzoQueryBuilderSparqlSource}")
+        raise ValueError(f"You must define {TRIPLESTORE.Anzo} to use {MUST.AnzoQueryBuilderSparqlSource}")
 
     spec_component.queryType = spec_component_details.spec_graph.value(subject=spec_component_details.spec_component_node,
                                                                        predicate=MUST.queryType)
@@ -460,14 +460,14 @@ def _get_spec_component_AnzoGraphmartStepSparqlSource(spec_component_details: Sp
     spec_component = init_spec_component(spec_component_details.predicate)
 
     # Get WHEN specComponent from query builder
-    if spec_component_details.mustrd_triple_store["type"] == MUST.Anzo:
+    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)
     # If anzo specific function is called but no anzo defined
     else:
-        raise ValueError(f"You must define {MUST.AnzoConfig} to use {MUST.AnzoGraphmartStepSparqlSource}")
+        raise ValueError(f"You must define {TRIPLESTORE.Anzo} to use {MUST.AnzoGraphmartStepSparqlSource}")
 
     spec_component.queryType = spec_component_details.spec_graph.value(subject=spec_component_details.spec_component_node,
                                                                        predicate=MUST.queryType)
@@ -478,7 +478,7 @@ def _get_spec_component_AnzoGraphmartQueryDrivenTemplatedStepSparqlSource(spec_c
     spec_component = init_spec_component(spec_component_details.predicate, spec_component_details.mustrd_triple_store["type"] )
 
     # Get WHEN specComponent from query builder
-    if spec_component_details.mustrd_triple_store["type"] == MUST.Anzo:
+    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)
         queries = get_queries_from_templated_step(triple_store=spec_component_details.mustrd_triple_store,
@@ -487,7 +487,7 @@ def _get_spec_component_AnzoGraphmartQueryDrivenTemplatedStepSparqlSource(spec_c
         spec_component.queryTemplate = queries["query_template"]
     # If anzo specific function is called but no anzo defined
     else:
-        raise ValueError(f"You must define {MUST.AnzoConfig} to use {MUST.AnzoGraphmartQueryDrivenTemplatedStepSparqlSource}")
+        raise ValueError(f"You must define {TRIPLESTORE.Anzo} to use {MUST.AnzoGraphmartQueryDrivenTemplatedStepSparqlSource}")
 
     spec_component.queryType = spec_component_details.spec_graph.value(subject=spec_component_details.spec_component_node,
                                                                        predicate=MUST.queryType)
@@ -497,7 +497,7 @@ def _get_spec_component_AnzoGraphmartQueryDrivenTemplatedStepSparqlSource(spec_c
 def _get_spec_component_AnzoGraphmartLayerSparqlSource(spec_component_details: SpecComponentDetails) -> list:
     spec_components = []
     # Get the ordered  WHEN specComponents which is the transform and query driven template queries for the Layer
-    if spec_component_details.mustrd_triple_store["type"] == MUST.Anzo:
+    if spec_component_details.mustrd_triple_store["type"] == TRIPLESTORE.Anzo:
         graphmart_layer_uri = spec_component_details.spec_graph.value(subject=spec_component_details.spec_component_node,
                                                              predicate=MUST.anzoGraphmartLayer)
         queries = get_queries_for_layer(triple_store=spec_component_details.mustrd_triple_store,
@@ -529,7 +529,7 @@ def init_spec_component(predicate: URIRef, triple_store_type: URIRef = None ) ->
     if predicate == MUST.given:
         spec_component = GivenSpec()
     elif predicate == MUST.when:
-        if triple_store_type == MUST.Anzo:
+        if triple_store_type == TRIPLESTORE.Anzo:
             spec_component = AnzoWhenSpec()
         else:
             spec_component = WhenSpec()

mustrd/steprunner.py

@@ -26,7 +26,7 @@ import json
 
 from . import logger_setup
 from multimethods import MultiMethod, Default
-from .namespace import MUST
+from .namespace import MUST, TRIPLESTORE
 from rdflib import Graph, URIRef
 from .mustrdRdfLib import execute_select as execute_select_rdflib
 from .mustrdRdfLib import execute_construct as execute_construct_rdflib
@@ -53,17 +53,17 @@ def dispatch_upload_given(triple_store: dict, given: Graph):
 upload_given = MultiMethod('upload_given', dispatch_upload_given)
 
 
-@upload_given.method(MUST.RdfLib)
+@upload_given.method(TRIPLESTORE.RdfLib)
 def _upload_given_rdflib(triple_store: dict, given: Graph):
     triple_store["given"] = given
 
 
-@upload_given.method(MUST.GraphDb)
+@upload_given.method(TRIPLESTORE.GraphDb)
 def _upload_given_graphdb(triple_store: dict, given: Graph):
     upload_given_graphdb(triple_store, given)
 
 
-@upload_given.method(MUST.Anzo)
+@upload_given.method(TRIPLESTORE.Anzo)
 def _upload_given_anzo(triple_store: dict, given: Graph):
     upload_given_anzo(triple_store, given)
 
@@ -78,52 +78,52 @@ def dispatch_run_when(spec_uri: URIRef, triple_store: dict, when: WhenSpec):
 run_when = MultiMethod('run_when', dispatch_run_when)
 
 
-@run_when.method((MUST.Anzo, MUST.UpdateSparql))
+@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)
 
 
-@run_when.method((MUST.Anzo, MUST.ConstructSparql))
+@run_when.method((TRIPLESTORE.Anzo, MUST.ConstructSparql))
 def _anzo_run_when_construct(spec_uri: URIRef, triple_store: dict, when: AnzoWhenSpec):
     return execute_construct_anzo(triple_store, when.value, when.bindings)
 
 
-@run_when.method((MUST.Anzo, MUST.SelectSparql))
+@run_when.method((TRIPLESTORE.Anzo, MUST.SelectSparql))
 def _anzo_run_when_select(spec_uri: URIRef, triple_store: dict, when: AnzoWhenSpec):
     return execute_select_anzo(triple_store, when.value, when.bindings)
 
 
-@run_when.method((MUST.GraphDb, MUST.UpdateSparql))
+@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)
 
 
-@run_when.method((MUST.GraphDb, MUST.ConstructSparql))
+@run_when.method((TRIPLESTORE.GraphDb, MUST.ConstructSparql))
 def _graphdb_run_when_construct(spec_uri: URIRef, triple_store: dict, when: WhenSpec):
     return execute_construct_graphdb(triple_store, when.value, when.bindings)
 
 
-@run_when.method((MUST.GraphDb, MUST.SelectSparql))
+@run_when.method((TRIPLESTORE.GraphDb, MUST.SelectSparql))
 def _graphdb_run_when_select(spec_uri: URIRef, triple_store: dict, when: WhenSpec):
     return execute_select_graphdb(triple_store, when.value, when.bindings)
 
 
-@run_when.method((MUST.RdfLib, MUST.UpdateSparql))
+@run_when.method((TRIPLESTORE.RdfLib, MUST.UpdateSparql))
 def _rdflib_run_when_update(spec_uri: URIRef, triple_store: dict, when: WhenSpec):
     return execute_update_rdflib(triple_store, triple_store["given"], when.value, when.bindings)
 
 
-@run_when.method((MUST.RdfLib, MUST.ConstructSparql))
+@run_when.method((TRIPLESTORE.RdfLib, MUST.ConstructSparql))
 def _rdflib_run_when_construct(spec_uri: URIRef, triple_store: dict, when: WhenSpec):
     return execute_construct_rdflib(triple_store, triple_store["given"], when.value, when.bindings)
 
 
-@run_when.method((MUST.RdfLib, MUST.SelectSparql))
+@run_when.method((TRIPLESTORE.RdfLib, MUST.SelectSparql))
 def _rdflib_run_when_select(spec_uri: URIRef, triple_store: dict, when: WhenSpec):
     return execute_select_rdflib(triple_store, triple_store["given"], when.value, when.bindings)
 
 
-@run_when.method((MUST.Anzo, MUST.AnzoQueryDrivenUpdateSparql))
+@run_when.method((TRIPLESTORE.Anzo, MUST.AnzoQueryDrivenUpdateSparql))
 def _multi_run_when_anzo_query_driven_update(spec_uri: URIRef, triple_store: dict, when: AnzoWhenSpec):
     # run the parameters query to obtain the values for the template step and put them into a dictionary
     query_parameters = json.loads(execute_select_anzo(triple_store, when.paramQuery, None))
@@ -158,7 +158,7 @@ def _multi_run_when_default(spec_uri: URIRef, triple_store: dict, when: WhenSpec
     elif when.queryType == MUST.DescribeSparql:
         log.warning(f"Skipping {spec_uri}, SPARQL DESCRIBE not implemented.")
         msg = "SPARQL DESCRIBE not implemented."
-    elif triple_store['type'] not in [MUST.Anzo, MUST.GraphDb, MUST.RdfLib]:
+    elif triple_store['type'] not in [TRIPLESTORE.Anzo, TRIPLESTORE.GraphDb, TRIPLESTORE.RdfLib]:
         msg = f"{when.queryType} not implemented for {triple_store['type']}"
     else:
         log.warning(f"Skipping {spec_uri},  {when.queryType} is not a valid SPARQL query type.")

mustrd/test/test_mustrd.py

@@ -0,0 +1,5 @@
+from mustrd.mustrdTestPlugin import run_test_spec
+
+
+def test_unit(unit_tests):
+    assert run_test_spec(unit_tests.unit_test)

{mustrd-0.1.6.dist-info → mustrd-0.1.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mustrd
-Version: 0.1.6
+Version: 0.1.8
 Summary: A Spec By Example framework for RDF and SPARQL, Inspired by Cucumber.
 Home-page: https://github.com/Semantic-partners/mustrd
 License: MIT

mustrd-0.1.8.dist-info/RECORD

@@ -0,0 +1,31 @@
+mustrd/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mustrd/logger_setup.py,sha256=AXTXiiyQ4E_SyqNaKlLsZlkkKr_YJfJZ0N4PEoN7d7E,1630
+mustrd/model/catalog-v001.xml,sha256=jgD6VOxR6A8izzr3ZmL4AzaTZ5cVwsvt618MTuRlGBk,386
+mustrd/model/mustrdShapes.ttl,sha256=BR-9fAwGpQt6glfPpDB0Xx3vFXMt_UTQwi469o6aWUo,9709
+mustrd/model/mustrdTestOntology.ttl,sha256=W7IRbPKrhpYFweZvc9QH8gdjBiuZMHKETIuHBepLnYw,2034
+mustrd/model/mustrdTestShapes.ttl,sha256=Bcof6p7MtzO2L6H1DWB1hibLSix7Dxo-z6HlFcG31M8,842
+mustrd/model/ontology.ttl,sha256=JF6LG5-T7tbi3QfmJcEFQcFo-rQT0CTYGg7PEmuzINY,17303
+mustrd/model/test-resources/resources.ttl,sha256=7z1P4qJwuqRdmHzKd_mhnUIs-aQoSQxas7yDCwKYarc,1558
+mustrd/model/triplestoreOntology.ttl,sha256=87leTcKot45AgcCGfJLEwbY9rsuRGHbYbnTFeijrzOk,6199
+mustrd/model/triplestoreshapes.ttl,sha256=qiLzbclGDzueH5GCKANEwMM9VxOmswu42FiSnITATeQ,1876
+mustrd/mustrd.py,sha256=-obRBvgFU5QiI5k4zTaf473aHkgvl3ZHQ2xVkdSxS8c,35099
+mustrd/mustrdAnzo.py,sha256=bQ-IHCnsEK7paJ31GgS9IH3hGd4o_5zeNrpn0Sb8WIk,11822
+mustrd/mustrdGraphDb.py,sha256=KNXXYyZjYm_IZaeuuxlPBP-XyX9hZ5UvrdxshKnZhwo,5599
+mustrd/mustrdRdfLib.py,sha256=LeS-uArlxQwsM-7lrJyp8O8m-6VgxsR1BlpxsOCNePs,2129
+mustrd/mustrdTestPlugin.py,sha256=SsTkwrs0n1lvHvuiyQs-z4dsXnjB7p3d6aFWR8_jLV8,15035
+mustrd/namespace.py,sha256=3zJbdWEji_2SkhasHK3J2UO3am_phNKDwAFk2htXRYM,3765
+mustrd/README.adoc,sha256=56W59hX4xyttspTXUXRJAgqemBSVavWHpfs6Lar_-qo,11995
+mustrd/run.py,sha256=r3FS_iAuXYpENbbrLfgymGUP4dx-ZGJ_Y2ZvnZdL9dg,4380
+mustrd/spec_component.py,sha256=0D81UlZEpUGk9FZfzUElp8a6kEoFsfkr7bGasKDTdSU,32546
+mustrd/steprunner.py,sha256=n3k4O2SjsLUEG5QOxLG8Z8D3iH9PJzzR63dIV2KHcBE,7555
+mustrd/templates/md_ResultList_leaf_template.jinja,sha256=un1XMeNO9xLcry-DmTQ2QoWoTM5Q5CkVUV_LS4O7sHM,526
+mustrd/templates/md_ResultList_template.jinja,sha256=RrTaPN1obsTEpG5BjQp7BV9iBFzZOXHwslgvyC0hDKY,211
+mustrd/templates/md_stats_template.jinja,sha256=DlNfH9eoEFVHQmvp6QNbQv36cqRLyBkqG1ITOHb_Yu8,157
+mustrd/test/test_mustrd.py,sha256=Q2qTTY--I0wfhgHW7hnkIoV3t_sUTXm8xMmirJaFc7o,129
+mustrd/TestResult.py,sha256=q5BnvRxhfCEEY062rHasnA61AeKR4oXXs5z8lASvx1o,4986
+mustrd/utils.py,sha256=fuvdLE20MdkJtY5atBiU8-u7sVcq1mzIYF0gTcw1UMk,1424
+mustrd-0.1.8.dist-info/entry_points.txt,sha256=v7V7sN0_L1aB4Ug_9io5axlQSeJ1C0tNrQWwdXdV58s,50
+mustrd-0.1.8.dist-info/LICENSE,sha256=OwjAcbL4HsENdMen1iYR23HH7OEn899oCt100xUo0Zo,1099
+mustrd-0.1.8.dist-info/METADATA,sha256=lxU94amogEOoqPHnF1cdKqK8ceXahLbgpXudBQ3pGCg,4130
+mustrd-0.1.8.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+mustrd-0.1.8.dist-info/RECORD,,

mustrd-0.1.8.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[pytest11]
+mustrd_plugin=mustrd.mustrdTestPlugin
+