mustrd 0.1.5__tar.gz → 0.1.7__tar.gz

{mustrd-0.1.5 → mustrd-0.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mustrd
-Version: 0.1.5
+Version: 0.1.7
 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.5 → mustrd-0.1.7}/mustrd/mustrd.py

@@ -381,11 +381,13 @@ def run_spec(spec: Specification) -> SpecResult:
     #     if type(mustrd_triple_store) == MustrdAnzo and close_connection:
     #         mustrd_triple_store.clear_graph()
 
-
-
-def get_triple_store_graph(triple_store_graph_path: Path):
-    secret_path = triple_store_graph_path.parent / Path(triple_store_graph_path.stem + "_secrets" + triple_store_graph_path.suffix)
-    return Graph().parse(triple_store_graph_path).parse(secret_path)
+def get_triple_store_graph(triple_store_graph_path: Path, secrets: str):
+    if secrets:
+        return Graph().parse(triple_store_graph_path).parse(data = secrets)
+    else:
+        secret_path = triple_store_graph_path.parent / Path(triple_store_graph_path.stem + "_secrets" + triple_store_graph_path.suffix)
+        return Graph().parse(triple_store_graph_path).parse(source = secret_path)
+    
 
 def get_triple_stores(triple_store_graph: Graph) -> list[dict]:
     triple_stores = []

{mustrd-0.1.5 → mustrd-0.1.7}/mustrd/mustrdTestPlugin.py

@@ -27,20 +27,79 @@ 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.mustrd import get_triple_store_graph, get_triple_stores
+from mustrd.mustrd import SpecSkipped, validate_specs, get_specs, SpecPassed, run_spec
 from mustrd.namespace import MUST
+from collections import defaultdict
 
 spnamespace = Namespace("https://semanticpartners.com/data/test/")
 
 mustrd_root = get_mustrd_root()
 
 
+def pytest_addoption(parser):
+    group = parser.getgroup("md summary")
+    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,
+        required=True,
+        help="Ttl file containing the list of test to construct.",
+    )
+    group.addoption(
+        "--secrets",
+        action="store",
+        dest="secrets",
+        metavar="Secrets",
+        default=None,
+        required=False,
+        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
+    test_configs: Dict[str, TestConfig] = defaultdict(lambda: defaultdict(list))
+    config_graph = Graph().parse(config.getoption("configpath"))
+    for test_config_subject in config_graph.subjects(predicate=RDF.type, object=MUST.TestConfig):
+        test_function = get_config_param(config_graph, test_config_subject, MUST.hasTestFunction, str)
+        spec_path = get_config_param(config_graph, test_config_subject, MUST.hasSpecPath, str)
+        data_path = get_config_param(config_graph, test_config_subject, MUST.hasDataPath, str)
+        triplestore_spec_path = get_config_param(config_graph, test_config_subject, MUST.triplestoreSpecPath, str)
+        filter_on_tripleStore = list(config_graph.objects(subject=test_config_subject,
+                                                          predicate=MUST.filterOnTripleStore))
+
+        test_configs[test_function] = TestConfig(test_function=test_function,
+                                                 spec_path=spec_path, data_path=data_path,
+                                                 triplestore_spec_path=triplestore_spec_path,
+                                                 filter_on_tripleStore=filter_on_tripleStore)
+
+    config.pluginmanager.register(MustrdTestPlugin(config.getoption("mdpath"),
+                                                   test_configs, config.getoption("secrets")))
+
+
+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
@@ -61,10 +120,12 @@ class TestConfig:
 class MustrdTestPlugin:
     md_path: str
     test_configs: Dict[str, TestConfig]
+    secrets: str
 
-    def __init__(self, md_path, test_configs):
+    def __init__(self, md_path, test_configs, secrets):
         self.md_path = md_path
         self.test_configs = test_configs
+        self.secrets = secrets
 
     # Hook called at collection time: reads the configuration of the tests, and generate pytests from it
     def pytest_generate_tests(self, metafunc):
@@ -122,10 +183,11 @@ 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)))
-            except Exception:
+                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""")
+                    Fall back: only embedded rdflib will be executed""", e)
                 triple_stores = [{'type': MUST.RdfLib}]
         else:
             print("No triple store configuration required: using embedded rdflib")

{mustrd-0.1.5 → mustrd-0.1.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "mustrd"
-version = "0.1.5"
+version = "0.1.7"
 description = "A Spec By Example framework for RDF and SPARQL, Inspired by Cucumber."
 authors = ["John Placek <john.placek@semanticpartners.com>",
     "Juliane Piñeiro-Winkler <juliane.pineiro-winkler@semanticpartners.com>",
@@ -51,4 +51,4 @@ requires = ["poetry-core>=1.0.0"]
 build-backend = "poetry.core.masonry.api"
 
 [tool.poetry.plugins.pytest11]
-mustrd_plugin = "mustrd.plugin"
+mustrd_plugin = "mustrd.mustrdTestPlugin"

mustrd-0.1.5/mustrd/plugin.py

@@ -1,78 +0,0 @@
-"""
-MIT License
-
-Copyright (c) 2023 Semantic Partners Ltd
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-"""
-
-from typing import Dict
-from .mustrdTestPlugin import MustrdTestPlugin, TestConfig
-from rdflib import RDF, Graph
-from .namespace import MUST
-from collections import defaultdict
-
-
-
-def pytest_addoption(parser):
-    group = parser.getgroup("md summary")
-    group.addoption(
-        "--md",
-        action="store",
-        dest="mdpath",
-        metavar="path",
-        default=None,
-        help="create md summary file at that path.",
-    )
-    group.addoption(
-        "--config",
-        action="store",
-        dest="configpath",
-        metavar="path",
-        default=None,
-        required=True,
-        help="Ttl file containing the list of test to construct.",
-    )
-    return
-
-
-def pytest_configure(config) -> None:
-
-    # Read configuration file
-    test_configs: Dict[str, TestConfig] = defaultdict(lambda: defaultdict(list))
-    config_graph = Graph().parse(config.getoption("configpath"))
-    for test_config_subject in config_graph.subjects(predicate=RDF.type, object=MUST.TestConfig):
-        test_function = get_config_param(config_graph, test_config_subject, MUST.hasTestFunction, str)
-        spec_path = get_config_param(config_graph, test_config_subject, MUST.hasSpecPath, str)
-        data_path = get_config_param(config_graph, test_config_subject, MUST.hasDataPath, str)
-        triplestore_spec_path = get_config_param(config_graph, test_config_subject, MUST.triplestoreSpecPath, str)
-        filter_on_tripleStore = list(config_graph.objects(subject=test_config_subject,
-                                                          predicate=MUST.filterOnTripleStore))
-
-        test_configs[test_function] = TestConfig(test_function=test_function,
-                                                 spec_path=spec_path, data_path=data_path,
-                                                 triplestore_spec_path=triplestore_spec_path,
-                                                 filter_on_tripleStore=filter_on_tripleStore)
-
-    config.pluginmanager.register(MustrdTestPlugin(config.getoption("mdpath"), 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