mustrd 0.1.7__py3-none-any.whl → 0.2.0__py3-none-any.whl

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

@@ -24,7 +24,6 @@ SOFTWARE.
 
 import os
 from dataclasses import dataclass, field
-from itertools import groupby
 from pathlib import Path
 from typing import Tuple, List, Type
 
@@ -37,8 +36,9 @@ 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
+from .utils import  get_mustrd_root
 
 log = logger_setup.setup_logger(__name__)
 
@@ -84,18 +84,14 @@ class SpecComponentDetails:
     spec_component_node: Node
     data_source_type: Node
     run_config: dict
+    root_paths: list
 
-def get_path(path_type: str, run_config: dict) -> Path:
-    try:
-        if str(run_config[path_type]).startswith("/"):
-            return run_config[path_type]
-        else: 
-            return Path(os.path.join(run_config['spec_path'], run_config[path_type]))
-    except(KeyError):
-        if str(run_config['data_path']).startswith("/"):
-            return run_config['data_path']
-        else: 
-            return Path(os.path.join(run_config['spec_path'], run_config['data_path']))
+def get_path(path_type: str, file_name, spec_component_details: SpecComponentDetails) -> Path:
+    if path_type in spec_component_details.run_config:
+        relative_path = os.path.join(spec_component_details.run_config[path_type], file_name)
+    else:
+        relative_path = file_name
+    return get_file_absolute_path(spec_component_details, relative_path)
     
 
 def parse_spec_component(subject: URIRef,
@@ -117,7 +113,8 @@ def parse_spec_component(subject: URIRef,
                 mustrd_triple_store=mustrd_triple_store,
                 spec_component_node=spec_component_node,
                 data_source_type=data_source_type,
-                run_config=run_config)
+                run_config=run_config, 
+                root_paths=get_components_roots(spec_graph, subject, run_config))
             spec_component = get_spec_component(spec_component_details)
             if type(spec_component) == list:
                 spec_components += spec_component 
@@ -130,6 +127,39 @@ def parse_spec_component(subject: URIRef,
     # print(f"calling multimethod with {spec_components}")
     return combine_specs(spec_components)
 
+# Here we retrieve all the possible root paths for a specification component.
+# This defines the order of priority between root paths which is:
+# 1) Path where the spec is located
+# 2) spec_path defined in mustrd test configuration files or cmd line argument
+# 3) data_path defined in mustrd test configuration files or cmd line argument
+# 4) Mustrd source folder: In case of default resources packaged with mustrd source (will be in venv when mustrd is called as library)
+# We intentionally don't try for absolute files, but you should feel free to argue that we should do
+def get_components_roots(spec_graph: Graph, subject: URIRef, run_config: dict):
+    where_did_i_load_this_spec_from = spec_graph.value(subject=subject,
+                                                                 predicate=MUST.specSourceFile)
+    roots = [] 
+    if (where_did_i_load_this_spec_from == None):
+        log.error(f"{where_did_i_load_this_spec_from=} was None for test_spec={subject}, we didn't set the test specifications specSourceFile when loading, spec_graph={spec_graph}")
+    else:
+        roots.append(Path(os.path.dirname(where_did_i_load_this_spec_from))) 
+    if run_config and'spec_path' in run_config:
+        roots.append(Path(run_config['spec_path']))
+    if run_config and 'data_path'  in run_config:
+        roots.append(run_config['data_path'])
+    roots.append(get_mustrd_root())
+    
+    return roots
+
+
+# From the list of component potential roots, return the first path that exists
+def get_file_absolute_path(spec_component_details: SpecComponentDetails, relative_file_path: str):
+    if not relative_file_path:
+        raise ValueError("Cannot get absolute path of None")
+    absolute_file_paths = list(map(lambda root_path: Path(os.path.join(root_path, relative_file_path)), spec_component_details.root_paths))
+    for absolute_file_path in absolute_file_paths:
+        if (os.path.exists(absolute_file_path)):
+            return absolute_file_path
+    raise FileNotFoundError(f"Could not find file {relative_file_path=} in any of the {absolute_file_paths=}")
 
 def get_spec_component_type(spec_components: List[SpecComponent]) -> Type[SpecComponent]:
     # Get the type of the first object in the list
@@ -224,7 +254,7 @@ def _get_spec_component_folderdatasource_given(spec_component_details: SpecCompo
     file_name = spec_component_details.spec_graph.value(subject=spec_component_details.spec_component_node,
                                                         predicate=MUST.fileName)
 
-    path = Path(os.path.join(str(get_path('given_path',spec_component_details.run_config)), str(file_name)))
+    path = get_path('given_path', file_name,spec_component_details)
     try:
         spec_component.value = Graph().parse(data=get_spec_component_from_file(path))
     except ParserError as e:
@@ -240,7 +270,7 @@ def _get_spec_component_foldersparqlsource_when(spec_component_details: SpecComp
     file_name = spec_component_details.spec_graph.value(subject=spec_component_details.spec_component_node,
                                                         predicate=MUST.fileName)
 
-    path = Path(os.path.join(str(get_path('when_path',spec_component_details.run_config)), str(file_name)))
+    path = get_path('when_path', file_name,spec_component_details)
     spec_component.value = get_spec_component_from_file(path)
     spec_component.queryType = spec_component_details.spec_graph.value(subject=spec_component_details.spec_component_node,
                                                                        predicate=MUST.queryType)
@@ -253,7 +283,7 @@ def _get_spec_component_folderdatasource_then(spec_component_details: SpecCompon
 
     file_name = spec_component_details.spec_graph.value(subject=spec_component_details.spec_component_node,
                                                         predicate=MUST.fileName)
-    path = Path(os.path.join(str(get_path('then_path',spec_component_details.run_config)), str(file_name)))
+    path = get_path('then_path', file_name,spec_component_details)
 
     return load_dataset_from_file(path, spec_component)
 
@@ -264,27 +294,9 @@ def _get_spec_component_filedatasource(spec_component_details: SpecComponentDeta
     return load_spec_component(spec_component_details, spec_component)
 
 def load_spec_component(spec_component_details, spec_component):
-    where_did_i_load_this_spec_from = spec_component_details.spec_graph.value(subject=spec_component_details.subject,
-                                                                 predicate=MUST.specSourceFile)
-    if (where_did_i_load_this_spec_from == None):
-        log.error(f"{where_did_i_load_this_spec_from=} was None for test_spec={spec_component_details.subject}, we didn't set the test specifications specSourceFile when loading, spec_graph={spec_component_details.spec_graph}")
     file_path = Path(str(spec_component_details.spec_graph.value(subject=spec_component_details.spec_component_node,
                                                                  predicate=MUST.file)))
-    
-    test_spec_file_path = os.path.dirname(where_did_i_load_this_spec_from)
-
-    # first we try local relative to the test_spec_file_path, then we try relative to the path under test
-    # we intentionally don't try for absolute files, but you should feel free to argue that we should do.
-    paths = [
-        Path(test_spec_file_path, file_path),
-        Path(os.path.join(spec_component_details.run_config['spec_path'], file_path))
-    ]
-    
-    for path in paths:
-        if (os.path.exists(path)):
-            return load_dataset_from_file(path, spec_component)
-
-    raise FileNotFoundError(f"Could not find file {file_path=} in any of the {paths=}")
+    return load_dataset_from_file(get_file_absolute_path(spec_component_details, file_path), spec_component)
     
 
 def load_dataset_from_file(path: Path, spec_component: ThenSpec) -> ThenSpec:
@@ -320,12 +332,8 @@ def _get_spec_component_filedatasource_when(spec_component_details: SpecComponen
     spec_component = init_spec_component(spec_component_details.predicate)
 
     file_path = Path(str(spec_component_details.spec_graph.value(subject=spec_component_details.spec_component_node,
-                                                                 predicate=MUST.file)))
-    if str(file_path).startswith("/"): # absolute path
-        path = file_path
-    else: #relative path
-        path = Path(os.path.join(spec_component_details.run_config['spec_path'], file_path))
-    spec_component.value = get_spec_component_from_file(path)
+                                                                 predicate=MUST.file)))    
+    spec_component.value = get_spec_component_from_file(get_file_absolute_path(spec_component_details, file_path))
 
     spec_component.queryType = spec_component_details.spec_graph.value(subject=spec_component_details.spec_component_node,
                                                                        predicate=MUST.queryType)
@@ -417,7 +425,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 +436,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 +446,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 +456,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 +468,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 +486,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 +495,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 +505,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 +537,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.7.dist-info → mustrd-0.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mustrd
-Version: 0.1.7
+Version: 0.2.0
 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.2.0.dist-info/RECORD

@@ -0,0 +1,32 @@
+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=H-j5s3qQmcmJ9g39Q9z5z075HJ5iMapM8OcY8HgcwJs,35081
+mustrd/mustrdAnzo.py,sha256=yGoNf93n9MeKMqef8H0qm-1HKvnKm1PO-spekATL6XM,10632
+mustrd/mustrdGraphDb.py,sha256=KNXXYyZjYm_IZaeuuxlPBP-XyX9hZ5UvrdxshKnZhwo,5599
+mustrd/mustrdQueryProcessor.py,sha256=fpEzD0R7rGy2ktOBSiUpNGevxMSVJxKfxnR3BAg4yRk,6357
+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=y6tY7YDFB6f-vICYJyPN8n615BKLm49lRqqWFWiqrzg,12620
+mustrd/run.py,sha256=r3FS_iAuXYpENbbrLfgymGUP4dx-ZGJ_Y2ZvnZdL9dg,4380
+mustrd/spec_component.py,sha256=bmfHGE_8uy9yIcbvflWnhEeCW9SCbw86k0E22GQAelk,33304
+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.2.0.dist-info/entry_points.txt,sha256=v7V7sN0_L1aB4Ug_9io5axlQSeJ1C0tNrQWwdXdV58s,50
+mustrd-0.2.0.dist-info/LICENSE,sha256=OwjAcbL4HsENdMen1iYR23HH7OEn899oCt100xUo0Zo,1099
+mustrd-0.2.0.dist-info/METADATA,sha256=0_uSxV7kB9BlUOd14aTILn9waE18kPWVueSPzjFp8-I,4130
+mustrd-0.2.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+mustrd-0.2.0.dist-info/RECORD,,

mustrd-0.1.7.dist-info/RECORD

@@ -1,25 +0,0 @@
-mustrd/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mustrd/logger_setup.py,sha256=AXTXiiyQ4E_SyqNaKlLsZlkkKr_YJfJZ0N4PEoN7d7E,1630
-mustrd/model/mustrdShapes.ttl,sha256=BR-9fAwGpQt6glfPpDB0Xx3vFXMt_UTQwi469o6aWUo,9709
-mustrd/model/ontology.ttl,sha256=6xhmOF02gjP4nlOh6rnF5EWCaxWOdexQFn8YndGebck,17226
-mustrd/model/test-resources/resources.ttl,sha256=7z1P4qJwuqRdmHzKd_mhnUIs-aQoSQxas7yDCwKYarc,1558
-mustrd/mustrd.py,sha256=kAudCpk7NLoS2Y555l5Q2jhKbxR-D_sSPLa0Z3yP42w,34109
-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=k7osmdgMIoHbVryrKxBqeDXYsE84Q_D5E2HEGhcOaSs,11784
-mustrd/namespace.py,sha256=pCvLXkD_n_tS23oIizO52ylVwXGC1xFP8cHx4Mml0Ro,3326
-mustrd/README.adoc,sha256=DwXeoMy2yMgAoLvyjZHp3HQW8NBIn8wCSaNo1ixHvFo,11803
-mustrd/run.py,sha256=Ez00qZrl0Qb7P374miD8hEVucRKt_PYWdr4aorigltg,4366
-mustrd/spec_component.py,sha256=l2CP8dszFENDkUsMIC065KNMeU8tNPPMMfCyQ4a1gHc,32487
-mustrd/steprunner.py,sha256=bpa0K_WCapsH-3tbdzQkCYNQI3NnfTXy71w8Pl0-8aA,7430
-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/TestResult.py,sha256=q5BnvRxhfCEEY062rHasnA61AeKR4oXXs5z8lASvx1o,4986
-mustrd/utils.py,sha256=fuvdLE20MdkJtY5atBiU8-u7sVcq1mzIYF0gTcw1UMk,1424
-mustrd-0.1.7.dist-info/entry_points.txt,sha256=v7V7sN0_L1aB4Ug_9io5axlQSeJ1C0tNrQWwdXdV58s,50
-mustrd-0.1.7.dist-info/LICENSE,sha256=OwjAcbL4HsENdMen1iYR23HH7OEn899oCt100xUo0Zo,1099
-mustrd-0.1.7.dist-info/METADATA,sha256=wHFv9uJO64la0-lEtXel4KusPEvXTDPqLyQdHtLX5vk,4130
-mustrd-0.1.7.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-mustrd-0.1.7.dist-info/RECORD,,