mustrd 0.2.6.1__py3-none-any.whl → 0.2.7a0__py3-none-any.whl

mustrd/mustrdAnzo.py

@@ -22,51 +22,24 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 """
 
-import requests
-from pyanzo import AnzoClient
 from rdflib import Graph, ConjunctiveGraph, Literal, URIRef
-from requests import ConnectTimeout, Response, HTTPError, RequestException, ConnectionError
-from bs4 import BeautifulSoup
+from requests import ConnectTimeout, HTTPError, ConnectionError
 import logging
-from .namespace import MUST
-
-
-# https://github.com/Semantic-partners/mustrd/issues/73
-def manage_anzo_response(response: Response) -> str:
-    content_string = response.content.decode("utf-8")
-    if response.status_code == 200:
-        return content_string
-    elif response.status_code == 403:
-        html = BeautifulSoup(content_string, 'html.parser')
-        title_tag = html.title.string
-        raise HTTPError(f"Anzo authentication error, status code: {response.status_code}, content: {title_tag}")
-    else:
-        raise RequestException(f"Anzo error, status code: {response.status_code}, content: {content_string}")
-
-
-def query_with_bindings(bindings: dict, when: str) -> str:
-    values = ""
-    for key, value in bindings.items():
-        values += f"VALUES ?{key} {{{value.n3()}}} "
-    split_query = when.lower().split("where {", 1)
-    return f"{split_query[0].strip()} WHERE {{ {values} {split_query[1].strip()}"
+from mustrd.anzo_utils import query_azg, query_graphmart
+from mustrd.anzo_utils import query_configuration, json_to_dictlist, ttl_to_graph
 
 
 def execute_select(triple_store: dict,  when: str, bindings: dict = None) -> str:
     try:
         if bindings:
             when = query_with_bindings(bindings, when)
-        when = when.replace("${fromSources}", f"FROM <{triple_store['input_graph']}>\nFROM <{triple_store['output_graph']}>").replace(
-        "${targetGraph}", f"<{triple_store['output_graph']}>")
-        data = {'datasourceURI': triple_store['gqe_uri'], 'query': when,
-                'default-graph-uri': triple_store['input_graph'],
-                'named-graph-uri': triple_store['input_graph'],
-                 'skipCache': 'true'}
-        url = f"https://{triple_store['url']}:{triple_store['port']}/sparql?format=application/sparql-results+json"
-        return manage_anzo_response(requests.post(url=url,
-                                                  auth=(triple_store['username'], triple_store['password']),
-                                                  data=data,
-                                                  verify=False))
+        # FIXME: why do we have those tokens in a select query? in particular ${targetGraph}?
+        # FIXME: why do we also query the output graph?
+        when = when.replace("${fromSources}",
+                            f"FROM <{triple_store['input_graph']}>\nFROM <{triple_store['output_graph']}>").replace(
+                                "${targetGraph}", f"<{triple_store['output_graph']}>")
+        # TODO: manage results here
+        return query_azg(anzo_config=triple_store, query=when)
     except (ConnectionError, TimeoutError, HTTPError, ConnectTimeout):
         raise
 
@@ -76,32 +49,20 @@ def execute_update(triple_store: dict, when: str, bindings: dict = None) -> Grap
     input_graph = triple_store['input_graph']
     output_graph = triple_store['output_graph']
 
-    substituted_query = when.replace("${usingSources}", f"USING <{triple_store['input_graph']}> \nUSING <{triple_store['output_graph']}>").replace(
-        "${targetGraph}", f"<{output_graph}>")
-   
-    data = {'datasourceURI': triple_store['gqe_uri'],
-            'update': substituted_query,
-            'using-graph-uri': [output_graph, input_graph],
-            'using-named-graph-uri': [output_graph, input_graph],
-            'skipCache': 'true'}
-    url = f"https://{triple_store['url']}:{triple_store['port']}/sparql?format=ttl"
-    response = manage_anzo_response(requests.post(url=url,
-            auth=(triple_store['username'],
-                triple_store['password']),
-            data=data,
-            verify=False))
+    # FIXME: that will only work with steps.
+    # We could replace USING clauses with using-graph-uri parameter
+    # But there is no parameter for default insert graphs.
+    substituted_query = when.replace("${usingSources}",
+                                     f"""USING <{input_graph}>
+USING <{triple_store['output_graph']}>""").replace(
+                                         "${targetGraph}", f"<{output_graph}>")
+
+    response = query_azg(anzo_config=triple_store, query=substituted_query, is_update=True,
+                         data_layers=input_graph, format="ttl")
     logging.debug(f'response {response}')
-    check_data = {'datasourceURI': triple_store['gqe_uri'], 'query': "construct {?s ?p ?o} { ?s ?p ?o }",
-                'default-graph-uri': output_graph,
-                'named-graph-uri': output_graph,
-                  'skipCache': 'true'}
-    everything_response = manage_anzo_response(requests.post(url=url,
-            auth=(triple_store['username'],
-                triple_store['password']),
-            data=check_data,
-            verify=False))
-    # todo deal with error responses
-    new_graph = Graph().parse(data=everything_response)
+    # TODO: deal with error responses
+    new_graph = ttl_to_graph(query_azg(anzo_config=triple_store, query="construct {?s ?p ?o} { ?s ?p ?o }",
+                                       format="ttl", data_layers=output_graph))
     logging.debug(f"new_graph={new_graph.serialize(format='ttl')}")
     return new_graph
 
@@ -110,35 +71,27 @@ def execute_construct(triple_store: dict, when: str, bindings: dict = None) -> G
     try:
         if bindings:
             when = query_with_bindings(bindings, when)
-        data = {'datasourceURI': triple_store['gqe_uri'], 'query': when,
-                'default-graph-uri': triple_store['input_graph'],
-                'named-graph-uri': triple_store['input_graph'],
-                'skipCache': 'true'}
-        url = f"https://{triple_store['url']}:{triple_store['port']}/sparql?format=ttl"
-        response = requests.post(url=url,
-            auth=(triple_store['username'],
-                triple_store['password']),
-            data=data,
-            verify=False)
-        logging.debug(f'response {response}')
-        g = Graph().parse(data=manage_anzo_response(response))
-        logging.debug(f"Actual Result = {g.serialize(format='ttl')}")
-        return g
+        return ttl_to_graph(query_azg(anzo_config=triple_store, query=when, format="ttl",
+                                      data_layers=triple_store['input_graph']))
     except (ConnectionError, TimeoutError, HTTPError, ConnectTimeout) as e:
         logging.error(f'response {e}')
         raise
 
 
+def query_with_bindings(bindings: dict, when: str) -> str:
+    values = ""
+    for key, value in bindings.items():
+        values += f"VALUES ?{key} {{{value.n3()}}} "
+    split_query = when.lower().split("where {", 1)
+    return f"{split_query[0].strip()} WHERE {{ {values} {split_query[1].strip()}"
+
+
 # Get Given or then from the content of a graphmart
 def get_spec_component_from_graphmart(triple_store: dict, graphmart: URIRef, layer: URIRef = None) -> ConjunctiveGraph:
     try:
-        anzo_client = AnzoClient(triple_store['url'], triple_store['port'],
-                                 username=triple_store['username'],
-                                 password=triple_store['password'])
-        return anzo_client.query_graphmart(graphmart=graphmart,
-                                           data_layers=layer,
-                                           query_string="CONSTRUCT {?s ?p ?o} WHERE {?s ?p ?o}",
-                                           skip_cache=True).as_quad_store().as_rdflib_graph()
+        return ttl_to_graph(query_graphmart(anzo_config=triple_store, graphmart=graphmart,
+                                            query="CONSTRUCT {?s ?p ?o} WHERE {?s ?p ?o}",
+                                            data_layers=layer, format="ttl"))
     except RuntimeError as e:
         raise ConnectionError(f"Anzo connection error, {e}")
 
@@ -153,46 +106,33 @@ def get_query_from_querybuilder(triple_store: dict, folder_name: Literal, query_
             ?queryFolder a <http://www.cambridgesemantics.com/ontologies/QueryPlayground#QueryFolder>;
                         <http://purl.org/dc/elements/1.1/title> "{folder_name}"
     }}"""
-    anzo_client = AnzoClient(triple_store['url'], triple_store['port'],
-                             username=triple_store['username'],
-                             password=triple_store['password'])
-
-    result = anzo_client.query_journal(query_string=query).as_table_results().as_record_dictionaries()
+    result = json_to_dictlist(query_configuration(
+        anzo_config=triple_store, query=query))
     if len(result) == 0:
-        raise FileNotFoundError(f"Query {query_name} not found in folder {folder_name}")
+        raise FileNotFoundError(
+            f"Query {query_name} not found in folder {folder_name}")
     return result[0].get("query")
 
 
 # https://github.com/Semantic-partners/mustrd/issues/102
 def get_query_from_step(triple_store: dict, query_step_uri: URIRef) -> str:
-    query = f"""SELECT ?stepUri ?query WHERE {{
+    query = f"""SELECT ?query WHERE {{
         BIND(<{query_step_uri}> as ?stepUri)
             ?stepUri a <http://cambridgesemantics.com/ontologies/Graphmarts#Step>;
                      <http://cambridgesemantics.com/ontologies/Graphmarts#transformQuery> ?query
-    }}
-    # """
-    anzo_client = AnzoClient(triple_store['url'], triple_store['port'],
-                             username=triple_store['username'],
-                             password=triple_store['password'])
-    record_dictionaries = anzo_client.query_journal(query_string=query).as_table_results().as_record_dictionaries()
+    }}"""
+    return json_to_dictlist(query_configuration(anzo_config=triple_store, query=query))[0]['query']
 
-    return record_dictionaries[0].get(
-        "query")
 
 def get_queries_from_templated_step(triple_store: dict, query_step_uri: URIRef) -> dict:
-
-    query = f"""SELECT ?stepUri ?param_query ?query_template WHERE {{
+    query = f"""SELECT ?param_query ?query_template WHERE {{
         BIND(<{query_step_uri}> as ?stepUri)
             ?stepUri    a <http://cambridgesemantics.com/ontologies/Graphmarts#Step> ;
-   					    <http://cambridgesemantics.com/ontologies/Graphmarts#parametersTemplate> ?param_query ;
-					    <http://cambridgesemantics.com/ontologies/Graphmarts#template> ?query_template .
+                        <http://cambridgesemantics.com/ontologies/Graphmarts#parametersTemplate> ?param_query ;
+                        <http://cambridgesemantics.com/ontologies/Graphmarts#template> ?query_template .
     }}
     """
-    anzo_client = AnzoClient(triple_store['url'], triple_store['port'],
-                             username=triple_store['username'],
-                             password=triple_store['password'])
-    record_dictionaries = anzo_client.query_journal(query_string=query).as_table_results().as_record_dictionaries()
-    return record_dictionaries[0]
+    return json_to_dictlist(query_configuration(anzo_config=triple_store, query=query))[0]
 
 
 def get_queries_for_layer(triple_store: dict, graphmart_layer_uri: URIRef):
@@ -204,37 +144,26 @@ SELECT ?query ?param_query ?query_template
                 anzo:orderedValue ?query_step .
   ?query_step graphmarts:enabled true ;
   OPTIONAL {{  ?query_step
-   				graphmarts:parametersTemplate ?param_query ;
-           		graphmarts:template ?query_template ;
+                graphmarts:parametersTemplate ?param_query ;
+                graphmarts:template ?query_template ;
       . }}
   OPTIONAL {{  ?query_step
-   				graphmarts:transformQuery ?query ;
+                graphmarts:transformQuery ?query ;
       . }}
   }}
   ORDER BY ?index"""
-    anzo_client = AnzoClient(triple_store['url'], triple_store['port'],
-                             username=triple_store['username'],
-                             password=triple_store['password'])
-    return anzo_client.query_journal(query_string=query).as_table_results().as_record_dictionaries()
+    return json_to_dictlist(query_configuration(anzo_config=triple_store, query=query))
 
 
 def upload_given(triple_store: dict, given: Graph):
     logging.debug(f"upload_given {triple_store} {given}")
 
     try:
-        input_graph = triple_store['input_graph']
-        output_graph = triple_store['output_graph']
-        clear_graph(triple_store, input_graph)
-        clear_graph(triple_store, output_graph)
+        clear_graph(triple_store, triple_store['input_graph'])
+        clear_graph(triple_store, triple_store['output_graph'])
         serialized_given = given.serialize(format="nt")
         insert_query = f"INSERT DATA {{graph <{triple_store['input_graph']}>{{{serialized_given}}}}}"
-        data = {'datasourceURI': triple_store['gqe_uri'],
-                'update': insert_query,
-                'using-graph-uri': input_graph,
-                'using-named-graph-uri': input_graph}
-        response = requests.post(url=f"https://{triple_store['url']}:{triple_store['port']}/sparql",
-                                    auth=(triple_store['username'], triple_store['password']), data=data, verify=False)
-        manage_anzo_response(response)
+        query_azg(anzo_config=triple_store, query=insert_query, is_update=True)
     except (ConnectionError, TimeoutError, HTTPError, ConnectTimeout):
         raise
 
@@ -242,10 +171,6 @@ def upload_given(triple_store: dict, given: Graph):
 def clear_graph(triple_store: dict, graph_uri: str):
     try:
         clear_query = f"CLEAR GRAPH <{graph_uri}>"
-        data = {'datasourceURI': triple_store['gqe_uri'], 'update': clear_query}
-        url = f"https://{triple_store['url']}:{triple_store['port']}/sparql"
-        response = requests.post(url=url,
-                                 auth=(triple_store['username'], triple_store['password']), data=data, verify=False)
-        manage_anzo_response(response)
+        query_azg(anzo_config=triple_store, query=clear_query, is_update=True)
     except (ConnectionError, TimeoutError, HTTPError, ConnectTimeout):
         raise

mustrd/mustrdGraphDb.py

@@ -49,7 +49,7 @@ def upload_given(triple_store: dict, given: Graph):
             graph = "default"
             if triple_store['input_graph']:
                 graph = urllib.parse.urlencode({'graph': triple_store['input_graph']})
-            url = f"{triple_store['url']}:{triple_store['port']}/repositories/{triple_store['repository']}" \
+            url = f"{triple_store['url']}/repositories/{triple_store['repository']}" \
                   f"/rdf-graphs/service?{graph}"
             # graph store PUT drop silently the graph or default and upload the payload
             # https://www.w3.org/TR/sparql11-http-rdf-update/#http-put
@@ -82,7 +82,7 @@ def post_update_query(triple_store: dict, query: str, params: dict = None) -> st
     params = add_graph_to_params(params, triple_store["input_graph"])
     try:
         return manage_graphdb_response(requests.post(
-            url=f"{triple_store['url']}:{triple_store['port']}/repositories/{triple_store['repository']}/statements",
+            url=f"{triple_store['url']}/repositories/{triple_store['repository']}/statements",
             data=query,
             params=params,
             auth=(triple_store['username'], triple_store['password']),
@@ -99,7 +99,7 @@ def post_query(triple_store: dict, query: str, accept: str, params: dict = None)
     params = add_graph_to_params(params, triple_store["input_graph"])
     try:
         return manage_graphdb_response(
-            requests.post(url=f"{triple_store['url']}:{triple_store['port']}/repositories/{triple_store['repository']}",
+            requests.post(url=f"{triple_store['url']}/repositories/{triple_store['repository']}",
                           data=query,
                           params=params,
                           auth=(triple_store['username'], triple_store['password']),

mustrd/mustrdTestPlugin.py

@@ -22,6 +22,7 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 """
 
+import logging
 from dataclasses import dataclass
 import pytest
 import os
@@ -30,14 +31,15 @@ from rdflib.namespace import Namespace
 from rdflib import Graph, RDF
 from pytest import Session
 
+from mustrd import logger_setup
 from mustrd.TestResult import ResultList, TestResult, get_result_list
 from mustrd.utils import get_mustrd_root
-from mustrd.mustrd import get_triple_store_graph, get_triple_stores
+from mustrd.mustrd import write_result_diff_to_log, get_triple_store_graph, get_triple_stores
 from mustrd.mustrd import Specification, SpecSkipped, validate_specs, get_specs, SpecPassed, run_spec
 from mustrd.namespace import MUST, TRIPLESTORE, MUSTRDTEST
 from typing import Union
 from pyshacl import validate
-
+import logging
 spnamespace = Namespace("https://semanticpartners.com/data/test/")
 
 mustrd_root = get_mustrd_root()
@@ -82,41 +84,48 @@ def pytest_addoption(parser):
 
 def pytest_configure(config) -> None:
     # Read configuration file
-    if config.getoption("mustrd"):
-        test_configs = parse_config(config.getoption("configpath"))
+    if config.getoption("mustrd") and config.getoption("configpath"):
         config.pluginmanager.register(MustrdTestPlugin(config.getoption("mdpath"),
-                                                       test_configs, config.getoption("secrets")))
+                                                       Path(config.getoption("configpath")), config.getoption("secrets")))
 
 
 def parse_config(config_path):
     test_configs = []
+    print(f"{config_path=}")
     config_graph = Graph().parse(config_path)
-    shacl_graph = Graph().parse(Path(os.path.join(mustrd_root, "model/mustrdTestShapes.ttl")))
-    ont_graph = Graph().parse(Path(os.path.join(mustrd_root, "model/mustrdTestOntology.ttl")))
+    shacl_graph = Graph().parse(
+        Path(os.path.join(mustrd_root, "model/mustrdTestShapes.ttl")))
+    ont_graph = Graph().parse(
+        Path(os.path.join(mustrd_root, "model/mustrdTestOntology.ttl")))
     conforms, results_graph, results_text = validate(
-            data_graph=config_graph,
-            shacl_graph=shacl_graph,
-            ont_graph=ont_graph,
-            advanced=True,
-            inference='none'
-        )
+        data_graph=config_graph,
+        shacl_graph=shacl_graph,
+        ont_graph=ont_graph,
+        advanced=True,
+        inference='none'
+    )
     if not conforms:
         raise ValueError(f"Mustrd test configuration not conform to the shapes. SHACL report: {results_text}",
                          results_graph)
 
     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))
+        spec_path = get_config_param(
+            config_graph, test_config_subject, MUSTRDTEST.hasSpecPath, str)
+        data_path = get_config_param(
+            config_graph, test_config_subject, MUSTRDTEST.hasDataPath, str)
+        triplestore_spec_path = get_config_param(
+            config_graph, test_config_subject, MUSTRDTEST.triplestoreSpecPath, str)
+        pytest_path = get_config_param(
+            config_graph, test_config_subject, MUSTRDTEST.hasPytestPath, str)
+        filter_on_tripleStore = tuple(config_graph.objects(subject=test_config_subject,
+                                                           predicate=MUSTRDTEST.filterOnTripleStore))
 
         # Root path is the mustrd test config path
         root_path = Path(config_path).parent
         spec_path = root_path / Path(spec_path) if spec_path else None
         data_path = root_path / Path(data_path) if data_path else None
-        triplestore_spec_path = root_path / Path(triplestore_spec_path) if triplestore_spec_path else None
+        triplestore_spec_path = root_path / \
+            Path(triplestore_spec_path) if triplestore_spec_path else None
 
         test_configs.append(TestConfig(spec_path=spec_path, data_path=data_path,
                                        triplestore_spec_path=triplestore_spec_path,
@@ -126,11 +135,12 @@ def parse_config(config_path):
 
 
 def get_config_param(config_graph, config_subject, config_param, convert_function):
-    raw_value = config_graph.value(subject=config_subject, predicate=config_param, any=True)
+    raw_value = config_graph.value(
+        subject=config_subject, predicate=config_param, any=True)
     return convert_function(raw_value) if raw_value else None
 
 
-@dataclass
+@dataclass(frozen=True)
 class TestConfig:
     spec_path: Path
     data_path: Path
@@ -139,94 +149,61 @@ class TestConfig:
     filter_on_tripleStore: str = None
 
 
-@dataclass
+@dataclass(frozen=True)
 class TestParamWrapper:
+    id: str
     test_config: TestConfig
     unit_test: Union[Specification, SpecSkipped]
 
 
+# Configure logging
+logger = logger_setup.setup_logger(__name__)
+
+
 class MustrdTestPlugin:
     md_path: str
-    test_configs: list
+    test_config_file: Path
+    selected_tests: list
     secrets: str
     unit_tests: Union[Specification, SpecSkipped]
     items: list
+    path_filter: str
+    collect_error: BaseException
 
-    def __init__(self, md_path, test_configs, secrets):
+    def __init__(self, md_path, test_config_file, secrets):
         self.md_path = md_path
-        self.test_configs = test_configs
+        self.test_config_file = test_config_file
         self.secrets = secrets
         self.items = []
 
     @pytest.hookimpl(tryfirst=True)
     def pytest_collection(self, session):
+        logger.info("Starting test collection")
         self.unit_tests = []
         args = session.config.args
-        if len(args) > 0:
-            file_name = self.get_file_name_from_arg(args[0])
-            # Filter test to collect only specified path
-            config_to_collect = list(filter(lambda config:
-                                            # Case we want to collect everything
-                                            MUSTRD_PYTEST_PATH not in args[0]
-                                            # Case we want to collect a test or sub test
-                                            or (config.pytest_path or "") in args[0]
-                                            # Case we want to collect a whole test folder
-                                            or args[0].replace(f"./{MUSTRD_PYTEST_PATH}", "") in config.pytest_path,
-                                            self.test_configs))
-
-            # Redirect everything to test_mustrd.py,
-            # no need to filter on specified test: Only specified test will be collected anyway
-            session.config.args[0] = os.path.join(mustrd_root, "test/test_mustrd.py")
-        # Collecting only relevant tests
-
-        for one_test_config in config_to_collect:
-            triple_stores = self.get_triple_stores_from_file(one_test_config)
-
-            if one_test_config.filter_on_tripleStore and not triple_stores:
-                self.unit_tests.extend(list(map(
-                    lambda triple_store:
-                        TestParamWrapper(test_config=one_test_config,
-                                         unit_test=SpecSkipped(MUST.TestSpec, triple_store, "No triplestore found")),
-                        one_test_config.filter_on_tripleStore)))
-            else:
-                specs = self.generate_tests_for_config({"spec_path": one_test_config.spec_path,
-                                                        "data_path": one_test_config.data_path},
-                                                       triple_stores, file_name)
-                self.unit_tests.extend(list(map(
-                    lambda spec: TestParamWrapper(test_config=one_test_config, unit_test=spec), specs)))
+        logger.info("Used arguments: " + str(args))
+        self.selected_tests = list(map(lambda arg: Path(arg.split("::")[0]).resolve(),
+                                       # By default the current directory is given as argument
+                                       # Remove it as it is not a test
+                                       filter(lambda arg: arg != os.getcwd() and "::" in arg, args)))
+
+        self.path_filter = args[0] if len(
+            args) == 1 and args[0] != os.getcwd() and not "::" in args[0] else None
+
+        session.config.args = [str(self.test_config_file.resolve())]
 
     def get_file_name_from_arg(self, arg):
-        if arg and len(arg) > 0 and "[" in arg and ".mustrd.ttl@" in arg:
-            return arg[arg.index("[") + 1: arg.index(".mustrd.ttl@")]
+        if arg and len(arg) > 0 and "[" in arg and ".mustrd.ttl " in arg:
+            return arg[arg.index("[") + 1: arg.index(".mustrd.ttl ")]
         return None
 
-    @pytest.hookimpl(hookwrapper=True)
-    def pytest_pycollect_makeitem(self, collector, name, obj):
-        report = yield
-        if name == "test_unit":
-            items = report.get_result()
-            new_results = []
-            for item in items:
-                virtual_path = MUSTRD_PYTEST_PATH + (item.callspec.params["unit_tests"].test_config.pytest_path or "default")
-                item.fspath = Path(virtual_path)
-                item._nodeid = virtual_path + "::" + item.name
-                self.items.append(item)
-                new_results.append(item)
-            return new_results
-
-    # Hook called at collection time: reads the configuration of the tests, and generate pytests from it
-    def pytest_generate_tests(self, metafunc):
-        if len(metafunc.fixturenames) > 0:
-            if metafunc.function.__name__ == "test_unit":
-                # Create the test in itself
-                if self.unit_tests:
-                    metafunc.parametrize(metafunc.fixturenames[0], self.unit_tests,
-                                         ids=lambda test_param: (test_param.unit_test.spec_file_name or "") + "@" +
-                                         (test_param.test_config.pytest_path or ""))
-            else:
-                metafunc.parametrize(metafunc.fixturenames[0],
-                                     [SpecSkipped(MUST.TestSpec, None, "No triplestore found")],
-                                     ids=lambda x: "No configuration found for this test")
+    @pytest.hookimpl
+    def pytest_collect_file(self, parent, path):
+        logger.debug(f"Collecting file: {path}")
+        mustrd_file = MustrdFile.from_parent(
+            parent, fspath=path, mustrd_plugin=self)
+        mustrd_file.mustrd_plugin = self
+        return mustrd_file
 
     # Generate test for each triple store available
     def generate_tests_for_config(self, config, triple_stores, file_name):
@@ -249,9 +226,10 @@ class MustrdTestPlugin:
             triple_store = spec.triple_store
         else:
             triple_store = spec.triple_store['type']
-        triple_store_name = triple_store.replace("https://mustrd.com/model/", "")
+        triple_store_name = triple_store.replace(
+            "https://mustrd.com/model/", "")
         test_name = spec.spec_uri.replace(spnamespace, "").replace("_", " ")
-        return triple_store_name + ": " + test_name
+        return spec.spec_file_name + " : " + triple_store_name + ": " + test_name
 
     # Get triple store configuration or default
     def get_triple_stores_from_file(self, test_config):
@@ -262,10 +240,12 @@ class MustrdTestPlugin:
             except Exception as e:
                 print(f"""Triplestore configuration parsing failed {test_config.triplestore_spec_path}.
                     Only rdflib will be executed""", e)
-                triple_stores = [{'type': TRIPLESTORE.RdfLib, 'uri': TRIPLESTORE.RdfLib}]
+                triple_stores = [
+                    {'type': TRIPLESTORE.RdfLib, 'uri': TRIPLESTORE.RdfLib}]
         else:
             print("No triple store configuration required: using embedded rdflib")
-            triple_stores = [{'type': TRIPLESTORE.RdfLib, 'uri': TRIPLESTORE.RdfLib}]
+            triple_stores = [
+                {'type': TRIPLESTORE.RdfLib, 'uri': TRIPLESTORE.RdfLib}]
 
         if test_config.filter_on_tripleStore:
             triple_stores = list(filter(lambda triple_store: (triple_store["uri"] in test_config.filter_on_tripleStore),
@@ -300,7 +280,8 @@ class MustrdTestPlugin:
             if test_conf.originalname != test_conf.name:
                 module_name = test_conf.parent.name
                 class_name = test_conf.originalname
-                test_name = test_conf.name.replace(class_name, "").replace("[", "").replace("]", "")
+                test_name = test_conf.name.replace(
+                    class_name, "").replace("[", "").replace("]", "")
                 is_mustrd = True
             # Case normal unit tests
             else:
@@ -309,7 +290,8 @@ class MustrdTestPlugin:
                 test_name = test_conf.originalname
                 is_mustrd = False
 
-            test_results.append(TestResult(test_name, class_name, module_name, result.outcome, is_mustrd))
+            test_results.append(TestResult(
+                test_name, class_name, module_name, result.outcome, is_mustrd))
 
         result_list = ResultList(None, get_result_list(test_results,
                                                        lambda result: result.type,
@@ -321,6 +303,66 @@ class MustrdTestPlugin:
             file.write(md)
 
 
+class MustrdFile(pytest.File):
+    mustrd_plugin: MustrdTestPlugin
+
+    def collect(self):
+        try:
+            logger.debug(f"Collecting tests from file: {self.fspath}")
+            test_configs = parse_config(self.fspath)
+            for test_config in test_configs:
+                # Skip if there is a path filter and it is not in the pytest path
+                if self.mustrd_plugin.path_filter is not None and self.mustrd_plugin.path_filter not in test_config.pytest_path:
+                    continue
+                triple_stores = self.mustrd_plugin.get_triple_stores_from_file(
+                    test_config)
+
+                if test_config.filter_on_tripleStore and not triple_stores:
+                    specs = list(map(
+                        lambda triple_store:
+                        SpecSkipped(MUST.TestSpec, triple_store,
+                                    "No triplestore found"),
+                        test_config.filter_on_tripleStore))
+                else:
+                    specs = self.mustrd_plugin.generate_tests_for_config({"spec_path": test_config.spec_path,
+                                                                          "data_path": test_config.data_path},
+                                                                         triple_stores, None)
+                for spec in specs:
+                    # Check if the current test is in the selected tests in arguments
+                    if spec.spec_source_file.resolve() in self.mustrd_plugin.selected_tests \
+                            or self.mustrd_plugin.selected_tests == []:
+                        item = MustrdItem.from_parent(
+                            self, name=test_config.pytest_path + "/" + spec.spec_file_name, spec=spec)
+                        self.mustrd_plugin.items.append(item)
+                        yield item
+        except BaseException as e:
+            # Catch error here otherwise it will be lost
+            self.mustrd_plugin.collect_error = e
+            logger.error(f"Error during collection: {e}")
+            raise e
+
+
+class MustrdItem(pytest.Item):
+    def __init__(self, name, parent, spec):
+        logging.info(f"Creating item: {name}")
+        super().__init__(name, parent)
+        self.spec = spec
+        self.fspath = spec.spec_source_file
+
+    def runtest(self):
+        result = run_test_spec(self.spec)
+        if not result:
+            raise AssertionError(f"Test {self.name} failed")
+
+    def repr_failure(self, excinfo):
+        return f"{self.name} failed: {excinfo.value}"
+
+    def reportinfo(self):
+        r = "", 0, f"mustrd test: {self.name}"
+        logger.debug(f"Reporting info for {self.name} {r=}")
+        return r
+
+
 # Function called in the test to actually run it
 def run_test_spec(test_spec):
     if isinstance(test_spec, SpecSkipped):
@@ -331,4 +373,6 @@ def run_test_spec(test_spec):
     if result_type == SpecSkipped:
         # FIXME: Better exception management
         pytest.skip("Unsupported configuration")
+    if result_type != SpecPassed:
+        write_result_diff_to_log(result)
     return result_type == SpecPassed