testeranto 0.203.0 → 0.205.0

package/src/graphml.xsd

@@ -0,0 +1,345 @@
+<?xml version="1.0"?>
+
+<xs:schema   
+             targetNamespace="http://graphml.graphdrawing.org/xmlns"
+
+             xmlns="http://graphml.graphdrawing.org/xmlns"
+             xmlns:xs="http://www.w3.org/2001/XMLSchema"
+
+             elementFormDefault="qualified"
+             attributeFormDefault="unqualified"
+>
+
+  <xs:annotation>
+    <xs:documentation 
+        source="http://graphml.graphdrawing.org/"
+        xml:lang="en">
+     This document defines the GraphML language including GraphML attributes and GraphML parseinfo.
+    </xs:documentation>
+  </xs:annotation>
+
+
+<xs:redefine schemaLocation="http://graphml.graphdrawing.org/xmlns/1.0/graphml-structure.xsd">
+
+  <!--redefinition as in graphml-attributes.xsd -->
+
+  <xs:attributeGroup name="key.extra.attrib">
+    <xs:attributeGroup ref="key.extra.attrib"/>
+    <xs:attributeGroup ref="key.attributes.attrib"/>
+  </xs:attributeGroup>
+
+  <!--redefinition as in graphml-parseinfo.xsd -->
+
+  <xs:attributeGroup name="graph.extra.attrib">
+    <xs:attributeGroup ref="graph.extra.attrib"/>
+    <xs:attributeGroup ref="graph.parseinfo.attrib"/>
+  </xs:attributeGroup>
+
+  <xs:attributeGroup name="node.extra.attrib">
+    <xs:attributeGroup ref="node.extra.attrib"/>
+    <xs:attributeGroup ref="node.parseinfo.attrib"/>
+  </xs:attributeGroup>
+
+</xs:redefine>
+
+
+  <!--types as in graphml-attributes.xsd -->
+
+<xs:simpleType name="key.name.type" final="#all">
+
+  <xs:annotation>
+    <xs:documentation 
+        source="http://graphml.graphdrawing.org/(Dokumentation der Attributes Erweiterung; entsprechende Stelle.html)"
+        xml:lang="en">
+      Simple type for the attr.name attribute of &lt;key>.
+      key.name.type is final, that is, it may not be extended
+                          or restricted.
+      key.name.type is a restriction of xs:NMTOKEN
+      Allowed values: (no restriction)
+    </xs:documentation>
+  </xs:annotation>
+
+  <xs:restriction base="xs:NMTOKEN"/>
+
+</xs:simpleType>
+
+
+
+<xs:simpleType name="key.type.type" final="#all">
+
+  <xs:annotation>
+    <xs:documentation 
+        source="http://graphml.graphdrawing.org/(Dokumentation der Attributes Erweiterung; entsprechende Stelle.html)"
+        xml:lang="en">
+      Simple type for the attr.type attribute of &lt;key>.
+      key.type.type is final, that is, it may not be extended
+                          or restricted.
+      key.type.type is a restriction of xs:NMTOKEN
+      Allowed values: boolean, int, long, float, double, string.
+    </xs:documentation>
+  </xs:annotation>
+
+  <xs:restriction base="xs:NMTOKEN">  
+    <xs:enumeration value="boolean"/>
+    <xs:enumeration value="int"/>
+    <xs:enumeration value="long"/>
+    <xs:enumeration value="float"/>
+    <xs:enumeration value="double"/>
+    <xs:enumeration value="string"/>
+  </xs:restriction>
+
+</xs:simpleType>
+
+
+<xs:attributeGroup name="key.attributes.attrib">
+
+  <xs:annotation>
+    <xs:documentation 
+        source="http://graphml.graphdrawing.org/"
+        xml:lang="en">
+     Definition of the attribute group key.attributes.attrib.
+     This group consists of the two optional attributes
+         - attr.name (gives the name for the data function)
+         - attr.type ((declares the range of values for the data function)
+    </xs:documentation>
+  </xs:annotation>
+
+  <xs:attribute name="attr.name" type="key.name.type" use="optional"/>
+  <xs:attribute name="attr.type" type="key.type.type" use="optional"/>
+</xs:attributeGroup>
+
+  <!--types as in graphml-parseinfo.xsd -->
+
+  <xs:annotation>
+    <xs:documentation 
+        source="http://graphml.graphdrawing.org/"
+        xml:lang="en">
+       Simple type definitions for the new graph attributes.
+    </xs:documentation>
+  </xs:annotation>
+
+<xs:simpleType name="graph.order.type"  final="#all">
+
+  <xs:annotation>
+    <xs:documentation 
+        source="http://graphml.graphdrawing.org/"
+        xml:lang="en">
+      Simple type for the parse.order attribute of &lt;graph>.
+      graph.order.type is final, that is, it may not be extended
+                          or restricted.
+      graph.order.type is a restriction of xs:NMTOKEN
+      Allowed values: free, nodesfirst, adjacencylist.
+    </xs:documentation>
+  </xs:annotation>
+
+  <xs:restriction base="xs:NMTOKEN">
+    <xs:enumeration value="free"/>
+    <xs:enumeration value="nodesfirst"/>
+    <xs:enumeration value="adjacencylist"/>
+  </xs:restriction>
+</xs:simpleType>
+
+<xs:simpleType name="graph.nodes.type"  final="#all">
+
+  <xs:annotation>
+    <xs:documentation 
+        source="http://graphml.graphdrawing.org/"
+        xml:lang="en">
+      Simple type for the parse.nodes attribute of &lt;graph>.
+      graph.nodes.type is final, that is, it may not be extended
+                          or restricted.
+      graph.nodes.type is a restriction of xs:nonNegativeInteger
+      Allowed values: (no restriction).
+    </xs:documentation>
+  </xs:annotation>
+
+  <xs:restriction base="xs:nonNegativeInteger"/>  
+</xs:simpleType>
+
+<xs:simpleType name="graph.edges.type" final="#all">
+
+  <xs:annotation>
+    <xs:documentation 
+        source="http://graphml.graphdrawing.org/"
+        xml:lang="en">
+      Simple type for the parse.edges attribute of &lt;graph>.
+      graph.edges.type is final, that is, it may not be extended
+                          or restricted.
+      graph.edges.type is a restriction of xs:nonNegativeInteger
+      Allowed values: (no restriction).
+    </xs:documentation>
+  </xs:annotation>
+
+  <xs:restriction base="xs:nonNegativeInteger"/>  
+</xs:simpleType>
+
+<xs:simpleType name="graph.maxindegree.type" final="#all">
+
+  <xs:annotation>
+    <xs:documentation 
+        source="http://graphml.graphdrawing.org/"
+        xml:lang="en">
+      Simple type for the parse.maxindegree attribute of &lt;graph>.
+      graph.maxindegree.type is final, that is, it may not be extended
+                          or restricted.
+      graph.maxindegree.type is a restriction of xs:nonNegativeInteger
+      Allowed values: (no restriction).
+    </xs:documentation>
+  </xs:annotation>
+
+  <xs:restriction base="xs:nonNegativeInteger"/>  
+</xs:simpleType>
+
+<xs:simpleType name="graph.maxoutdegree.type" final="#all">
+
+  <xs:annotation>
+    <xs:documentation 
+        source="http://graphml.graphdrawing.org/"
+        xml:lang="en">
+      Simple type for the parse.maxoutdegree attribute of &lt;graph>.
+      graph.maxoutdegree.type is final, that is, it may not be extended
+                          or restricted.
+      graph.maxoutdegree.type is a restriction of xs:nonNegativeInteger
+      Allowed values: (no restriction).
+    </xs:documentation>
+  </xs:annotation>
+
+  <xs:restriction base="xs:nonNegativeInteger"/>  
+</xs:simpleType>
+
+<xs:simpleType name="graph.nodeids.type"  final="#all">
+
+  <xs:annotation>
+    <xs:documentation 
+        source="http://graphml.graphdrawing.org/"
+        xml:lang="en">
+      Simple type for the parse.nodeids attribute of &lt;graph>.
+      graph.nodeids.type is final, that is, it may not be extended
+                          or restricted.
+      graph.nodeids.type is a restriction of xs:string
+      Allowed values: (no restriction).
+    </xs:documentation>
+  </xs:annotation>
+
+  <xs:restriction base="xs:NMTOKEN">
+    <xs:enumeration value="canonical"/>
+    <xs:enumeration value="free"/>
+  </xs:restriction>  
+</xs:simpleType>
+
+<xs:simpleType name="graph.edgeids.type"  final="#all">
+
+  <xs:annotation>
+    <xs:documentation 
+        source="http://graphml.graphdrawing.org/"
+        xml:lang="en">
+      Simple type for the parse.edgeids attribute of &lt;graph>.
+      graph.edgeids.type is final, that is, it may not be extended
+                          or restricted.
+      graph.edgeids.type is a restriction of xs:string
+      Allowed values: (no restriction).
+    </xs:documentation>
+  </xs:annotation>
+
+  <xs:restriction base="xs:NMTOKEN">
+    <xs:enumeration value="canonical"/>
+    <xs:enumeration value="free"/>
+  </xs:restriction>  
+</xs:simpleType>
+
+<xs:attributeGroup name="graph.parseinfo.attrib">
+
+  <xs:annotation>
+    <xs:documentation 
+        source="http://graphml.graphdrawing.org/"
+        xml:lang="en">
+     Definition of the attribute group graph.parseinfo.attrib.
+     This group consists of the seven attributes
+     - parse.nodeids (fixed to 'canonical' meaning that the id attribute
+                      of &lt;node> follows the pattern 'n[number]),
+     - parse.edgeids (fixed to 'canonical' meaning that the id attribute
+                      of &lt;edge> follows the pattern 'e[number]),
+     - parse.order (required; one of the values 'nodesfirst', 
+                    'adjacencylist' or 'free'),
+     - parse.nodes (required; number of nodes in this graph), 
+     - parse.edges (required; number of edges in this graph), 
+     - parse.maxindegree (optional; maximal indegree of a node in this graph),
+     - parse.maxoutdegree (optional; maximal outdegree of a node in this graph)
+    </xs:documentation>
+  </xs:annotation>
+
+  <xs:attribute name="parse.nodeids" type="graph.nodeids.type"/>
+  <xs:attribute name="parse.edgeids" type="graph.edgeids.type"/>
+  <xs:attribute name="parse.order" type="graph.order.type"/>
+  <xs:attribute name="parse.nodes" type="graph.nodes.type"/>
+  <xs:attribute name="parse.edges" type="graph.edges.type"/>
+  <xs:attribute name="parse.maxindegree" type="graph.maxindegree.type" use="optional"/>
+  <xs:attribute name="parse.maxoutdegree" type="graph.maxoutdegree.type" use="optional"/>
+</xs:attributeGroup>
+
+
+
+  <xs:annotation>
+    <xs:documentation 
+        source="http://graphml.graphdrawing.org/"
+        xml:lang="en">
+       Simple type definitions for the new node attributes.
+    </xs:documentation>
+  </xs:annotation>
+
+<xs:simpleType name="node.indegree.type" final="#all">
+
+  <xs:annotation>
+    <xs:documentation 
+        source="http://graphml.graphdrawing.org/"
+        xml:lang="en">
+      Simple type for the parse.indegree attribute of &lt;node>.
+      node.indegree.type is final, that is, it may not be extended
+                          or restricted.
+      node.indegree.type is a restriction of xs:nonNegativeInteger
+      Allowed values: (no restriction).
+    </xs:documentation>
+  </xs:annotation>
+
+  <xs:restriction base="xs:nonNegativeInteger"/>  
+</xs:simpleType>
+
+<xs:simpleType name="node.outdegree.type" final="#all">
+
+  <xs:annotation>
+    <xs:documentation 
+        source="http://graphml.graphdrawing.org/"
+        xml:lang="en">
+      Simple type for the parse.outdegree attribute of &lt;node>.
+      node.outdegree.type is final, that is, it may not be extended
+                          or restricted.
+      node.outdegree.type is a restriction of xs:nonNegativeInteger
+      Allowed values: (no restriction).
+    </xs:documentation>
+  </xs:annotation>
+
+  <xs:restriction base="xs:nonNegativeInteger"/>  
+</xs:simpleType>
+
+<xs:attributeGroup name="node.parseinfo.attrib">
+
+  <xs:annotation>
+    <xs:documentation 
+        source="http://graphml.graphdrawing.org/"
+        xml:lang="en">
+     Definition of the attribute group node.parseinfo.attrib.
+     This group consists of two attributes
+     - parse.indegree (optional; indegree of this node),
+     - parse.outdegree (optional; outdegree of this node).
+    </xs:documentation>
+  </xs:annotation>
+
+  <xs:attribute name="parse.indegree" type="node.indegree.type" use="optional"/>
+  <xs:attribute name="parse.outdegree" type="node.outdegree.type" use="optional"/>
+</xs:attributeGroup>
+
+</xs:schema>
+
+<!--======================================================-->
+<!--      end of file: graphml-parseinfo.xsd             -->
+<!--======================================================-->

package/src/lib/BaseGiven.ts

@@ -21,7 +21,6 @@ import { BaseSuite } from "./BaseSuite";
 export type IGivens<I extends Ibdd_in_any> = Record<string, BaseGiven<I>>;
 
 export abstract class BaseGiven<I extends Ibdd_in_any> {
-  // name: string;
   features: string[];
   whens: any[];
   thens: any[];
@@ -35,6 +34,8 @@ export abstract class BaseGiven<I extends Ibdd_in_any> {
   failed: boolean;
   artifacts: string[] = [];
 
+  status: boolean | undefined;
+
   addArtifact(path: string) {
     if (typeof path !== "string") {
       throw new Error(
@@ -54,31 +55,9 @@ export abstract class BaseGiven<I extends Ibdd_in_any> {
     givenCB: I["given"],
     initialValues: any
   ) {
-    // Ensure features are always strings
-    // Ensure features are always strings and not objects
-    // If features contains objects, it's likely a parameter shift error
-    this.features = (Array.isArray(features) ? features : [])
-      .map((feature) => {
-        // If feature is a string, use it directly
-        if (typeof feature === "string") return feature;
-        // If feature is an object, this is an error - log it and return empty string
-        if (feature && typeof feature === "object") {
-          console.error(
-            `[ERROR] Found object in features array: ${
-              feature.name || JSON.stringify(feature)
-            }`
-          );
-          return ""; // Return empty string to avoid issues
-        }
-        // For any other case, convert to string
-        return String(feature);
-      })
-      .filter((f) => f !== null && f !== undefined && f !== "");
-
-    // Ensure whens and thens are always arrays
-    this.whens = Array.isArray(whens) ? whens : [];
-    this.thens = Array.isArray(thens) ? thens : [];
-
+    this.features = features;
+    this.whens = whens;
+    this.thens = thens;
     this.givenCB = givenCB;
     this.initialValues = initialValues;
     this.fails = 0; // Initialize fail count
@@ -91,7 +70,6 @@ export abstract class BaseGiven<I extends Ibdd_in_any> {
   toObj() {
     return {
       key: this.key,
-      // name: this.name,
       whens: (this.whens || []).map((w) => {
         if (w && w.toObj) return w.toObj();
         console.error("When step is not as expected!", JSON.stringify(w));
@@ -102,6 +80,7 @@ export abstract class BaseGiven<I extends Ibdd_in_any> {
       failed: this.failed,
       features: this.features || [],
       artifacts: this.artifacts,
+      status: this.status,
     };
   }
 
@@ -139,7 +118,7 @@ export abstract class BaseGiven<I extends Ibdd_in_any> {
     this.fails = 0; // Initialize fail count for this given
 
     tLog(`\n ${this.key}`);
-    tLog(`\n Given: ${this.name}`);
+    tLog(`\n Given: ${this.key}`);
 
     const givenArtifactory = (fPath: string, value: unknown) =>
       artifactory(`given-${key}/${fPath}`, value);
@@ -162,7 +141,9 @@ export abstract class BaseGiven<I extends Ibdd_in_any> {
         this.initialValues,
         proxiedPm
       );
+      this.status = true;
     } catch (e) {
+      this.status = false;
       // console.error("Given failure: ", e.stack);
       this.failed = true;
       this.fails++; // Increment fail count
@@ -171,77 +152,73 @@ export abstract class BaseGiven<I extends Ibdd_in_any> {
     }
 
     try {
-      // tLog(`\n Given this.store`, this.store);
-
-      // Process when steps
       const whens = this.whens || [];
       // console.log(`[BaseGiven.give] Number of when steps: ${whens.length}`);
-      if (whens.length > 0) {
-        // console.log(`[BaseGiven.give] When steps exist, let's process them`);
-        for (const [whenNdx, whenStep] of whens.entries()) {
-          // console.log(
-          //   `[BaseGiven.give] Processing when step ${whenNdx}:`,
-          //   whenStep?.name
-          // );
-          // console.log(`[BaseGiven.give] Store before when step:`, this.store);
-          // console.log(`[BaseGiven.give] When step instance:`, whenStep);
+      // if (whens.length > 0) {
+      //   // console.log(`[BaseGiven.give] When steps exist, let's process them`);
+      //   for (const [whenNdx, whenStep] of whens.entries()) {
+      //     // console.log(
+      //     //   `[BaseGiven.give] Processing when step ${whenNdx}:`,
+      //     //   whenStep?.name
+      //     // );
+      //     // console.log(`[BaseGiven.give] Store before when step:`, this.store);
+      //     // console.log(`[BaseGiven.give] When step instance:`, whenStep);
 
-          // Check if this is actually a then step that was incorrectly placed in whens
-          if (
-            whenStep &&
-            whenStep.name &&
-            whenStep.name.startsWith("result:")
-          ) {
-            // console.error(
-            //   `[BaseGiven.give] ERROR: Found then step "${whenStep.name}" in whens array!`
-            // );
-            // Move it to thens array
-            this.thens.push(whenStep);
-            // console.log(
-            //   `[BaseGiven.give] Moved "${whenStep.name}" from whens to thens`
-            // );
-            continue; // Skip processing as a when step
-          }
+      //     // Check if this is actually a then step that was incorrectly placed in whens
+      //     // if (
+      //     //   whenStep &&
+      //     //   whenStep.name &&
+      //     //   whenStep.name.startsWith("result:")
+      //     // ) {
+      //     //   // console.error(
+      //     //   //   `[BaseGiven.give] ERROR: Found then step "${whenStep.name}" in whens array!`
+      //     //   // );
+      //     //   // Move it to thens array
+      //     //   this.thens.push(whenStep);
+      //     //   // console.log(
+      //     //   //   `[BaseGiven.give] Moved "${whenStep.name}" from whens to thens`
+      //     //   // );
+      //     //   continue; // Skip processing as a when step
+      //     // }
 
-          // Check if whenStep exists and whenStep.test is a function
-          if (whenStep && typeof whenStep.test === "function") {
-            try {
-              // Update the store with the result of the when step
-              this.store = await whenStep.test(
-                this.store,
-                testResourceConfiguration,
-                tLog,
-                pm,
-                `suite-${suiteNdx}/given-${key}/when/${whenNdx}`
-              );
-              // console.log(
-              //   `[BaseGiven.give] Store after when step ${whenNdx}:`,
-              //   this.store
-              // );
-            } catch (e) {
-              // console.error(
-              //   `[BaseGiven.give] Error in when step ${whenNdx}:`,
-              //   e
-              // );
-              this.failed = true;
-              this.fails++; // Increment fail count
-              throw e;
-            }
-          } else {
-            // console.error(
-            //   `[BaseGiven.give] whenStep.test is not a function:`,
-            //   typeof whenStep?.test
-            // );
-            this.failed = true;
-            this.fails++; // Increment fail count
-            throw new Error(`When step ${whenNdx} does not have a test method`);
-          }
-        }
-      } else {
-        console.log(`[BaseGiven.give] No when steps to process`);
-      }
+      //     // // Check if whenStep exists and whenStep.test is a function
+      //     // if (whenStep && typeof whenStep.test === "function") {
+      //     //   try {
+      //     //     // Update the store with the result of the when step
+      //     //     this.store = await whenStep.test(
+      //     //       this.store,
+      //     //       testResourceConfiguration,
+      //     //       tLog,
+      //     //       pm,
+      //     //       `suite-${suiteNdx}/given-${key}/when/${whenNdx}`
+      //     //     );
+      //     //     // console.log(
+      //     //     //   `[BaseGiven.give] Store after when step ${whenNdx}:`,
+      //     //     //   this.store
+      //     //     // );
+      //     //   } catch (e) {
+      //     //     // console.error(
+      //     //     //   `[BaseGiven.give] Error in when step ${whenNdx}:`,
+      //     //     //   e
+      //     //     // );
+      //     //     this.failed = true;
+      //     //     this.fails++; // Increment fail count
+      //     //     throw e;
+      //     //   }
+      //     // } else {
+      //     //   // console.error(
+      //     //   //   `[BaseGiven.give] whenStep.test is not a function:`,
+      //     //   //   typeof whenStep?.test
+      //     //   // );
+      //     //   this.failed = true;
+      //     //   this.fails++; // Increment fail count
+      //     //   throw new Error(`When step ${whenNdx} does not have a test method`);
+      //     // }
+      //   }
+      // } else {
+      //   console.log(`[BaseGiven.give] No when steps to process`);
+      // }
 
-      // Process then steps
       for (const [thenNdx, thenStep] of this.thens.entries()) {
         try {
           const t = await thenStep.test(
@@ -268,7 +245,6 @@ export abstract class BaseGiven<I extends Ibdd_in_any> {
       // throw e;
     } finally {
       try {
-        // Ensure addArtifact is properly bound to 'this'
         const addArtifact = this.addArtifact.bind(this);
         const proxiedPm = afterEachProxy(
           pm,

package/src/lib/BaseSuite.test/test.ts

@@ -139,18 +139,14 @@ export const implementation: ITestImplementation<I, O> = {
 
   whens: {
     // Add TestWhen which is defined in O type
-    TestWhen:
-      (): ((suite: MockSuite) => MockSuite) =>
-      (suite: MockSuite) => {
-        return suite;
-      },
+    TestWhen: (): ((suite: MockSuite) => MockSuite) => (suite: MockSuite) => {
+      return suite;
+    },
 
     // Add RunSuite which is defined in O type
-    RunSuite:
-      (): ((suite: MockSuite) => MockSuite) =>
-      (suite: MockSuite) => {
-        return suite;
-      },
+    RunSuite: (): ((suite: MockSuite) => MockSuite) => (suite: MockSuite) => {
+      return suite;
+    },
 
     // Add AddFeature which is used in the specification
     AddFeature:
@@ -166,8 +162,7 @@ export const implementation: ITestImplementation<I, O> = {
 
     // Add RunSuiteWithError which is used in the specification
     RunSuiteWithError:
-      (): ((suite: MockSuite) => MockSuite) =>
-      (suite: MockSuite) => {
+      (): ((suite: MockSuite) => MockSuite) => (suite: MockSuite) => {
         // Mark the suite as having an error
         return suite;
       },