mustrd 0.3.3a1__tar.gz → 0.3.4a1__tar.gz

{mustrd-0.3.3a1 → mustrd-0.3.4a1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: mustrd
-Version: 0.3.3a1
+Version: 0.3.4a1
 Summary: A Spec By Example framework for RDF and SPARQL, Inspired by Cucumber.
 License: MIT
 Author: John Placek
@@ -34,13 +34,13 @@ Requires-Dist: urllib3 (==1.26.19)
 Project-URL: Repository, https://github.com/Semantic-partners/mustrd
 Description-Content-Type: text/markdown
 
-# mustrd
+# MustRD
 
 **"MustRD: Validate your SPARQL queries and transformations with precision and confidence, using BDD and Given-When-Then principles."**
 
-[<img src="https://github.com/Semantic-partners/mustrd/raw/python-coverage-comment-action-data/badge.svg?sanitize=true" alt="coverage badge">](https://github.com/Semantic-partners/mustrd/tree/python-coverage-comment-action-data)
+[![Coverage Badge](https://github.com/Semantic-partners/mustrd/raw/python-coverage-comment-action-data/badge.svg?sanitize=true)](https://github.com/Semantic-partners/mustrd/tree/python-coverage-comment-action-data)
 
-### Why?
+## Why?
 
 SPARQL is a powerful query language for RDF data, but how can you ensure your queries and transformations are doing what you intend? Whether you're working on a pipeline or a standalone query, certainty is key.
 
@@ -48,11 +48,11 @@ While RDF and SPARQL offer great flexibility, we noticed a gap in tooling to val
 
 With MustRD, you can:
 
-* Define data scenarios and verify that queries produce the expected results.
-* Test edge cases to ensure your queries remain reliable.
-* Isolate small SPARQL enrichment or transformation steps and confirm you're only inserting what you intend.
+- Define data scenarios and verify that queries produce the expected results.
+- Test edge cases to ensure your queries remain reliable.
+- Isolate small SPARQL enrichment or transformation steps and confirm you're only inserting what you intend.
 
-### What?
+## What?
 
 MustRD is a Spec-By-Example ontology with a reference Python implementation, inspired by tools like Cucumber. It uses the Given-When-Then approach to define and validate SPARQL queries and transformations.
 
@@ -62,23 +62,85 @@ MustRD is designed to be triplestore/SPARQL engine agnostic, leveraging open sta
 
 MustRD is not an alternative to SHACL. While SHACL validates data structures, MustRD focuses on validating data transformations and query results.
 
-### How?
+## How?
 
 You define your specs in Turtle (`.ttl`) or TriG (`.trig`) files using the Given-When-Then approach:
 
-* **Given**: Define the starting dataset.
-* **When**: Specify the action (e.g., a SPARQL query).
-* **Then**: Outline the expected results.
+- **Given**: Define the starting dataset.
+- **When**: Specify the action (e.g., a SPARQL query).
+- **Then**: Outline the expected results.
 
 Depending on the type of SPARQL query (CONSTRUCT, SELECT, INSERT/DELETE), MustRD runs the query and compares the results against the expectations defined in the spec.
 
 Expectations can also be defined as:
 
-* INSERT queries.
-* SELECT queries.
-* Higher-order expectation languages, similar to those used in various platforms.
+- INSERT queries.
+- SELECT queries.
+- Higher-order expectation languages, similar to those used in various platforms.
 
-### When?
+## Example
+
+### Configuration File
+
+You'll have a configuration `.ttl` file, which acts as a suite of tests. It tells MustRD where to look for test specifications and any triplestore configurations you might have:
+
+```ttl
+:test_example a :MustrdTest;
+              :hasSpecPath "test/specs/";
+              :hasDataPath "test/data/";
+              :hasPytestPath "example";
+              :triplestoreSpecPath "test/triplestore_config/triplestores.ttl";
+              :filterOnTripleStore triplestore:example_test .
+```
+
+### Test Specification
+
+In the directory specified by `:hasSpecPath`, you'll have one or more `.mustrd.ttl` files. These can be organized in a directory structure. MustRD collects them and reports results to your test runner.
+
+```ttl
+:test_example :given [ a :FileDataset ;
+                       :file "test/data/given.ttl" ] ;
+              :when [ a :TextSparqlSource ;
+                     :queryText "SELECT ?s ?p ?o WHERE { ?s ?p ?o }" ;
+                     :queryType :SelectSparql ] ;
+              :then [ a :OrderedTableDataset ;
+                     :hasRow [ :variable "s" ; :boundValue "example:subject" ;
+                               :variable "p" ; :boundValue "example:predicate" ;
+                               :variable "o" ; :boundValue "example:object" ] ].
+```
+
+And you will have a `'test/data/given.ttl'` which contains the given ttl. 
+
+```ttl
+example:subject example:predicate example:object .
+```
+
+### Running Tests
+
+Run the test using the MustRD Pytest plugin:
+
+```bash
+poetry run pytest --mustrd --config=test/mustrd_configuration.ttl --md=render/github_job_summary.md
+```
+
+This will validate your SPARQL queries against the defined dataset and expected results, ensuring your transformations behave as intended.
+
+You can refer to SPARQL inline, in files, or in Anzo Graphmarts, Steps, or Layers. See `GETSTARTED.adoc` for more details.
+
+#### Integrating with Visual Studio Code (vscode)
+We have a pytest plugin.
+1. Choose a python interpreter (probably a venv)
+2. `pip install mustrd ` in it.
+3. add to your settings.json
+```json
+    "python.testing.pytestArgs": [
+        "--mustrd", "--md=junit/github_job_summary.md", "--config=test/test_config_local.ttl"
+    ],
+```
+4. VS Code should auto discover your tests and they'll show up in the flask icon 'tab'.
+![alt text](image.png)
+
+## When?
 
 MustRD is a work in progress, built to meet the needs of our projects across multiple clients and vendor stacks. While we find it useful, it may not meet your needs out of the box.
 
@@ -89,3 +151,4 @@ We invite you to try it, raise issues, or contribute via pull requests. If you n
 Semantic Partners is a specialist consultancy in Semantic Technology. If you need more support, contact us at info@semanticpartners.com or mustrd@semanticpartners.com.
 
 
+

mustrd-0.3.4a1/README.md

@@ -0,0 +1,117 @@
+# MustRD
+
+**"MustRD: Validate your SPARQL queries and transformations with precision and confidence, using BDD and Given-When-Then principles."**
+
+[![Coverage Badge](https://github.com/Semantic-partners/mustrd/raw/python-coverage-comment-action-data/badge.svg?sanitize=true)](https://github.com/Semantic-partners/mustrd/tree/python-coverage-comment-action-data)
+
+## Why?
+
+SPARQL is a powerful query language for RDF data, but how can you ensure your queries and transformations are doing what you intend? Whether you're working on a pipeline or a standalone query, certainty is key.
+
+While RDF and SPARQL offer great flexibility, we noticed a gap in tooling to validate their behavior. We missed the robust testing frameworks available in imperative programming languages that help ensure your code works as expected.
+
+With MustRD, you can:
+
+- Define data scenarios and verify that queries produce the expected results.
+- Test edge cases to ensure your queries remain reliable.
+- Isolate small SPARQL enrichment or transformation steps and confirm you're only inserting what you intend.
+
+## What?
+
+MustRD is a Spec-By-Example ontology with a reference Python implementation, inspired by tools like Cucumber. It uses the Given-When-Then approach to define and validate SPARQL queries and transformations.
+
+MustRD is designed to be triplestore/SPARQL engine agnostic, leveraging open standards to ensure compatibility across different platforms.
+
+### What it is NOT
+
+MustRD is not an alternative to SHACL. While SHACL validates data structures, MustRD focuses on validating data transformations and query results.
+
+## How?
+
+You define your specs in Turtle (`.ttl`) or TriG (`.trig`) files using the Given-When-Then approach:
+
+- **Given**: Define the starting dataset.
+- **When**: Specify the action (e.g., a SPARQL query).
+- **Then**: Outline the expected results.
+
+Depending on the type of SPARQL query (CONSTRUCT, SELECT, INSERT/DELETE), MustRD runs the query and compares the results against the expectations defined in the spec.
+
+Expectations can also be defined as:
+
+- INSERT queries.
+- SELECT queries.
+- Higher-order expectation languages, similar to those used in various platforms.
+
+## Example
+
+### Configuration File
+
+You'll have a configuration `.ttl` file, which acts as a suite of tests. It tells MustRD where to look for test specifications and any triplestore configurations you might have:
+
+```ttl
+:test_example a :MustrdTest;
+              :hasSpecPath "test/specs/";
+              :hasDataPath "test/data/";
+              :hasPytestPath "example";
+              :triplestoreSpecPath "test/triplestore_config/triplestores.ttl";
+              :filterOnTripleStore triplestore:example_test .
+```
+
+### Test Specification
+
+In the directory specified by `:hasSpecPath`, you'll have one or more `.mustrd.ttl` files. These can be organized in a directory structure. MustRD collects them and reports results to your test runner.
+
+```ttl
+:test_example :given [ a :FileDataset ;
+                       :file "test/data/given.ttl" ] ;
+              :when [ a :TextSparqlSource ;
+                     :queryText "SELECT ?s ?p ?o WHERE { ?s ?p ?o }" ;
+                     :queryType :SelectSparql ] ;
+              :then [ a :OrderedTableDataset ;
+                     :hasRow [ :variable "s" ; :boundValue "example:subject" ;
+                               :variable "p" ; :boundValue "example:predicate" ;
+                               :variable "o" ; :boundValue "example:object" ] ].
+```
+
+And you will have a `'test/data/given.ttl'` which contains the given ttl. 
+
+```ttl
+example:subject example:predicate example:object .
+```
+
+### Running Tests
+
+Run the test using the MustRD Pytest plugin:
+
+```bash
+poetry run pytest --mustrd --config=test/mustrd_configuration.ttl --md=render/github_job_summary.md
+```
+
+This will validate your SPARQL queries against the defined dataset and expected results, ensuring your transformations behave as intended.
+
+You can refer to SPARQL inline, in files, or in Anzo Graphmarts, Steps, or Layers. See `GETSTARTED.adoc` for more details.
+
+#### Integrating with Visual Studio Code (vscode)
+We have a pytest plugin.
+1. Choose a python interpreter (probably a venv)
+2. `pip install mustrd ` in it.
+3. add to your settings.json
+```json
+    "python.testing.pytestArgs": [
+        "--mustrd", "--md=junit/github_job_summary.md", "--config=test/test_config_local.ttl"
+    ],
+```
+4. VS Code should auto discover your tests and they'll show up in the flask icon 'tab'.
+![alt text](image.png)
+
+## When?
+
+MustRD is a work in progress, built to meet the needs of our projects across multiple clients and vendor stacks. While we find it useful, it may not meet your needs out of the box.
+
+We invite you to try it, raise issues, or contribute via pull requests. If you need custom features, contact us for consultancy rates, and we may prioritize your request.
+
+## Support
+
+Semantic Partners is a specialist consultancy in Semantic Technology. If you need more support, contact us at info@semanticpartners.com or mustrd@semanticpartners.com.
+
+

{mustrd-0.3.3a1 → mustrd-0.3.4a1}/mustrd/model/mustrdShapes.ttl

@@ -169,6 +169,7 @@ must:SparqlSourceShape
     a              sh:NodeShape ;
     sh:targetClass must:SparqlSource ;
     sh:property    [ sh:path     must:queryType ;
+                     sh:in ( must:SelectSparql  must:ConstructSparql must:UpdateSparql) ;
                      sh:minCount 1 ;
                      sh:maxCount 1 ; ] .
 

{mustrd-0.3.3a1 → mustrd-0.3.4a1}/mustrd/mustrd.py

@@ -134,7 +134,7 @@ class TripleStoreConnectionError(SpecResult):
 
 
 @dataclass
-class SpecSkipped(SpecResult):
+class SpecInvalid(SpecResult):
     message: str
     spec_file_name: str = "default.mustrd.ttl"
     spec_source_file: Path = Path("default.mustrd.ttl")
@@ -204,6 +204,12 @@ def validate_specs(
                 f"Could not extract spec from {file} due to exception of type "
                 f"{type(e).__name__} when parsing file"
             ]
+            invalid_specs += [
+                SpecInvalid(
+                    "urn:invalid_spec_file", triple_store["type"], message, file.name, file
+                )
+                for triple_store in triple_stores
+            ]
             continue
 
         # run shacl validation
@@ -310,7 +316,7 @@ def add_spec_validation(
             error_messages.sort()
             error_message = "\n".join(msg for msg in error_messages)
             invalid_specs += [
-                SpecSkipped(
+                SpecInvalid(
                     subject_uri, triple_store["type"], error_message, file.name, file
                 )
                 for triple_store in triple_stores
@@ -324,15 +330,15 @@ def get_specs(
     run_config: dict,
 ):
     specs = []
-    skipped_results = []
+    invalid_spec = []
     try:
         for triple_store in triple_stores:
             if "error" in triple_store:
                 log.error(
                     f"{triple_store['error']}. No specs run for this triple store."
                 )
-                skipped_results += [
-                    SpecSkipped(
+                invalid_spec += [
+                    SpecInvalid(
                         spec_uri,
                         triple_store["type"],
                         triple_store["error"],
@@ -360,8 +366,8 @@ def get_specs(
                             )
                             or "unknown"
                         )
-                        skipped_results += [
-                            SpecSkipped(
+                        invalid_spec += [
+                            SpecInvalid(
                                 spec_uri,
                                 triple_store["type"],
                                 str(e),
@@ -380,7 +386,7 @@ def get_specs(
         log.error("No specifications will be run.")
 
     log.info(f"Extracted {len(specs)} specifications that will be run")
-    return specs, skipped_results
+    return specs, invalid_spec
 
 
 def run_specs(specs) -> List[SpecResult]:
@@ -505,7 +511,7 @@ def run_spec(spec: Specification) -> SpecResult:
         upload_given(triple_store, spec.given)
     else:
         if triple_store["type"] == TRIPLESTORE.RdfLib:
-            return SpecSkipped(
+            return SpecInvalid(
                 spec_uri,
                 triple_store["type"],
                 "Unable to run Inherited State tests on Rdflib",
@@ -526,7 +532,6 @@ def run_spec(spec: Specification) -> SpecResult:
             except NotImplementedError as ex:
                 log.error(f"NotImplementedError {ex}")
                 raise ex
-                # return SpecSkipped(spec_uri, triple_store["type"], ex.args[0])
         return check_result(spec, result)
     except (ConnectionError, TimeoutError, HTTPError, ConnectTimeout, OSError) as e:
         # close_connection = False
@@ -548,38 +553,13 @@ def run_spec(spec: Specification) -> SpecResult:
 
 
 def get_triple_store_graph(triple_store_graph_path: Path, secrets: str):
-    graph = Graph()
-    # Parse the main triple store graph file
-    try:
-        graph.parse(triple_store_graph_path)
-    except Exception as e:
-        log.error(f"Failed to parse triple store graph file '{triple_store_graph_path}': {e}")
-        raise
-
-    # Parse secrets, either from string or from file
     if secrets:
-        log.info("Parsing secrets from provided string (--secrets option)")
-        log.info("" + secrets)
-        try:
-            graph.parse(data=secrets)
-        except Exception as e:
-            log.error(f"Failed to parse secrets data for triple store graph: {e}")
-            raise
+        return Graph().parse(triple_store_graph_path).parse(data=secrets)
     else:
-        secret_path = triple_store_graph_path.with_name(
+        secret_path = triple_store_graph_path.parent / Path(
             triple_store_graph_path.stem + "_secrets" + triple_store_graph_path.suffix
         )
-        log.info("Parsing secrets from secrets file: " + str(secret_path))
-        if secret_path.exists():
-            try:
-                graph.parse(secret_path)
-            except Exception as e:
-                log.error(f"Failed to parse secrets file '{secret_path}': {e}")
-                raise
-        else:
-            log.info(f"No secrets file found at '{secret_path}', continuing without it.")
-
-    return graph
+        return Graph().parse(triple_store_graph_path).parse(secret_path)
 
 
 # Parse and validate triple store configuration
@@ -973,8 +953,8 @@ def write_result_diff_to_log(res, info):
     ):
         info(f"{Fore.RED}Failed {res.spec_uri} {res.triple_store}")
         info(res.exception)
-    if isinstance(res, SpecSkipped):
-        info(f"{Fore.YELLOW}Skipped {res.spec_uri} {res.triple_store}")
+    if isinstance(res, SpecInvalid):
+        info(f"{Fore.RED} Invalid {res.spec_uri} {res.triple_store}")
         info(res.message)
 
 
@@ -1071,7 +1051,7 @@ def review_results(results: List[SpecResult], verbose: bool) -> None:
     colours = {
         SpecPassed: Fore.GREEN,
         SpecPassedWithWarning: Fore.YELLOW,
-        SpecSkipped: Fore.YELLOW,
+        SpecInvalid: Fore.RED,
     }
     # Populate dictionaries from results
     for result in results:
@@ -1128,12 +1108,12 @@ def review_results(results: List[SpecResult], verbose: bool) -> None:
 
     pass_count = statuses.count(SpecPassed)
     warning_count = statuses.count(SpecPassedWithWarning)
-    skipped_count = statuses.count(SpecSkipped)
+    invalid_count = statuses.count(SpecInvalid)
     fail_count = len(
         list(
             filter(
                 lambda status: status
-                not in [SpecPassed, SpecPassedWithWarning, SpecSkipped],
+                not in [SpecPassed, SpecPassedWithWarning, SpecInvalid],
                 statuses,
             )
         )
@@ -1141,18 +1121,18 @@ def review_results(results: List[SpecResult], verbose: bool) -> None:
 
     if fail_count:
         overview_colour = Fore.RED
-    elif warning_count or skipped_count:
+    elif warning_count or invalid_count:
         overview_colour = Fore.YELLOW
     else:
         overview_colour = Fore.GREEN
 
     logger_setup.flush()
     log.info(
-        f"{overview_colour}===== {fail_count} failures, {skipped_count} skipped, {Fore.GREEN}{pass_count} passed, "
+        f"{overview_colour}===== {fail_count} failures, {invalid_count} invalid, {Fore.GREEN}{pass_count} passed, "
         f"{overview_colour}{warning_count} passed with warnings ====="
     )
 
-    if verbose and (fail_count or warning_count or skipped_count):
+    if verbose and (fail_count or warning_count or invalid_count):
         display_verbose(results)
 
 
@@ -1190,8 +1170,8 @@ def display_verbose(results: List[SpecResult]):
         ):
             log.info(f"{Fore.RED}Failed {res.spec_uri} {res.triple_store}")
             log.info(res.exception)
-        if isinstance(res, SpecSkipped):
-            log.info(f"{Fore.YELLOW}Skipped {res.spec_uri} {res.triple_store}")
+        if isinstance(res, SpecInvalid):
+            log.info(f"{Fore.YELLOW}Invalid {res.spec_uri} {res.triple_store}")
             log.info(res.message)
 
 

{mustrd-0.3.3a1 → mustrd-0.3.4a1}/mustrd/mustrdAnzo.py

@@ -98,8 +98,11 @@ def get_query_from_step(triple_store: dict, query_step_uri: URIRef) -> str:
             ?stepUri a <http://cambridgesemantics.com/ontologies/Graphmarts#Step>;
                      <http://cambridgesemantics.com/ontologies/Graphmarts#transformQuery> ?query
     }}"""
-    return json_to_dictlist(query_configuration(anzo_config=triple_store, query=query))[0]['query']
-
+    result = json_to_dictlist(query_configuration(anzo_config=triple_store, query=query))
+    if len(result) == 0:
+        raise FileNotFoundError(
+            f"Querynot found for step {query_step_uri}")
+    return result[0].get("query")
 
 def get_queries_from_templated_step(triple_store: dict, query_step_uri: URIRef) -> dict:
     query = f"""SELECT ?param_query ?query_template WHERE {{
@@ -109,8 +112,11 @@ def get_queries_from_templated_step(triple_store: dict, query_step_uri: URIRef)
                         <http://cambridgesemantics.com/ontologies/Graphmarts#template> ?query_template .
     }}
     """
-    return json_to_dictlist(query_configuration(anzo_config=triple_store, query=query))[0]
-
+    result = json_to_dictlist(query_configuration(anzo_config=triple_store, query=query))
+    if len(result) == 0:
+        raise FileNotFoundError(
+            f"Templated query not found for {query_step_uri}")
+    return result[0]
 
 def get_queries_for_layer(triple_store: dict, graphmart_layer_uri: URIRef):
     query = f"""PREFIX graphmarts: <http://cambridgesemantics.com/ontologies/Graphmarts#>
@@ -129,8 +135,11 @@ SELECT ?query ?param_query ?query_template
       . }}
   }}
   ORDER BY ?index"""
-    return json_to_dictlist(query_configuration(anzo_config=triple_store, query=query))
-
+    result = json_to_dictlist(query_configuration(anzo_config=triple_store, query=query))
+    if len(result) == 0:
+        raise FileNotFoundError(
+            f"Queries not found for graphmart layer {graphmart_layer_uri}")
+    return result
 
 def upload_given(triple_store: dict, given: Graph):
     logging.debug(f"upload_given {triple_store} {given}")

{mustrd-0.3.3a1 → mustrd-0.3.4a1}/mustrd/mustrdTestPlugin.py

@@ -2,7 +2,7 @@ import logging
 from dataclasses import dataclass
 import pytest
 import os
-from pathlib import Path, PosixPath
+from pathlib import Path
 from rdflib.namespace import Namespace
 from rdflib import Graph, RDF
 from pytest import Session
@@ -11,20 +11,16 @@ 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 (
-    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,
+    write_result_diff_to_log,
+    get_triple_store_graph,
+    get_triple_stores,
+    SpecInvalid
 )
 from mustrd.namespace import MUST, TRIPLESTORE, MUSTRDTEST
-from typing import Union
 from pyshacl import validate
 
 import pathlib
@@ -171,13 +167,6 @@ class TestConfig:
     filter_on_tripleStore: str = None
 
 
-@dataclass(frozen=True)
-class TestParamWrapper:
-    id: str
-    test_config: TestConfig
-    unit_test: Union[Specification, SpecSkipped]
-
-
 # Configure logging
 logger = logger_setup.setup_logger(__name__)
 
@@ -187,7 +176,6 @@ class MustrdTestPlugin:
     test_config_file: Path
     selected_tests: list
     secrets: str
-    unit_tests: Union[Specification, SpecSkipped]
     items: list
     path_filter: str
     collect_error: BaseException
@@ -201,18 +189,17 @@ class MustrdTestPlugin:
     @pytest.hookimpl(tryfirst=True)
     def pytest_collection(self, session):
         logger.info("Starting test collection")
-        
-        self.unit_tests = []
+
         args = session.config.args
-        
+
         # Split args into mustrd and regular pytest args
         mustrd_args = [arg for arg in args if ".mustrd.ttl" in arg]
         pytest_args = [arg for arg in args if arg != os.getcwd() and ".mustrd.ttl" not in arg]
-        
+
         self.selected_tests = list(
             map(
                 lambda arg: Path(arg.split("::")[0]),
-                mustrd_args 
+                mustrd_args
             )
         )
         logger.info(f"selected_tests is: {self.selected_tests}")
@@ -237,7 +224,7 @@ class MustrdTestPlugin:
 
     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 arg[arg.index("[") + 1: arg.index(".mustrd.ttl ")]
         return None
 
     @pytest.hookimpl
@@ -247,9 +234,9 @@ class MustrdTestPlugin:
         if not str(path).endswith('.ttl'):
             return None
         if Path(path).resolve() != Path(self.test_config_file).resolve():
-                logger.debug(f"{self.test_config_file}: Skipping non-matching-config file: {path}")
-                return None
-        
+            logger.debug(f"{self.test_config_file}: Skipping non-matching-config file: {path}")
+            return None
+
         mustrd_file = MustrdFile.from_parent(parent, path=pathlib.Path(path), mustrd_plugin=self)
         mustrd_file.mustrd_plugin = self
         return mustrd_file
@@ -264,7 +251,7 @@ class MustrdTestPlugin:
         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(
+        valid_spec_uris, spec_graph, invalid_specs = validate_specs(
             config,
             triple_stores,
             shacl_graph,
@@ -272,17 +259,6 @@ class MustrdTestPlugin:
             file_name or "*",
             selected_test_files=self.selected_tests,
         )
-        # Convert invalid specs to SpecInvalid instead of SpecSkipped
-        invalid_specs = [
-            SpecInvalid(
-                spec.spec_uri,
-                spec.triple_store,
-                spec.message,
-                spec.spec_file_name,
-                spec.spec_source_file
-            ) for spec in invalid_spec_results
-        ]
-
 
         specs, skipped_spec_results = get_specs(
             valid_spec_uris, spec_graph, triple_stores, config
@@ -291,18 +267,6 @@ class MustrdTestPlugin:
         # Return normal specs + skipped results
         return specs + skipped_spec_results + invalid_specs
 
-    # Function called to generate the name of the test
-    def get_test_name(self, spec):
-        # FIXME: SpecSkipped should have the same structure?
-        if isinstance(spec, SpecSkipped):
-            triple_store = spec.triple_store
-        else:
-            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 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:
@@ -397,13 +361,6 @@ class MustrdTestPlugin:
         with open(self.md_path, "w") as file:
             file.write(md)
 
-@dataclass(frozen=True)
-class SpecInvalid:
-    spec_uri: str
-    triple_store: str
-    message: str
-    spec_file_name: str = None
-    spec_source_file: Path = None
 
 class MustrdFile(pytest.File):
     mustrd_plugin: MustrdTestPlugin
@@ -417,14 +374,14 @@ class MustrdFile(pytest.File):
         try:
             logger.info(f"{self.mustrd_plugin.test_config_file}: Collecting tests from file: {self.path=}")
             # Only process the specific mustrd config file we were given
-            
+
             # if not str(self.fspath).endswith(".ttl"):
             #     return []
             # Only process the specific mustrd config file we were given
             # if str(self.fspath) != str(self.mustrd_plugin.test_config_file):
             #     logger.info(f"Skipping non-config file: {self.fspath}")
             #     return []
-                
+
             test_configs = parse_config(self.path)
             from collections import defaultdict
             pytest_path_grouped = defaultdict(list)
@@ -435,7 +392,7 @@ class MustrdFile(pytest.File):
                 ):
                     logger.info(f"Skipping test config due to path filter: {test_config.pytest_path=} {self.mustrd_plugin.path_filter=}")
                     continue
-                
+
                 triple_stores = self.mustrd_plugin.get_triple_stores_from_file(test_config)
                 try:
                     specs = self.mustrd_plugin.generate_tests_for_config(
@@ -521,7 +478,7 @@ class MustrdItem(pytest.Item):
             f"Error: \n{excinfo.value}\n"
             f"Traceback:\n{tb_str}"
         )
-    
+
     def reportinfo(self):
         r = "", 0, f"mustrd test: {self.name}"
         return r
@@ -531,9 +488,6 @@ class MustrdItem(pytest.Item):
 def run_test_spec(test_spec):
     logger = logging.getLogger("mustrd.test")
     logger.info(f"Running test spec: {getattr(test_spec, 'spec_uri', test_spec)}")
-    if isinstance(test_spec, SpecSkipped):
-        logger.warning(f"Test skipped: {test_spec.message}")
-        pytest.skip(f"Invalid configuration, error : {test_spec.message}")
     try:
         result = run_spec(test_spec)
         logger.info(f"Result type: {type(result)} for spec: {getattr(test_spec, 'spec_uri', test_spec)}")
@@ -544,13 +498,11 @@ def run_test_spec(test_spec):
 
     if isinstance(test_spec, SpecInvalid):
         logger.error(f"Invalid test specification: {test_spec.message} {test_spec}")
-        raise ValueError(f"Invalid test specification: {test_spec.message} {test_spec}")
-    if type(result) == SpecSkipped:
-        logger.warning("Test skipped due to unsupported configuration")
-        pytest.skip("Unsupported configuration")
-    if type(result) != SpecPassed:
+        pytest.fail(f"Invalid test specification: {test_spec.message} {test_spec}")
+    if not isinstance(result, SpecPassed):
         write_result_diff_to_log(result, logger.info)
         log_lines = []
+
         def log_to_string(message):
             log_lines.append(message)
         try:
@@ -562,4 +514,4 @@ def run_test_spec(test_spec):
         raise AssertionError("Test failed: " + "\n".join(log_lines))
 
     logger.info(f"Test PASSED: {getattr(test_spec, 'spec_uri', test_spec)}")
-    return type(result) == SpecPassed
+    return isinstance(result, SpecPassed)

{mustrd-0.3.3a1 → mustrd-0.3.4a1}/mustrd/spec_component.py

@@ -179,8 +179,6 @@ def get_file_absolute_path(spec_component_details: SpecComponentDetails, relativ
 
 
 def get_spec_component_type(spec_components: List[SpecComponent]) -> Type[SpecComponent]:
-    if not spec_components:
-        raise ValueError("spec_components list is empty")
     # Get the type of the first object in the list
     spec_type = type(spec_components[0])
     # Loop through the remaining objects in the list and check their types
@@ -677,7 +675,7 @@ def get_spec_component_from_file(path: Path) -> str:
         raise ValueError(f"Path {path} is a directory, expected a file")
 
     try:
-        content = path.read_text()
+        content = path.read_text(encoding='utf-8')
     except FileNotFoundError:
         raise
     return str(content)

{mustrd-0.3.3a1 → mustrd-0.3.4a1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mustrd"
-version = "0.3.3a1"
+version = "0.3.4a1"
 description = "A Spec By Example framework for RDF and SPARQL, Inspired by Cucumber."
 authors = [
     { name = "John Placek", email = "john.placek@semanticpartners.com" },

mustrd-0.3.3a1/README.md

@@ -1,54 +0,0 @@
-# mustrd
-
-**"MustRD: Validate your SPARQL queries and transformations with precision and confidence, using BDD and Given-When-Then principles."**
-
-[<img src="https://github.com/Semantic-partners/mustrd/raw/python-coverage-comment-action-data/badge.svg?sanitize=true" alt="coverage badge">](https://github.com/Semantic-partners/mustrd/tree/python-coverage-comment-action-data)
-
-### Why?
-
-SPARQL is a powerful query language for RDF data, but how can you ensure your queries and transformations are doing what you intend? Whether you're working on a pipeline or a standalone query, certainty is key.
-
-While RDF and SPARQL offer great flexibility, we noticed a gap in tooling to validate their behavior. We missed the robust testing frameworks available in imperative programming languages that help ensure your code works as expected.
-
-With MustRD, you can:
-
-* Define data scenarios and verify that queries produce the expected results.
-* Test edge cases to ensure your queries remain reliable.
-* Isolate small SPARQL enrichment or transformation steps and confirm you're only inserting what you intend.
-
-### What?
-
-MustRD is a Spec-By-Example ontology with a reference Python implementation, inspired by tools like Cucumber. It uses the Given-When-Then approach to define and validate SPARQL queries and transformations.
-
-MustRD is designed to be triplestore/SPARQL engine agnostic, leveraging open standards to ensure compatibility across different platforms.
-
-### What it is NOT
-
-MustRD is not an alternative to SHACL. While SHACL validates data structures, MustRD focuses on validating data transformations and query results.
-
-### How?
-
-You define your specs in Turtle (`.ttl`) or TriG (`.trig`) files using the Given-When-Then approach:
-
-* **Given**: Define the starting dataset.
-* **When**: Specify the action (e.g., a SPARQL query).
-* **Then**: Outline the expected results.
-
-Depending on the type of SPARQL query (CONSTRUCT, SELECT, INSERT/DELETE), MustRD runs the query and compares the results against the expectations defined in the spec.
-
-Expectations can also be defined as:
-
-* INSERT queries.
-* SELECT queries.
-* Higher-order expectation languages, similar to those used in various platforms.
-
-### When?
-
-MustRD is a work in progress, built to meet the needs of our projects across multiple clients and vendor stacks. While we find it useful, it may not meet your needs out of the box.
-
-We invite you to try it, raise issues, or contribute via pull requests. If you need custom features, contact us for consultancy rates, and we may prioritize your request.
-
-## Support
-
-Semantic Partners is a specialist consultancy in Semantic Technology. If you need more support, contact us at info@semanticpartners.com or mustrd@semanticpartners.com.
-