683 lines
21 KiB
JavaScript
683 lines
21 KiB
JavaScript
import { describe, expect, it } from "vitest";
|
|
import {
|
|
applyValidatedProposal,
|
|
assessReasoningPatternCompatibility,
|
|
assessStructuralContextAdmission,
|
|
} from "@/lib/graph/apply-proposal.js";
|
|
import { selectReasoningPattern } from "@/lib/graph/question-formulator.js";
|
|
import { makeGraph, makeNode } from "@/lib/graph/schema.js";
|
|
|
|
// ── Helpers ──────────────────────────────────────────────
|
|
|
|
function buildDecisionContext() {
|
|
const decision = makeNode({
|
|
id: "n_relocation_decision",
|
|
label: "Whether continuing development is commercially justified",
|
|
description:
|
|
"Need to know whether continuing development is commercially justified before committing resources.",
|
|
kind: "unknown",
|
|
status: "unknown",
|
|
confidence: "medium",
|
|
});
|
|
|
|
return makeGraph({
|
|
centralStatement:
|
|
"Relocation decision context for structural embedding tests.",
|
|
nodes: [decision],
|
|
edges: [],
|
|
activeUnknownNodeId: decision.id,
|
|
resolvedNodeIds: [],
|
|
currentSummary: "Decision fixture",
|
|
});
|
|
}
|
|
|
|
function addOption(graph, optionId) {
|
|
const option = makeNode({
|
|
id: optionId,
|
|
label: "Relocate to new office",
|
|
description: "Move operations to a new location.",
|
|
kind: "option",
|
|
status: "provisional",
|
|
});
|
|
graph.nodes.push(option);
|
|
graph.edges.push({
|
|
id: `${optionId}_contained_in`,
|
|
fromNodeId: optionId,
|
|
toNodeId: graph.activeUnknownNodeId,
|
|
relationship: "contained_in",
|
|
confidence: "high",
|
|
description: "Option belongs to this decision.",
|
|
});
|
|
}
|
|
|
|
function resolveActivePattern(graph) {
|
|
const activeNode = graph.nodes.find(
|
|
(n) => n.id === graph.activeUnknownNodeId,
|
|
);
|
|
if (!activeNode) return null;
|
|
return selectReasoningPattern({ node: activeNode, graph }).pattern;
|
|
}
|
|
|
|
function assessBoundedAdmission(graph, node, overrides = {}) {
|
|
return assessStructuralContextAdmission({
|
|
node,
|
|
graph,
|
|
activePattern: overrides.activePattern ?? resolveActivePattern(graph),
|
|
activeNodeId: overrides.activeNodeId ?? graph.activeUnknownNodeId,
|
|
});
|
|
}
|
|
|
|
function buildApplyProposalDecisionFixture() {
|
|
const decision = makeNode({
|
|
id: "n_active_decision",
|
|
label: "Whether relocating is commercially justified",
|
|
description:
|
|
"Need to evaluate whether relocating is commercially justified.",
|
|
kind: "unknown",
|
|
status: "unknown",
|
|
confidence: "medium",
|
|
});
|
|
|
|
return makeGraph({
|
|
centralStatement: "Relocation follow-up fixture.",
|
|
nodes: [decision],
|
|
edges: [],
|
|
activeUnknownNodeId: decision.id,
|
|
resolvedNodeIds: [],
|
|
currentSummary: "Decision apply-proposal fixture",
|
|
});
|
|
}
|
|
|
|
// ── Tests ────────────────────────────────────────────────
|
|
|
|
describe("reasoning-context compatibility — bounded structural admission (60B.19)", () => {
|
|
it("Test 1 - Route A: newly-added decision unknown admitted via parent/ancestor chain", () => {
|
|
const decision = makeNode({
|
|
id: "n_decision_a",
|
|
label: "Investment context A",
|
|
description: "A parent context for the option under review.",
|
|
kind: "unknown",
|
|
status: "unknown",
|
|
confidence: "medium",
|
|
});
|
|
|
|
const parentOption = makeNode({
|
|
id: "opt_parent_a",
|
|
label: "Parent option A",
|
|
description: "An option for the decision.",
|
|
kind: "option",
|
|
status: "provisional",
|
|
parentId: "n_decision_a",
|
|
});
|
|
|
|
const childUnknown = makeNode({
|
|
id: "n_child_embedded",
|
|
label: "What practical issue is blocking progress",
|
|
description:
|
|
"Need to identify the specific blocking issue before continuing this line of work.",
|
|
kind: "unknown",
|
|
status: "unknown",
|
|
confidence: "medium",
|
|
parentId: "opt_parent_a",
|
|
});
|
|
|
|
const graph = makeGraph({
|
|
centralStatement: "Market entry decision.",
|
|
nodes: [decision, parentOption],
|
|
edges: [],
|
|
activeUnknownNodeId: "n_decision_a",
|
|
resolvedNodeIds: [],
|
|
currentSummary: "Route A fixture",
|
|
});
|
|
|
|
// childUnknown is not yet in graph.nodes; add it so we can build the chain
|
|
const compat = assessBoundedAdmission(
|
|
{ ...graph, nodes: [...graph.nodes, childUnknown] },
|
|
childUnknown,
|
|
{ activePattern: "decision", activeNodeId: "n_decision_a" },
|
|
);
|
|
|
|
expect(compat.admitted).toBe(true);
|
|
expect(compat.structuralEmbedding).toBe(true);
|
|
expect(compat.routeA).toBe(true);
|
|
});
|
|
|
|
it("Test 2 - Route B may_cause admitted", () => {
|
|
const graph = buildDecisionContext();
|
|
addOption(graph, "opt_relocate");
|
|
|
|
const newUnknown = makeNode({
|
|
id: "n_client_retention_uncertainty",
|
|
label: "What practical risk affects this option",
|
|
description:
|
|
"Need to identify the concrete risk factor affecting this option.",
|
|
kind: "unknown",
|
|
status: "unknown",
|
|
confidence: "medium",
|
|
});
|
|
|
|
graph.nodes.push(newUnknown);
|
|
graph.edges.push({
|
|
id: "n_client_retention_uncertainty_may_cause_opt_relocate",
|
|
fromNodeId: "n_client_retention_uncertainty",
|
|
toNodeId: "opt_relocate",
|
|
relationship: "may_cause",
|
|
confidence: "medium",
|
|
description: "May cause option consequence.",
|
|
});
|
|
|
|
const compat = assessBoundedAdmission(graph, newUnknown);
|
|
|
|
expect(compat.admitted).toBe(true);
|
|
expect(compat.structuralEmbedding).toBe(true);
|
|
expect(compat.routeB).toBe(true);
|
|
});
|
|
|
|
it("Test 3 - Route B causes admitted", () => {
|
|
const graph = buildDecisionContext();
|
|
addOption(graph, "opt_relocate");
|
|
|
|
// Add the node and edge into the graph for traversal.
|
|
const newUnknown = makeNode({
|
|
id: "n_client_retention_uncertainty",
|
|
label: "What practical risk affects this option",
|
|
description:
|
|
"Need to identify the concrete risk factor affecting this option.",
|
|
kind: "unknown",
|
|
status: "unknown",
|
|
confidence: "medium",
|
|
});
|
|
|
|
graph.nodes.push(newUnknown);
|
|
graph.edges.push({
|
|
id: "n_client_retention_uncertainty_causes_opt_relocate",
|
|
fromNodeId: "n_client_retention_uncertainty",
|
|
toNodeId: "opt_relocate",
|
|
relationship: "causes",
|
|
confidence: "medium",
|
|
description: "Causal link.",
|
|
});
|
|
|
|
const compat = assessBoundedAdmission(graph, newUnknown);
|
|
|
|
expect(compat.admitted).toBe(true);
|
|
expect(compat.structuralEmbedding).toBe(true);
|
|
expect(compat.routeB).toBe(true);
|
|
});
|
|
|
|
it("Test 4 - Route B affects admitted", () => {
|
|
const graph = buildDecisionContext();
|
|
addOption(graph, "opt_relocate");
|
|
|
|
const newUnknown = makeNode({
|
|
id: "n_client_retention_uncertainty",
|
|
label: "What practical risk affects this option",
|
|
description:
|
|
"Need to identify the concrete risk factor affecting this option.",
|
|
kind: "unknown",
|
|
status: "unknown",
|
|
confidence: "medium",
|
|
});
|
|
|
|
graph.nodes.push(newUnknown);
|
|
graph.edges.push({
|
|
id: "n_client_retention_uncertainty_affects_opt_relocate",
|
|
fromNodeId: "n_client_retention_uncertainty",
|
|
toNodeId: "opt_relocate",
|
|
relationship: "affects",
|
|
confidence: "medium",
|
|
description: "Impact link.",
|
|
});
|
|
|
|
const compat = assessBoundedAdmission(graph, newUnknown);
|
|
|
|
expect(compat.admitted).toBe(true);
|
|
expect(compat.structuralEmbedding).toBe(true);
|
|
expect(compat.routeB).toBe(true);
|
|
});
|
|
|
|
it("Test 5 - supports does NOT qualify as structural embedding", () => {
|
|
const graph = buildDecisionContext();
|
|
addOption(graph, "opt_relocate");
|
|
|
|
const newUnknown = makeNode({
|
|
id: "n_supporting_factor",
|
|
label: "What causes the revenue discrepancy?",
|
|
description: "Need to understand root cause of divergence.",
|
|
kind: "unknown",
|
|
status: "unknown",
|
|
confidence: "medium",
|
|
});
|
|
|
|
graph.nodes.push(newUnknown);
|
|
graph.edges.push({
|
|
id: "n_supporting_factor_supports_opt_relocate",
|
|
fromNodeId: "n_supporting_factor",
|
|
toNodeId: "opt_relocate",
|
|
relationship: "supports",
|
|
confidence: "medium",
|
|
description: "Support link.",
|
|
});
|
|
|
|
const compat = assessBoundedAdmission(graph, newUnknown);
|
|
|
|
expect(compat.admitted).toBe(false);
|
|
expect(compat.structuralEmbedding).toBe(false);
|
|
});
|
|
|
|
it("Test 6 - measures does NOT qualify as structural embedding", () => {
|
|
const graph = buildDecisionContext();
|
|
addOption(graph, "opt_relocate");
|
|
|
|
const newUnknown = makeNode({
|
|
id: "n_measuring_node",
|
|
label: "What causes the revenue discrepancy?",
|
|
description: "Need to understand root cause of divergence.",
|
|
kind: "unknown",
|
|
status: "unknown",
|
|
confidence: "medium",
|
|
});
|
|
|
|
graph.nodes.push(newUnknown);
|
|
graph.edges.push({
|
|
id: "n_measuring_node_measures_opt_relocate",
|
|
fromNodeId: "n_measuring_node",
|
|
toNodeId: "opt_relocate",
|
|
relationship: "measures",
|
|
confidence: "medium",
|
|
description: "Measurement link.",
|
|
});
|
|
|
|
const compat = assessBoundedAdmission(graph, newUnknown);
|
|
|
|
expect(compat.admitted).toBe(false);
|
|
expect(compat.structuralEmbedding).toBe(false);
|
|
});
|
|
|
|
it("Test 7 - depends_on does NOT qualify as structural embedding", () => {
|
|
const graph = buildDecisionContext();
|
|
addOption(graph, "opt_relocate");
|
|
|
|
const newUnknown = makeNode({
|
|
id: "n_depends_node",
|
|
label: "What causes the revenue discrepancy?",
|
|
description: "Need to understand root cause of divergence.",
|
|
kind: "unknown",
|
|
status: "unknown",
|
|
confidence: "medium",
|
|
});
|
|
|
|
graph.nodes.push(newUnknown);
|
|
graph.edges.push({
|
|
id: "n_depends_node_depends_on_opt_relocate",
|
|
fromNodeId: "n_depends_node",
|
|
toNodeId: "opt_relocate",
|
|
relationship: "depends_on",
|
|
confidence: "medium",
|
|
description: "Dependency link.",
|
|
});
|
|
|
|
const compat = assessBoundedAdmission(graph, newUnknown);
|
|
|
|
expect(compat.admitted).toBe(false);
|
|
expect(compat.structuralEmbedding).toBe(false);
|
|
});
|
|
|
|
it("Test 8 - arbitrary graph connectivity does NOT produce compatibility", () => {
|
|
const graph = buildDecisionContext();
|
|
addOption(graph, "opt_relocate");
|
|
|
|
const intermediateNode = makeNode({
|
|
id: "n_intermediate",
|
|
label: "Some unrelated factor",
|
|
description: "Not relevant.",
|
|
kind: "unknown",
|
|
status: "unknown",
|
|
confidence: "medium",
|
|
});
|
|
|
|
const newUnknown = makeNode({
|
|
id: "n_arbitrary_path",
|
|
label: "What causes the revenue discrepancy?",
|
|
description: "Need to understand root cause of divergence.",
|
|
kind: "unknown",
|
|
status: "unknown",
|
|
confidence: "medium",
|
|
});
|
|
|
|
graph.nodes.push(intermediateNode, newUnknown);
|
|
graph.edges.push({
|
|
id: "n_arbitrary_path_may_cause_intermediate",
|
|
fromNodeId: "n_arbitrary_path",
|
|
toNodeId: "n_intermediate",
|
|
relationship: "may_cause",
|
|
confidence: "medium",
|
|
description: "Connects to intermediate, not an option.",
|
|
});
|
|
|
|
const compat = assessBoundedAdmission(graph, newUnknown);
|
|
|
|
expect(compat.admitted).toBe(false);
|
|
expect(compat.structuralEmbedding).toBe(false);
|
|
});
|
|
|
|
it("Test 9 - wrong decision context rejects", () => {
|
|
const otherDecision = makeNode({
|
|
id: "n_other_decision",
|
|
label: "Should we launch product B?",
|
|
description: "Different decision.",
|
|
kind: "unknown",
|
|
status: "unknown",
|
|
confidence: "medium",
|
|
});
|
|
|
|
const baseGraph = makeGraph({
|
|
centralStatement: "Testing wrong decision context.",
|
|
nodes: [buildDecisionContext().nodes[0], otherDecision],
|
|
edges: [],
|
|
activeUnknownNodeId: "n_relocation_decision",
|
|
resolvedNodeIds: [],
|
|
currentSummary: "Wrong context fixture",
|
|
});
|
|
|
|
const wrongOption = makeNode({
|
|
id: "opt_wrong_context",
|
|
label: "Launch product B option",
|
|
description: "Belongs to other decision.",
|
|
kind: "option",
|
|
status: "provisional",
|
|
});
|
|
|
|
baseGraph.nodes.push(wrongOption);
|
|
baseGraph.edges.push({
|
|
id: "opt_wrong_context_contained_in_other",
|
|
fromNodeId: "opt_wrong_context",
|
|
toNodeId: "n_other_decision",
|
|
relationship: "contained_in",
|
|
confidence: "high",
|
|
description: "Wrong decision membership.",
|
|
});
|
|
|
|
const newUnknown = makeNode({
|
|
id: "n_wrong_context_unknown",
|
|
label: "What practical risk affects this option",
|
|
description:
|
|
"Need to identify the concrete risk factor affecting this option.",
|
|
kind: "unknown",
|
|
status: "unknown",
|
|
confidence: "medium",
|
|
});
|
|
|
|
baseGraph.nodes.push(newUnknown);
|
|
baseGraph.edges.push({
|
|
id: "n_wrong_context_unknown_may_cause_opt",
|
|
fromNodeId: "n_wrong_context_unknown",
|
|
toNodeId: "opt_wrong_context",
|
|
relationship: "may_cause",
|
|
confidence: "medium",
|
|
description: "May cause wrong option.",
|
|
});
|
|
|
|
const compat = assessBoundedAdmission(baseGraph, newUnknown);
|
|
|
|
expect(compat.admitted).toBe(false);
|
|
expect(compat.structuralEmbedding).toBe(false);
|
|
});
|
|
|
|
it("Test 10 - already-compatible pattern remains unchanged", () => {
|
|
const decision = makeNode({
|
|
id: "n_decision_10",
|
|
label: "Whether proceeding is commercially justified",
|
|
description:
|
|
"Need to evaluate whether proceeding is commercially justified.",
|
|
kind: "unknown",
|
|
status: "unknown",
|
|
confidence: "medium",
|
|
});
|
|
|
|
const definitionNode = makeNode({
|
|
id: "n_definition_node",
|
|
label: "Definition of commercially justified",
|
|
description: "Define what commercially justified means. Define the term.",
|
|
kind: "unknown",
|
|
status: "unknown",
|
|
confidence: "medium",
|
|
});
|
|
|
|
const graph = makeGraph({
|
|
centralStatement: "Decision context.",
|
|
nodes: [decision, definitionNode],
|
|
edges: [],
|
|
activeUnknownNodeId: "n_decision_10",
|
|
resolvedNodeIds: [],
|
|
currentSummary: "Already compatible fixture",
|
|
});
|
|
|
|
const compat = assessBoundedAdmission(graph, definitionNode);
|
|
|
|
expect(compat.intrinsicCompatible).toBe(true);
|
|
expect(compat.admitted).toBe(false);
|
|
expect(compat.structuralEmbedding).toBe(false);
|
|
});
|
|
|
|
it("Test 11 - genuine incompatible child under explanation is rejected", () => {
|
|
const explanationUnknown = makeNode({
|
|
id: "n_explanation",
|
|
label: "Explanation for why revenue increased by 18%",
|
|
description:
|
|
"Need to understand what change or event could explain these observations.",
|
|
kind: "unknown",
|
|
status: "unknown",
|
|
confidence: "medium",
|
|
});
|
|
|
|
const graph = makeGraph({
|
|
centralStatement:
|
|
"Revenue increased by 18%, but cash in the bank fell over the same period.",
|
|
nodes: [
|
|
explanationUnknown,
|
|
makeNode({
|
|
id: "n_revenue_obs",
|
|
label: "Revenue increased by 18%.",
|
|
description: "Revenue increased by 18%.",
|
|
kind: "observation",
|
|
status: "supported",
|
|
confidence: "high",
|
|
}),
|
|
makeNode({
|
|
id: "n_cash_obs",
|
|
label: "Cash in the bank fell over the same period.",
|
|
description: "Cash in the bank fell.",
|
|
kind: "observation",
|
|
status: "supported",
|
|
confidence: "high",
|
|
}),
|
|
],
|
|
edges: [],
|
|
activeUnknownNodeId: "n_explanation",
|
|
resolvedNodeIds: [],
|
|
currentSummary: "Explanation fixture",
|
|
});
|
|
|
|
const diagnosisChild = makeNode({
|
|
id: "n_diagnosis_child",
|
|
label: "What practical issue is blocking progress",
|
|
description:
|
|
"Need to identify the specific blocking issue before continuing this line of work.",
|
|
kind: "unknown",
|
|
status: "unknown",
|
|
confidence: "medium",
|
|
parentId: "n_explanation",
|
|
});
|
|
|
|
graph.nodes.push(diagnosisChild);
|
|
|
|
const compat = assessBoundedAdmission(graph, diagnosisChild);
|
|
const compatibility = assessReasoningPatternCompatibility({
|
|
node: diagnosisChild,
|
|
graph,
|
|
activePattern: resolveActivePattern(graph),
|
|
activeNodeId: graph.activeUnknownNodeId,
|
|
});
|
|
|
|
expect(compat.admitted).toBe(false);
|
|
expect(compat.nodePattern).toBe("diagnosis");
|
|
expect(compat.structuralEmbedding).toBe(false);
|
|
expect(compatibility.compatible).toBe(false);
|
|
});
|
|
|
|
it("Test 12 - pre-existing unknown does not enter fallback", () => {
|
|
const graph = buildApplyProposalDecisionFixture();
|
|
const preExisting = makeNode({
|
|
id: "n_preexisting_diagnosis",
|
|
label: "What practical risk affects this option",
|
|
description:
|
|
"Need to identify the concrete risk factor affecting this option.",
|
|
kind: "unknown",
|
|
status: "unknown",
|
|
confidence: "medium",
|
|
parentId: graph.activeUnknownNodeId,
|
|
});
|
|
graph.nodes.push(preExisting);
|
|
|
|
const result = applyValidatedProposal({
|
|
situationGraph: graph,
|
|
proposal: {
|
|
addedNodes: [],
|
|
updatedNodes: [
|
|
{
|
|
nodeId: graph.activeUnknownNodeId,
|
|
previousStatus: "unknown",
|
|
newStatus: "known",
|
|
previousValue: null,
|
|
newValue: "Decision anchor updated for selection.",
|
|
reason: "Makes the parent answer-derived for the test.",
|
|
},
|
|
],
|
|
addedEdges: [],
|
|
removedEdgeIds: [],
|
|
resolvedUnknownNodeIds: [],
|
|
affectedNodeIds: [],
|
|
selectedQuestion: {
|
|
nodeId: "n_preexisting_diagnosis",
|
|
question: "What practical risk affects this option?",
|
|
reason: "Pre-existing node should not gain fallback admission.",
|
|
},
|
|
},
|
|
});
|
|
|
|
expect(result.success).toBe(true);
|
|
});
|
|
|
|
it("Test 13 - admitted node survives later result validation", () => {
|
|
const graph = buildApplyProposalDecisionFixture();
|
|
|
|
const result = applyValidatedProposal({
|
|
situationGraph: graph,
|
|
answer: "We need to identify the practical risk affecting this option.",
|
|
previousQuestion: "Should we relocate?",
|
|
proposal: {
|
|
addedNodes: [
|
|
makeNode({
|
|
id: "n_added_route_a",
|
|
label: "What practical risk affects this option",
|
|
description:
|
|
"Need to identify the concrete risk factor affecting this option because it matters to the decision.",
|
|
kind: "unknown",
|
|
status: "unknown",
|
|
confidence: "medium",
|
|
parentId: graph.activeUnknownNodeId,
|
|
}),
|
|
],
|
|
updatedNodes: [
|
|
{
|
|
nodeId: graph.activeUnknownNodeId,
|
|
previousStatus: "unknown",
|
|
newStatus: "provisional",
|
|
previousValue: null,
|
|
newValue: "Decision remains open pending factor clarification.",
|
|
reason: "The answer introduces a concrete follow-up factor.",
|
|
},
|
|
],
|
|
addedEdges: [],
|
|
removedEdgeIds: [],
|
|
resolvedUnknownNodeIds: [],
|
|
affectedNodeIds: [],
|
|
selectedQuestion: {
|
|
nodeId: "n_added_route_a",
|
|
question: "What practical risk affects this option?",
|
|
reason: "New factor introduced this turn.",
|
|
},
|
|
answerMeaning: {
|
|
userSupportedMeaning:
|
|
"We need to identify the practical risk affecting this option.",
|
|
possibleInference: null,
|
|
supportCategory: null,
|
|
resolutionGuidance: null,
|
|
},
|
|
structuralActionRequired: true,
|
|
},
|
|
});
|
|
|
|
expect(result.success).toBe(true);
|
|
expect(result.selectedQuestion?.nodeId).toBe("n_added_route_a");
|
|
});
|
|
|
|
it("Test 14 - non-pattern validations still apply", () => {
|
|
const graph = buildApplyProposalDecisionFixture();
|
|
|
|
const result = applyValidatedProposal({
|
|
situationGraph: graph,
|
|
answer: "We need to identify the practical risk affecting this option.",
|
|
previousQuestion: "Should we relocate?",
|
|
proposal: {
|
|
addedNodes: [
|
|
makeNode({
|
|
id: "n_added_invalid",
|
|
label: "What practical risk affects this option",
|
|
description:
|
|
"Need to identify the concrete risk factor affecting this option because it matters to the decision.",
|
|
kind: "unknown",
|
|
status: "unknown",
|
|
confidence: "medium",
|
|
parentId: graph.activeUnknownNodeId,
|
|
}),
|
|
],
|
|
updatedNodes: [
|
|
{
|
|
nodeId: graph.activeUnknownNodeId,
|
|
previousStatus: "unknown",
|
|
newStatus: "provisional",
|
|
previousValue: null,
|
|
newValue: "Decision remains open pending factor clarification.",
|
|
reason: "The answer introduces a concrete follow-up factor.",
|
|
},
|
|
],
|
|
addedEdges: [],
|
|
removedEdgeIds: [],
|
|
resolvedUnknownNodeIds: [],
|
|
affectedNodeIds: [],
|
|
selectedQuestion: {
|
|
nodeId: "n_added_invalid",
|
|
question:
|
|
"What practical risk affects this option, and how severe is it?",
|
|
reason: "Compound question should still fail.",
|
|
},
|
|
answerMeaning: {
|
|
userSupportedMeaning:
|
|
"We need to identify the practical risk affecting this option.",
|
|
possibleInference: null,
|
|
supportCategory: null,
|
|
resolutionGuidance: null,
|
|
},
|
|
structuralActionRequired: true,
|
|
},
|
|
});
|
|
|
|
expect(result.success).toBe(false);
|
|
expect(result.errors.join(" ")).toContain(
|
|
"selectedQuestion must be a single non-compound question",
|
|
);
|
|
});
|
|
});
|