@itwin/presentation-core-interop 0.1.0

package/src/test/QueryExecutor.test.ts

@@ -0,0 +1,217 @@
+/*---------------------------------------------------------------------------------------------
+ * Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+ * See LICENSE.md in the project root for license terms and full copyright notice.
+ *--------------------------------------------------------------------------------------------*/
+
+import { expect } from "chai";
+import sinon from "sinon";
+import { QueryBinder, QueryOptions, QueryRowFormat } from "@itwin/core-common";
+import { Point2d, Point3d } from "@itwin/core-geometry";
+import { ECSqlBinding } from "@itwin/presentation-shared";
+import { createECSqlQueryExecutor } from "../core-interop/QueryExecutor";
+
+describe("createECSqlQueryExecutor", () => {
+  describe("createQueryReader", () => {
+    it("calls IModel's `createQueryReader` with default params", async () => {
+      const imodel = {
+        createQueryReader: sinon.stub().returns(createCoreECSqlReaderStub([{}, {}])),
+      };
+
+      const executor = createECSqlQueryExecutor(imodel);
+      const reader = executor.createQueryReader({ ecsql: "ecsql" });
+      for await (const _ of reader) {
+      }
+
+      // eslint-disable-next-line @typescript-eslint/unbound-method
+      expect(imodel.createQueryReader).to.be.calledOnceWithExactly(
+        "ecsql",
+        sinon.match((binder: QueryBinder) => Object.keys(binder.serialize()).length === 0),
+        sinon.match((options: QueryOptions) => Object.keys(options).length === 0),
+      );
+    });
+
+    it("calls IModel's `createQueryReader` with CTEs", async () => {
+      const imodel = {
+        createQueryReader: sinon.stub().returns(createCoreECSqlReaderStub([{}, {}])),
+      };
+
+      const executor = createECSqlQueryExecutor(imodel);
+      const reader = executor.createQueryReader({ ctes: ["cte1", "cte2"], ecsql: "ecsql" });
+      for await (const _ of reader) {
+      }
+
+      // eslint-disable-next-line @typescript-eslint/unbound-method
+      expect(imodel.createQueryReader).to.be.calledOnceWith("WITH RECURSIVE cte1, cte2 ecsql");
+    });
+
+    it("calls IModel's `createQueryReader` with `ECSqlPropertyNames` row format", async () => {
+      const imodel = {
+        createQueryReader: sinon.stub().returns(createCoreECSqlReaderStub([])),
+      };
+
+      const executor = createECSqlQueryExecutor(imodel);
+      const reader = executor.createQueryReader({ ecsql: "ecsql" }, { rowFormat: "ECSqlPropertyNames" });
+      for await (const _ of reader) {
+      }
+
+      // eslint-disable-next-line @typescript-eslint/unbound-method
+      expect(imodel.createQueryReader).to.be.calledOnceWithExactly(
+        "ecsql",
+        sinon.match((binder: QueryBinder) => Object.keys(binder.serialize()).length === 0),
+        sinon.match((options: QueryOptions) => options.rowFormat === QueryRowFormat.UseECSqlPropertyNames),
+      );
+    });
+
+    it("calls IModel's `createQueryReader` with `Indexes` row format", async () => {
+      const imodel = {
+        createQueryReader: sinon.stub().returns(createCoreECSqlReaderStub([])),
+      };
+
+      const executor = createECSqlQueryExecutor(imodel);
+      const reader = executor.createQueryReader({ ecsql: "ecsql" }, { rowFormat: "Indexes" });
+      for await (const _ of reader) {
+      }
+
+      // eslint-disable-next-line @typescript-eslint/unbound-method
+      expect(imodel.createQueryReader).to.be.calledOnceWithExactly(
+        "ecsql",
+        sinon.match((binder: QueryBinder) => Object.keys(binder.serialize()).length === 0),
+        sinon.match((options: QueryOptions) => options.rowFormat === QueryRowFormat.UseECSqlPropertyIndexes),
+      );
+    });
+
+    it("calls IModel's `createQueryReader` with different bindings", async () => {
+      const imodel = {
+        createQueryReader: sinon.stub().returns(createCoreECSqlReaderStub([])),
+      };
+
+      const bindings: ECSqlBinding[] = [
+        {
+          type: "boolean",
+          value: true,
+        },
+        {
+          type: "double",
+          value: 1.23,
+        },
+        {
+          type: "id",
+          value: "0x123",
+        },
+        {
+          type: "idset",
+          value: ["0x123", "0x456"],
+        },
+        {
+          type: "int",
+          value: 123,
+        },
+        { type: "long", value: 456 },
+        {
+          type: "point2d",
+          value: { x: 1.23, y: 4.56 },
+        },
+        {
+          type: "point3d",
+          value: { x: 1.23, y: 4.56, z: 7.89 },
+        },
+        {
+          type: "string",
+          value: "xxx",
+        },
+        {
+          type: "string",
+          value: undefined,
+        },
+      ];
+
+      const expectedBinder = new QueryBinder();
+      expectedBinder.bindBoolean(1, true);
+      expectedBinder.bindDouble(2, 1.23);
+      expectedBinder.bindId(3, "0x123");
+      expectedBinder.bindIdSet(4, ["0x123", "0x456"]);
+      expectedBinder.bindInt(5, 123);
+      expectedBinder.bindLong(6, 456);
+      expectedBinder.bindPoint2d(7, Point2d.create(1.23, 4.56));
+      expectedBinder.bindPoint3d(8, Point3d.create(1.23, 4.56, 7.89));
+      expectedBinder.bindString(9, "xxx");
+      expectedBinder.bindNull(10);
+
+      const executor = createECSqlQueryExecutor(imodel);
+      const reader = executor.createQueryReader({ ecsql: "ecsql", bindings }, undefined);
+      for await (const _ of reader) {
+      }
+
+      // eslint-disable-next-line @typescript-eslint/unbound-method
+      expect(imodel.createQueryReader).to.be.calledOnceWithExactly(
+        "ecsql",
+        sinon.match((binder: QueryBinder) => JSON.stringify(expectedBinder.serialize()) === JSON.stringify(binder.serialize())),
+        sinon.match((options: QueryOptions) => Object.keys(options).length === 0),
+      );
+    });
+
+    it("creates iterable reader for rows as objects", async () => {
+      const rows = [{ x: 1 }, { y: 2 }];
+      const imodel = {
+        createQueryReader: sinon.stub().returns(createCoreECSqlReaderStub(rows)),
+      };
+
+      const executor = createECSqlQueryExecutor(imodel);
+      const reader = executor.createQueryReader({ ecsql: "ecsql" }, { rowFormat: "ECSqlPropertyNames" });
+
+      const resultRows = new Array<any>();
+      for await (const row of reader) {
+        resultRows.push(row);
+      }
+
+      expect(resultRows).to.deep.eq(rows);
+    });
+
+    it("creates iterable reader for rows as arrays", async () => {
+      const rows = [
+        [1, 2],
+        [3, 4],
+      ];
+      const imodel = {
+        createQueryReader: sinon.stub().returns(createCoreECSqlReaderStub(rows)),
+      };
+
+      const executor = createECSqlQueryExecutor(imodel);
+      const reader = executor.createQueryReader({ ecsql: "ecsql" }, { rowFormat: "Indexes" });
+
+      const resultRows = new Array<any>();
+      for await (const row of reader) {
+        resultRows.push(row);
+      }
+
+      expect(resultRows).to.deep.eq(rows);
+    });
+  });
+});
+
+function createCoreECSqlReaderStub(rows: object[]) {
+  let curr = -1;
+  const reader = {
+    next: sinon.fake(async () => {
+      ++curr;
+      if (curr < rows.length) {
+        return { done: false, value: createQueryRowProxy(rows[curr]) };
+      }
+      return { done: true, value: undefined };
+    }),
+  };
+  return {
+    ...reader,
+    async *[Symbol.asyncIterator]() {
+      return reader;
+    },
+  };
+}
+
+function createQueryRowProxy(data: object) {
+  return {
+    ...data,
+    toArray: () => data,
+    toRow: () => data,
+  };
+}

package/src/test/Transactions.test.ts

@@ -0,0 +1,74 @@
+/*---------------------------------------------------------------------------------------------
+ * Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+ * See LICENSE.md in the project root for license terms and full copyright notice.
+ *--------------------------------------------------------------------------------------------*/
+
+import { expect } from "chai";
+import sinon from "sinon";
+import { registerTxnListeners } from "../core-interop/Transactions";
+
+describe("registerTxnListeners", () => {
+  it("calls provided callback on `onAppliedChanges` event", async () => {
+    const txns = createCoreTxnManager();
+    const callback = sinon.stub();
+    registerTxnListeners(txns, callback);
+    expect(txns.onChangesApplied.addListener).to.be.calledOnce;
+    txns.onChangesApplied.addListener.firstCall.callArg(0);
+    expect(callback).to.be.calledOnce;
+  });
+
+  it("calls provided callback on `onCommit` and `onCommitted` event", async () => {
+    const txns = createCoreTxnManager();
+    const callback = sinon.stub();
+    registerTxnListeners(txns, callback);
+    expect(txns.onCommit.addListener).to.be.calledOnce;
+    expect(txns.onCommitted.addListener).to.be.calledOnce;
+    txns.onCommit.addListener.firstCall.callArg(0);
+    txns.onCommitted.addListener.firstCall.callArg(0);
+    expect(callback).to.be.calledOnce;
+  });
+
+  it("doesn't call provided callback on `onCommitted` event if there was no `onCommit` event", async () => {
+    const txns = createCoreTxnManager();
+    const callback = sinon.stub();
+    registerTxnListeners(txns, callback);
+    expect(txns.onCommit.addListener).to.be.calledOnce;
+    expect(txns.onCommitted.addListener).to.be.calledOnce;
+    txns.onCommitted.addListener.firstCall.callArg(0);
+    expect(callback).to.not.be.called;
+  });
+
+  it("unregisters from events when returned function is called", async () => {
+    const txns = createCoreTxnManager();
+    const unregister = registerTxnListeners(txns, sinon.stub());
+    expect(txns.onCommit.hasListeners()).to.be.true;
+    expect(txns.onCommitted.hasListeners()).to.be.true;
+    expect(txns.onChangesApplied.hasListeners()).to.be.true;
+    unregister();
+    expect(txns.onCommit.hasListeners()).to.be.false;
+    expect(txns.onCommitted.hasListeners()).to.be.false;
+    expect(txns.onChangesApplied.hasListeners()).to.be.false;
+  });
+
+  function createCoreTxnManager() {
+    return {
+      onCommit: createEventStub(),
+      onCommitted: createEventStub(),
+      onChangesApplied: createEventStub(),
+    };
+  }
+
+  function createEventStub() {
+    let hasListeners = false;
+    return {
+      hasListeners: () => hasListeners,
+      addListener: sinon.fake(() => {
+        hasListeners = true;
+        return () => {
+          hasListeners = false;
+        };
+      }),
+      removeListener: sinon.stub(),
+    };
+  }
+});

package/src/test/index.ts

@@ -0,0 +1,17 @@
+/*---------------------------------------------------------------------------------------------
+ * Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+ * See LICENSE.md in the project root for license terms and full copyright notice.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as chai from "chai";
+import chaiAsPromised from "chai-as-promised";
+import sinon from "sinon";
+import sinonChai from "sinon-chai";
+
+// setup chai
+chai.use(chaiAsPromised);
+chai.use(sinonChai);
+
+beforeEach(function () {
+  sinon.restore();
+});

package/tsconfig.cjs.json

@@ -0,0 +1,7 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "module": "CommonJS",
+    "outDir": "lib/cjs"
+  }
+}

package/tsconfig.esm.json

@@ -0,0 +1,7 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "module": "ES2020",
+    "outDir": "lib/esm"
+  }
+}

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "sourceMap": true,
+    "esModuleInterop": true,
+    "inlineSources": true,
+    "declaration": true,
+    "declarationMap": true,
+    "allowSyntheticDefaultImports": true,
+    "resolveJsonModule": true,
+    "lib": ["ES2022"]
+  },
+  "include": ["src"]
+}