@itwin/presentation-core-interop 0.1.1 → 0.2.0

package/src/test/QueryExecutor.test.ts

@@ -1,217 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- * 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

@@ -1,74 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- * 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

@@ -1,17 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- * 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

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

package/tsconfig.esm.json

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

package/tsconfig.json

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