jsonld-dataset-proxy and subscribable-dataset tests fixed

main
jaxoncreed 2 years ago
parent 0c33223982
commit 08649c5d7a
  1. 10
      packages/jsonld-dataset-proxy/src/arrayProxy/arrayMethods.ts
  2. 12
      packages/jsonld-dataset-proxy/test/jsonldDatasetProxy.test.ts
  3. 41
      packages/rdf-utils/src/nodeSerialization.ts
  4. 15
      packages/subscribable-dataset/example/subscribableDatasetExample.ts
  5. 2
      packages/subscribable-dataset/package.json
  6. 9
      packages/subscribable-dataset/src/ProxyTransactionalDataset.ts
  7. 27
      packages/subscribable-dataset/src/WrapperSubscribableDataset.ts
  8. 2
      packages/subscribable-dataset/src/WrapperSubscribableDatasetFactory.ts
  9. 2
      packages/subscribable-dataset/src/createWrapperSubscribableDataset.ts
  10. 3
      packages/subscribable-dataset/src/createWrapperSubscribableDatasetFromSerializedInput.ts
  11. 8
      packages/subscribable-dataset/src/types.ts
  12. 4
      packages/subscribable-dataset/test/ProxyTransactionalDataset.test.ts
  13. 27
      packages/subscribable-dataset/test/WrapperSubscribableDataset.test.ts

@ -42,11 +42,11 @@ export const arrayMethodsBuilders: ArrayMethodBuildersType = {
target,
key,
quadsToDelete: (quads) => {
if (!start) {
return [];
}
const realEnd = end || quads.length;
return quads.slice(targetIndex, targetIndex + (realEnd - start));
const oldQuads = [...quads];
const newQuadSet = new Set(
quads.copyWithin(targetIndex, start, end),
);
return oldQuads.filter((oldQuad) => !newQuadSet.has(oldQuad));
},
modifyCoreArray: (coreArray) => {
coreArray.copyWithin(targetIndex, start, end);

@ -854,6 +854,18 @@ describe("jsonldDatasetProxy", () => {
);
});
it("handles copyWithin with the optional start variable missing", async () => {
const [dataset, patient] = await getArrayLoadedDataset();
const arr = patient.name as string[];
// eslint-disable-next-line @typescript-eslint/ban-ts-comment
// @ts-ignore
expect(() => arr.copyWithin(0, undefined, 2)).not.toThrowError();
expect(arr).toEqual(["Garrett", "Bobby", "Ferguson"]);
expect(dataset.toString()).toEqual(
'<http://example.com/Patient1> <http://hl7.org/fhir/name> "Garrett" .\n<http://example.com/Patient1> <http://hl7.org/fhir/name> "Bobby" .\n<http://example.com/Patient1> <http://hl7.org/fhir/name> "Ferguson" .\n',
);
});
it("handles fill", async () => {
const [dataset, patient] = await getArrayLoadedDataset();
const arr = patient.name as string[];

@ -209,12 +209,13 @@ export function stringToNode(
expectTermType?: NodeTermTypes<Term>,
): AnyNode {
const node = stringToTerm(input);
if (expectTermType && expectTermType.has(node.termType)) {
if (expectTermType && !expectTermType.has(node.termType)) {
throw new Error(
`Expected term one of term type: [${Array.from(expectTermType).reduce(
(agg, termType) => `${agg}${termType}, `,
"",
)}], but got ${node.termType}.`,
`Expected term to be one of term type: [${Array.from(
expectTermType,
).reduce((agg, termType) => `${agg}${termType}, `, "")}], but got ${
node.termType
}.`,
);
}
return node as AnyNode;
@ -226,7 +227,11 @@ export function stringToNode(
* @returns Quad
*/
export function stringToQuad(input: string) {
return stringQuadToQuad(JSON.parse(input));
try {
return stringQuadToQuad(JSON.parse(input));
} catch (err) {
throw new Error("Invalid Quad String");
}
}
/**
@ -235,11 +240,21 @@ export function stringToQuad(input: string) {
* @returns QuadMatch
*/
export function stringToQuadMatch(input: string): QuadMatch {
const jsonRep = JSON.parse(input);
return [
jsonRep.subject ? stringToSubjectNode(jsonRep.subject) : undefined,
jsonRep.predicate ? stringToPredicateNode(jsonRep.predicate) : undefined,
jsonRep.object ? stringToObjectNode(jsonRep.object) : undefined,
jsonRep.graph ? stringToGraphNode(jsonRep.graph) : undefined,
];
try {
const jsonRep = JSON.parse(input);
return [
jsonRep.subject != undefined
? stringToSubjectNode(jsonRep.subject)
: undefined,
jsonRep.predicate != undefined
? stringToPredicateNode(jsonRep.predicate)
: undefined,
jsonRep.object != undefined
? stringToObjectNode(jsonRep.object)
: undefined,
jsonRep.graph != undefined ? stringToGraphNode(jsonRep.graph) : undefined,
];
} catch (err) {
throw new Error("Invalid Quad Match String");
}
}

@ -1,6 +1,6 @@
import { createSubscribableDataset } from "../src";
import { quad, namedNode, literal } from "@ldo/rdf-utils";
import type { Dataset, DatasetChanges } from "@ldo/rdf-utils";
import { quad, namedNode, literal } from "@rdfjs/data-model";
import type { DatasetChanges } from "@ldo/rdf-utils";
// Create an empty subscribable dataset
const subscribableDataset = createSubscribableDataset();
@ -23,10 +23,8 @@ subscribableDataset.addAll([
// Listener that will trigger whenever a quad containing the named
// node "http://example.org/cartoons#Zuko" is added or removed.
subscribableDataset.on(
namedNode("http://example.org/cartoons#Zuko"),
(zukoQuads: Dataset, changes: DatasetChanges) => {
console.log("ZUKO NODE CHANGED ============");
console.log(zukoQuads.toString());
[namedNode("http://example.org/cartoons#Zuko"), null, null, null],
(changes: DatasetChanges) => {
console.log("Added Quads:");
console.log(changes.added?.toString());
console.log("Removed Quads:");
@ -38,10 +36,9 @@ subscribableDataset.on(
// node "http://example.org/cartoons" is added or removed. This is
// useful for keeping track of the cartoons graph.
subscribableDataset.on(
namedNode("http://example.org/cartoons"),
(cartoonGraphQuads: Dataset, changes: DatasetChanges) => {
[namedNode("http://example.org/cartoons"), null, null, null],
(changes: DatasetChanges) => {
console.log("CARTOON GRAPH CHANGED ============");
console.log(cartoonGraphQuads.toString());
console.log("Added Quads:");
console.log(changes.added?.toString());
console.log("Removed Quads:");

@ -22,7 +22,9 @@
},
"homepage": "https://github.com/o-development/o-dataset-pack#readme",
"devDependencies": {
"@rdfjs/data-model": "^1.2.0",
"@rdfjs/dataset": "^1.1.0",
"@rdfjs/types": "^1.0.1",
"@types/jest": "^27.0.3",
"@types/jsonld": "^1.5.6",
"@types/rdfjs__dataset": "^1.0.4",

@ -1,10 +1,5 @@
import type {
Dataset,
BaseQuad,
Term,
DatasetFactory,
DatasetChanges,
} from "@ldo/rdf-utils";
import type { Dataset, BaseQuad, Term, DatasetFactory } from "@rdfjs/types";
import type { DatasetChanges } from "@ldo/rdf-utils";
import type { BulkEditableDataset, TransactionalDataset } from "./types";
import { ExtendedDataset } from "@ldo/dataset";

@ -2,16 +2,19 @@ import { EventEmitter } from "events";
import { quadMatchToString, stringToQuadMatch } from "@ldo/rdf-utils";
import type {
DatasetChanges,
Dataset,
BaseQuad,
Stream,
Term,
DatasetFactory,
QuadMatch,
SubjectNode,
PredicateNode,
ObjectNode,
GraphNode,
} from "@ldo/rdf-utils";
import type {
Dataset,
BaseQuad,
Stream,
Term,
DatasetFactory,
} from "@rdfjs/types";
import type {
nodeEventListener,
SubscribableDataset,
@ -39,10 +42,6 @@ export default class WrapperSubscribableDataset<
* The underlying event emitter
*/
private eventEmitter: EventEmitter;
/**
* EventNames as a Set for O(1) lookup
*/
private eventNamesSet: Set<string>;
/**
*
@ -56,7 +55,6 @@ export default class WrapperSubscribableDataset<
this.datasetFactory = datasetFactory;
this.dataset = initialDataset || this.datasetFactory.dataset();
this.eventEmitter = new EventEmitter();
this.eventNamesSet = new Set();
}
/**
@ -379,6 +377,7 @@ export default class WrapperSubscribableDataset<
subject: SubjectNode;
predicate: PredicateNode;
object: ObjectNode;
graph: GraphNode;
};
// All possible matches that could match with this triple
const quadMatches: QuadMatch[] = [
@ -390,6 +389,14 @@ export default class WrapperSubscribableDataset<
[null, quad.predicate, quad.object, null],
[null, null, quad.object, null],
[quad.subject, quad.predicate, quad.object, null],
[null, null, null, quad.graph],
[quad.subject, null, null, quad.graph],
[quad.subject, quad.predicate, null, quad.graph],
[quad.subject, null, quad.object, quad.graph],
[null, quad.predicate, null, quad.graph],
[null, quad.predicate, quad.object, quad.graph],
[null, null, quad.object, quad.graph],
[quad.subject, quad.predicate, quad.object, quad.graph],
];
quadMatches.forEach((quadMatch) => {
const eventName = quadMatchToString(quadMatch);

@ -1,4 +1,4 @@
import type { DatasetFactory, BaseQuad, Dataset } from "@ldo/rdf-utils";
import type { DatasetFactory, BaseQuad, Dataset } from "@rdfjs/types";
import WrapperSubscribableDataset from "./WrapperSubscribableDataset";
/**

@ -1,4 +1,4 @@
import type { Dataset, DatasetFactory, Quad } from "@ldo/rdf-utils";
import type { Dataset, DatasetFactory, Quad } from "@rdfjs/types";
import type { WrapperSubscribableDataset } from ".";
import { createDataset } from "@ldo/dataset";
import WrapperSubscribableDatasetFactory from "./WrapperSubscribableDatasetFactory";

@ -1,4 +1,5 @@
import type { ParserOptions, Quad } from "@ldo/rdf-utils";
import type { Quad } from "@rdfjs/types";
import type { ParserOptions } from "@ldo/rdf-utils";
import { createDatasetFromSerializedInput } from "@ldo/dataset";
import { createWrapperSubscribableDatasetFactory } from "./createWrapperSubscribableDataset";
import type WrapperSubscribableDataset from "./WrapperSubscribableDataset";

@ -1,9 +1,5 @@
import type {
Dataset,
BaseQuad,
DatasetChanges,
QuadMatch,
} from "@ldo/rdf-utils";
import type { DatasetChanges, QuadMatch } from "@ldo/rdf-utils";
import type { Dataset, BaseQuad } from "@rdfjs/types";
/**
* An event listeners for nodes

@ -1,10 +1,10 @@
import { namedNode, literal, quad } from "@ldo/rdf-utils";
import { namedNode, literal, quad } from "@rdfjs/data-model";
import type {
Dataset,
DatasetCoreFactory,
Quad,
DatasetCore,
} from "@ldo/rdf-utils";
} from "@rdfjs/types";
import type { BulkEditableDataset } from "../src";
import { ExtendedDatasetFactory } from "@ldo/dataset";
import { ProxyTransactionalDataset } from "../src";

@ -7,8 +7,8 @@ import {
quad,
defaultGraph,
blankNode,
} from "@ldo/rdf-utils";
import type { Quad, BlankNode } from "@ldo/rdf-utils";
} from "@rdfjs/data-model";
import type { Quad, BlankNode } from "@rdfjs/types";
import testDataset from "@ldo/dataset/test/dataset.testHelper";
describe("WrapperSubscribableDataset", () => {
@ -125,6 +125,19 @@ describe("WrapperSubscribableDataset", () => {
expect(callbackFuncTom.mock.calls[0][0].added).toBe(undefined);
});
it("Alerts when emit is called", () => {
const callbackFuncTom = jest.fn();
subscribableDatastet.on(
[namedNode("http://example.org/cartoons#Tom"), null, null, null],
callbackFuncTom,
);
subscribableDatastet.emit(
[namedNode("http://example.org/cartoons#Tom"), null, null, null],
{},
);
expect(callbackFuncTom.mock.calls[0][0]).toEqual({});
});
it("Alerts when bulk updated", () => {
const callbackFuncLicky = jest.fn();
const callbackFuncTom = jest.fn();
@ -229,7 +242,7 @@ describe("WrapperSubscribableDataset", () => {
expect(callbackFunc).toBeCalledTimes(1);
expect(
callbackFunc.mock.calls[0][0].added.equals(
createDataset([blankNodeQuadA, blankNodeAdditionA]),
createDataset([blankNodeAdditionA]),
),
).toBe(true);
});
@ -262,9 +275,9 @@ describe("WrapperSubscribableDataset", () => {
),
).toBe(true);
expect(
subscribableTerms.some(
(curQuadMatch) => curQuadMatch[3]?.equals(defaultGraph()),
),
subscribableTerms.some((curQuadMatch) => {
return curQuadMatch[3]?.equals(defaultGraph());
}),
).toBe(true);
});
@ -276,7 +289,7 @@ describe("WrapperSubscribableDataset", () => {
/* Do Nothing */
});
expect(() => subscribableDatastet.eventNames()).toThrowError(
"Invalid Subscription Key",
"Invalid Quad Match String",
);
});

Loading…
Cancel
Save