@itwin/map-layers-formats 4.1.0-dev.51 → 4.1.0-dev.56

package/lib/cjs/test/ArcGisFeature/ArcGisFeatureProvider.test.js

@@ -1,812 +0,0 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
-Object.defineProperty(exports, "__esModule", { value: true });
-const core_common_1 = require("@itwin/core-common");
-const chai = require("chai");
-const chaiAsPromised = require("chai-as-promised");
-const ArcGisFeatureFormat_1 = require("../../ArcGisFeature/ArcGisFeatureFormat");
-const map_layers_formats_1 = require("../../map-layers-formats");
-const sinon = require("sinon");
-const core_frontend_1 = require("@itwin/core-frontend");
-const NewYorkDataset_1 = require("./NewYorkDataset");
-const core_bentley_1 = require("@itwin/core-bentley");
-const PhillyLandmarksDataset_1 = require("./PhillyLandmarksDataset");
-const ArcGisFeatureResponse_1 = require("../../ArcGisFeature/ArcGisFeatureResponse");
-const core_geometry_1 = require("@itwin/core-geometry");
-const ArcGisFeaturePBF_1 = require("../../ArcGisFeature/ArcGisFeaturePBF");
-const ArcGisFeatureJSON_1 = require("../../ArcGisFeature/ArcGisFeatureJSON");
-const expect = chai.expect;
-chai.use(chaiAsPromised);
-const esriFeatureSampleSource = { name: "dummyFeatureLayer", url: "https://dummy.com/SomeGuid/ArcGIS/rest/services/SomeService/FeatureServer", formatId: ArcGisFeatureFormat_1.ArcGisFeatureMapLayerFormat.formatId };
-const pngTransparent1x1 = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==";
-describe("ArcGisFeatureProvider", () => {
-    const sandbox = sinon.createSandbox();
-    let fetchStub;
-    beforeEach(async () => {
-        // Make sure no call to fetch is made, other it creates leaks
-        fetchStub = sandbox.stub(core_frontend_1.ArcGISImageryProvider.prototype, "fetch");
-    });
-    afterEach(async () => {
-        sandbox.restore();
-    });
-    it("should initialize with valid service metadata", async () => {
-        sandbox.stub(core_frontend_1.ArcGisUtilities, "getServiceJson").callsFake(async function _(_url, _formatId, _userName, _password, _ignoreCache, _requireToken) {
-            return { accessTokenRequired: false, content: NewYorkDataset_1.NewYorkDataset.serviceCapabilities };
-        });
-        sandbox.stub(map_layers_formats_1.ArcGisFeatureProvider.prototype, "getLayerMetadata").callsFake(async function _(_layerId) {
-            return NewYorkDataset_1.NewYorkDataset.streetsLayerCapabilities;
-        });
-        const settings = core_common_1.ImageMapLayerSettings.fromJSON(esriFeatureSampleSource);
-        const provider = new map_layers_formats_1.ArcGisFeatureProvider(settings);
-        await provider.initialize();
-        expect(provider._minDepthFromLod).to.equals(11);
-        expect(provider._maxDepthFromLod).to.equals(22);
-    });
-    it("should initialize and set cartoRange without making extra extent request", async () => {
-        sandbox.stub(core_frontend_1.ArcGisUtilities, "getServiceJson").callsFake(async function _(_url, _formatId, _userName, _password, _ignoreCache, _requireToken) {
-            return { accessTokenRequired: false, content: NewYorkDataset_1.NewYorkDataset.serviceCapabilities };
-        });
-        sandbox.stub(map_layers_formats_1.ArcGisFeatureProvider.prototype, "getLayerMetadata").callsFake(async function _(_layerId) {
-            return NewYorkDataset_1.NewYorkDataset.streetsLayerCapabilities;
-        });
-        const setCartoSpy = sandbox.spy(map_layers_formats_1.ArcGisFeatureProvider.prototype, "setCartoRangeFromExtentJson");
-        const fetchLayerExtentSpy = sandbox.spy(map_layers_formats_1.ArcGisFeatureProvider.prototype, "fetchLayerExtent");
-        const settings = core_common_1.ImageMapLayerSettings.fromJSON(esriFeatureSampleSource);
-        const provider = new map_layers_formats_1.ArcGisFeatureProvider(settings);
-        await provider.initialize();
-        expect(setCartoSpy.called).to.be.true;
-        expect(setCartoSpy.args[0][0]).to.be.equals(NewYorkDataset_1.NewYorkDataset.streetsLayerCapabilities.extent);
-        expect(fetchLayerExtentSpy.called).to.be.false;
-    });
-    it("should make an extra extent request when none available in layer metadata", async () => {
-        sandbox.stub(core_frontend_1.ArcGisUtilities, "getServiceJson").callsFake(async function _(_url, _formatId, _userName, _password, _ignoreCache, _requireToken) {
-            return { accessTokenRequired: false, content: NewYorkDataset_1.NewYorkDataset.serviceCapabilities };
-        });
-        const setCartoSpy = sandbox.spy(map_layers_formats_1.ArcGisFeatureProvider.prototype, "setCartoRangeFromExtentJson");
-        const layerExtent = { ...NewYorkDataset_1.NewYorkDataset.streetsLayerCapabilities.extent };
-        const fetchLayerExtentStub = sandbox.stub(map_layers_formats_1.ArcGisFeatureProvider.prototype, "fetchLayerExtent").callsFake(async function _(_layerId) {
-            return layerExtent;
-        });
-        const layerCapabilitiesNoExtent = { ...NewYorkDataset_1.NewYorkDataset.streetsLayerCapabilities, extent: null };
-        sandbox.stub(map_layers_formats_1.ArcGisFeatureProvider.prototype, "getLayerMetadata").callsFake(async function _(_layerId) {
-            return layerCapabilitiesNoExtent;
-        });
-        const settings = core_common_1.ImageMapLayerSettings.fromJSON(esriFeatureSampleSource);
-        const provider = new map_layers_formats_1.ArcGisFeatureProvider(settings);
-        await provider.initialize();
-        expect(fetchLayerExtentStub.called).to.be.true;
-        expect(setCartoSpy.called).to.be.true;
-        expect(setCartoSpy.args[0][0]).to.be.equals(layerExtent);
-    });
-    it("should make an extra extent request when none available in layer metadata", async () => {
-        sandbox.stub(core_frontend_1.ArcGisUtilities, "getServiceJson").callsFake(async function _(_url, _formatId, _userName, _password, _ignoreCache, _requireToken) {
-            return { accessTokenRequired: false, content: NewYorkDataset_1.NewYorkDataset.serviceCapabilities };
-        });
-        const setCartoSpy = sandbox.spy(map_layers_formats_1.ArcGisFeatureProvider.prototype, "setCartoRangeFromExtentJson");
-        const layerExtent = { ...NewYorkDataset_1.NewYorkDataset.streetsLayerCapabilities.extent };
-        const fetchLayerExtentStub = sandbox.stub(map_layers_formats_1.ArcGisFeatureProvider.prototype, "fetchLayerExtent").callsFake(async function _(_layerId) {
-            return layerExtent;
-        });
-        const layerExtentBadSrs = { ...NewYorkDataset_1.NewYorkDataset.streetsLayerCapabilities };
-        layerExtentBadSrs.extent.spatialReference.wkid = 1234;
-        layerExtentBadSrs.extent.spatialReference.latestWkid = 1234;
-        sandbox.stub(map_layers_formats_1.ArcGisFeatureProvider.prototype, "getLayerMetadata").callsFake(async function _(_layerId) {
-            return layerExtentBadSrs;
-        });
-        const settings = core_common_1.ImageMapLayerSettings.fromJSON(esriFeatureSampleSource);
-        const provider = new map_layers_formats_1.ArcGisFeatureProvider(settings);
-        await provider.initialize();
-        expect(fetchLayerExtentStub.called).to.be.true;
-        expect(setCartoSpy.called).to.be.true;
-        expect(setCartoSpy.args[0][0]).to.be.equals(layerExtent);
-    });
-    it("should set cartoRange from Extent json", async () => {
-        const newYorkLayerExtent = NewYorkDataset_1.NewYorkDataset.streetsLayerCapabilities.extent;
-        const settings = core_common_1.ImageMapLayerSettings.fromJSON(esriFeatureSampleSource);
-        const provider = new map_layers_formats_1.ArcGisFeatureProvider(settings);
-        const west = provider.getEPSG4326Lon(newYorkLayerExtent.xmin);
-        const south = provider.getEPSG4326Lat(newYorkLayerExtent.ymin);
-        const east = provider.getEPSG4326Lon(newYorkLayerExtent.xmax);
-        const north = provider.getEPSG4326Lat(newYorkLayerExtent.ymax);
-        provider.setCartoRangeFromExtentJson(newYorkLayerExtent);
-        expect(provider.cartoRange).to.be.not.undefined;
-        const delta = 0.0000001;
-        expect(provider.cartoRange.west * core_geometry_1.Angle.degreesPerRadian).to.approximately(west, delta);
-        expect(provider.cartoRange.south * core_geometry_1.Angle.degreesPerRadian).to.approximately(south, delta);
-        expect(provider.cartoRange.east * core_geometry_1.Angle.degreesPerRadian).to.approximately(east, delta);
-        expect(provider.cartoRange.north * core_geometry_1.Angle.degreesPerRadian).to.approximately(north, delta);
-    });
-    it("should compose proper request to get extent", async () => {
-        fetchStub.restore(); // fetch is always stubbed by default, restore and provide our own stub
-        sandbox.stub(core_frontend_1.ArcGisUtilities, "getServiceJson").callsFake(async function _(_url, _formatId, _userName, _password, _ignoreCache, _requireToken) {
-            return { accessTokenRequired: false, content: NewYorkDataset_1.NewYorkDataset.serviceCapabilities };
-        });
-        const layerCapabilitiesNoExtent = { ...NewYorkDataset_1.NewYorkDataset.streetsLayerCapabilities };
-        sandbox.stub(map_layers_formats_1.ArcGisFeatureProvider.prototype, "getLayerMetadata").callsFake(async function _(_layerId) {
-            return layerCapabilitiesNoExtent;
-        });
-        const referenceExtent = { extent: NewYorkDataset_1.NewYorkDataset.streetsLayerCapabilities.extent };
-        const stub = sandbox.stub(core_frontend_1.ArcGISImageryProvider.prototype, "fetch").callsFake(async function _(_url, _options) {
-            const test = {
-                headers: { "content-type": "json" },
-                json: async () => {
-                    return referenceExtent;
-                },
-                status: 200,
-            }; // By using unknown type, I can define parts of Response I really need
-            return test;
-        });
-        let layerId = 0;
-        let expectedUrl = `https://dummy.com/SomeGuid/ArcGIS/rest/services/SomeService/FeatureServer/${layerId}/query?where=1%3D1&outSR=3857&returnExtentOnly=true&f=json`;
-        let cachedExtent = map_layers_formats_1.ArcGisFeatureProvider._extentCache.get(expectedUrl);
-        expect(cachedExtent).to.be.undefined;
-        const settings = core_common_1.ImageMapLayerSettings.fromJSON(esriFeatureSampleSource);
-        const provider = new map_layers_formats_1.ArcGisFeatureProvider(settings);
-        await provider.initialize();
-        let fetchExtent = await provider.fetchLayerExtent();
-        expect(fetchExtent).to.equals(referenceExtent.extent);
-        expect(stub.getCalls().length).to.equals(1);
-        expect(stub.args[0][0].toString()).to.be.equals(expectedUrl);
-        // Check if entry has been created in cache
-        cachedExtent = map_layers_formats_1.ArcGisFeatureProvider._extentCache.get(expectedUrl);
-        expect(cachedExtent).to.be.not.undefined;
-        expect(cachedExtent).to.equals(referenceExtent);
-        // Make sure cache is used
-        await provider.fetchLayerExtent();
-        expect(stub.getCalls().length).to.equals(1);
-        // Force a different layerId, and check a new request has been made
-        layerId = 2;
-        expectedUrl = `https://dummy.com/SomeGuid/ArcGIS/rest/services/SomeService/FeatureServer/${layerId}/query?where=1%3D1&outSR=3857&returnExtentOnly=true&f=json`;
-        cachedExtent = map_layers_formats_1.ArcGisFeatureProvider._extentCache.get(expectedUrl);
-        expect(cachedExtent).to.be.undefined;
-        provider._layerId = layerId;
-        fetchExtent = await provider.fetchLayerExtent();
-        expect(fetchExtent).to.equals(referenceExtent.extent);
-        expect(stub.getCalls().length).to.equals(2);
-        expect(stub.args[1][0].toString()).to.be.equals(expectedUrl);
-        // check cache has been updated with a new entry
-        cachedExtent = map_layers_formats_1.ArcGisFeatureProvider._extentCache.get(expectedUrl);
-        expect(cachedExtent).to.be.not.undefined;
-        expect(cachedExtent).to.equals(referenceExtent);
-    });
-    it("should not initialize with no service metadata", async () => {
-        sandbox.stub(core_frontend_1.ArcGisUtilities, "getServiceJson").callsFake(async function _(_url, _formatId, _userName, _password, _ignoreCache, _requireToken) {
-            return undefined;
-        });
-        const settings = core_common_1.ImageMapLayerSettings.fromJSON(esriFeatureSampleSource);
-        const provider = new map_layers_formats_1.ArcGisFeatureProvider(settings);
-        await expect(provider.initialize()).to.be.rejectedWith(core_common_1.ServerError);
-    });
-    it("should update status when invalid token error from service", async () => {
-        sandbox.stub(core_frontend_1.ArcGisUtilities, "getServiceJson").callsFake(async function _(_url, _formatId, _userName, _password, _ignoreCache, _requireToken) {
-            return { accessTokenRequired: false, content: { error: { code: 499 } } };
-        });
-        const settings = core_common_1.ImageMapLayerSettings.fromJSON(esriFeatureSampleSource);
-        const provider = new map_layers_formats_1.ArcGisFeatureProvider(settings);
-        const raiseEventSpy = sandbox.spy(provider.onStatusChanged, "raiseEvent");
-        await provider.initialize();
-        expect(provider.status).to.equals(core_frontend_1.MapLayerImageryProviderStatus.RequireAuth);
-        expect(raiseEventSpy.calledOnceWith(provider)).to.be.true;
-    });
-    it("should throw    query capability not supported", async () => {
-        sandbox.stub(core_frontend_1.ArcGisUtilities, "getServiceJson").callsFake(async function _(_url, _formatId, _userName, _password, _ignoreCache, _requireToken) {
-            return { accessTokenRequired: false, content: { capabilities: "Test" } };
-        });
-        const settings = core_common_1.ImageMapLayerSettings.fromJSON(esriFeatureSampleSource);
-        const provider = new map_layers_formats_1.ArcGisFeatureProvider(settings);
-        await expect(provider.initialize()).to.be.rejectedWith(core_common_1.ServerError);
-    });
-    it("should pick the first visible sub-layer when multiple visible sub-layers", async () => {
-        sandbox.stub(core_frontend_1.ArcGisUtilities, "getServiceJson").callsFake(async function _(_url, _formatId, _userName, _password, _ignoreCache, _requireToken) {
-            return { accessTokenRequired: false, content: { capabilities: "Query" } };
-        });
-        const settings = core_common_1.ImageMapLayerSettings.fromJSON({
-            ...esriFeatureSampleSource,
-            subLayers: [{ id: 0, name: "layer1", visible: true }, { id: 2, name: "layer2", visible: true }]
-        });
-        const provider = new map_layers_formats_1.ArcGisFeatureProvider(settings);
-        provider._format = "JSON";
-        await provider.initialize();
-        expect(provider._layerId).to.equals(settings.subLayers[0].id);
-    });
-    it("should pick sub-layers from service metadata if none provided on layer settings", async () => {
-        sandbox.stub(core_frontend_1.ArcGisUtilities, "getServiceJson").callsFake(async function _(_url, _formatId, _userName, _password, _ignoreCache, _requireToken) {
-            return { accessTokenRequired: false, content: { capabilities: "Query",
-                    layers: [
-                        {
-                            id: 0,
-                        },
-                        {
-                            id: 1,
-                        },
-                    ] },
-            };
-        });
-        sandbox.stub(map_layers_formats_1.ArcGisFeatureProvider.prototype, "getLayerMetadata").callsFake(async function (id) {
-            if (id === 1) {
-                return { defaultVisibility: true };
-            }
-            return undefined;
-        });
-        const settings = core_common_1.ImageMapLayerSettings.fromJSON(esriFeatureSampleSource);
-        const provider = new map_layers_formats_1.ArcGisFeatureProvider(settings);
-        provider._format = "JSON";
-        await provider.initialize();
-        expect(provider._layerId).to.equals(1);
-        expect(provider._layerMetadata).to.eql({ defaultVisibility: true });
-    });
-    it("should throw error if no layers in capabilities", async () => {
-        sandbox.stub(core_frontend_1.ArcGisUtilities, "getServiceJson").callsFake(async function _(_url, _formatId, _userName, _password, _ignoreCache, _requireToken) {
-            return { accessTokenRequired: false, content: { capabilities: "Query", layers: [] } };
-        });
-        const settings = core_common_1.ImageMapLayerSettings.fromJSON(esriFeatureSampleSource);
-        const provider = new map_layers_formats_1.ArcGisFeatureProvider(settings);
-        await expect(provider.initialize()).to.be.rejectedWith(core_common_1.ServerError);
-    });
-    it("should throw if no layer metadata from service", async () => {
-        const settings = core_common_1.ImageMapLayerSettings.fromJSON({
-            ...esriFeatureSampleSource,
-            subLayers: [{ id: 0, name: "layer1", visible: true }, { id: 2, name: "layer2", visible: true }]
-        });
-        sandbox.stub(core_frontend_1.ArcGisUtilities, "getServiceJson").callsFake(async function _(_url, _formatId, _userName, _password, _ignoreCache, _requireToken) {
-            return { accessTokenRequired: false, content: { capabilities: "Query" } };
-        });
-        sandbox.stub(map_layers_formats_1.ArcGisFeatureProvider.prototype, "getLayerMetadata").callsFake(async function (_id) {
-            return undefined;
-        });
-        const provider = new map_layers_formats_1.ArcGisFeatureProvider(settings);
-        await expect(provider.initialize()).to.be.rejectedWith(core_common_1.ServerError);
-    });
-    it("should read supported supported format", async () => {
-        const settings = core_common_1.ImageMapLayerSettings.fromJSON({
-            ...esriFeatureSampleSource,
-            subLayers: [{ id: 0, name: "layer1", visible: true }, { id: 2, name: "layer2", visible: true }]
-        });
-        let getLayerMetadataStub = sandbox.stub(map_layers_formats_1.ArcGisFeatureProvider.prototype, "getLayerMetadata").callsFake(async function (_id) {
-            return { defaultVisibility: true, supportedQueryFormats: "PBF, JSON" };
-        });
-        const getServiceJsonStub = sandbox.stub(core_frontend_1.ArcGisUtilities, "getServiceJson").callsFake(async function _(_url, _formatId, _userName, _password, _ignoreCache, _requireToken) {
-            return { accessTokenRequired: false, content: { capabilities: "Query" } };
-        });
-        let provider = new map_layers_formats_1.ArcGisFeatureProvider(settings);
-        await provider.initialize();
-        expect(provider.format).to.equals("JSON");
-        // PBF requires 'supportsCoordinatesQuantization'
-        getServiceJsonStub.restore();
-        sandbox.stub(core_frontend_1.ArcGisUtilities, "getServiceJson").callsFake(async function _(_url, _formatId, _userName, _password, _ignoreCache, _requireToken) {
-            return { accessTokenRequired: false, content: { currentVersion: 11, capabilities: "Query" } };
-        });
-        getLayerMetadataStub.restore();
-        getLayerMetadataStub = sandbox.stub(map_layers_formats_1.ArcGisFeatureProvider.prototype, "getLayerMetadata").callsFake(async function (_id) {
-            return { defaultVisibility: true, supportsCoordinatesQuantization: true, supportedQueryFormats: "PBF, JSON" };
-        });
-        provider = new map_layers_formats_1.ArcGisFeatureProvider(settings);
-        await provider.initialize();
-        expect(provider.format).to.equals("PBF");
-        getLayerMetadataStub.restore();
-        getLayerMetadataStub = sandbox.stub(map_layers_formats_1.ArcGisFeatureProvider.prototype, "getLayerMetadata").callsFake(async function (_id) {
-            return { defaultVisibility: true, supportedQueryFormats: "JSON" };
-        });
-        getServiceJsonStub.restore();
-        sandbox.stub(core_frontend_1.ArcGisUtilities, "getServiceJson").callsFake(async function _(_url, _formatId, _userName, _password, _ignoreCache, _requireToken) {
-            return { accessTokenRequired: false, content: { currentVersion: 10.91, capabilities: "Query", supportsCoordinatesQuantization: true } };
-        });
-        provider = new map_layers_formats_1.ArcGisFeatureProvider(settings);
-        await provider.initialize();
-        expect(provider.format).to.equals("JSON");
-        getLayerMetadataStub.restore();
-        getLayerMetadataStub = sandbox.stub(map_layers_formats_1.ArcGisFeatureProvider.prototype, "getLayerMetadata").callsFake(async function (_id) {
-            return { defaultVisibility: true, supportedQueryFormats: "JSON" };
-        });
-        provider = new map_layers_formats_1.ArcGisFeatureProvider(settings);
-        await provider.initialize();
-        expect(provider.format).to.equals("JSON");
-        getLayerMetadataStub.restore();
-        getLayerMetadataStub = sandbox.stub(map_layers_formats_1.ArcGisFeatureProvider.prototype, "getLayerMetadata").callsFake(async function (_id) {
-            return { defaultVisibility: true, supportedQueryFormats: "" };
-        });
-        provider = new map_layers_formats_1.ArcGisFeatureProvider(settings);
-        await expect(provider.initialize()).to.be.rejectedWith(core_common_1.ServerError);
-    });
-    it("should compute minLod/maxLod", async () => {
-        const settings = core_common_1.ImageMapLayerSettings.fromJSON({
-            ...esriFeatureSampleSource,
-            subLayers: [{ id: 0, name: "layer1", visible: true }, { id: 2, name: "layer2", visible: true }]
-        });
-        sandbox.stub(map_layers_formats_1.ArcGisFeatureProvider.prototype, "getLayerMetadata").callsFake(async function (_id) {
-            return {
-                defaultVisibility: true,
-                supportedQueryFormats: "PBF, JSON",
-                minScale: 600000,
-                maxScale: 5000,
-            };
-        });
-        sandbox.stub(core_frontend_1.ArcGisUtilities, "getServiceJson").callsFake(async function _(_url, _formatId, _userName, _password, _ignoreCache, _requireToken) {
-            return { accessTokenRequired: false, content: { capabilities: "Query" } };
-        });
-        const provider = new map_layers_formats_1.ArcGisFeatureProvider(settings);
-        await provider.initialize();
-        expect(provider._minDepthFromLod).to.equals(9);
-        expect(provider._maxDepthFromLod).to.equals(15);
-    });
-    it("should construct empty url", async () => {
-        const settings = core_common_1.ImageMapLayerSettings.fromJSON(esriFeatureSampleSource);
-        const provider = new map_layers_formats_1.ArcGisFeatureProvider(settings);
-        const url = await provider.constructUrl(0, 0, 0);
-        expect(url).to.equals("");
-    });
-    it("should construct feature query url", async () => {
-        const settings = core_common_1.ImageMapLayerSettings.fromJSON({
-            ...esriFeatureSampleSource,
-            subLayers: [{ id: 0, name: "layer1", visible: true }, { id: 2, name: "layer2", visible: true }]
-        });
-        let getLayerMetadataStub = sandbox.stub(map_layers_formats_1.ArcGisFeatureProvider.prototype, "getLayerMetadata").callsFake(async function (_id) {
-            return {
-                defaultVisibility: true,
-                supportedQueryFormats: "PBF, JSON",
-            };
-        });
-        sandbox.stub(core_frontend_1.ArcGisUtilities, "getServiceJson").callsFake(async function _(_url, _formatId, _userName, _password, _ignoreCache, _requireToken) {
-            return { accessTokenRequired: false, content: { currentVersion: 11, capabilities: "Query" } };
-        });
-        const provider = new map_layers_formats_1.ArcGisFeatureProvider(settings);
-        await provider.initialize();
-        let url = provider.constructFeatureUrl(0, 0, 0, "PBF");
-        const extent = {
-            xmin: -20037508.34,
-            ymin: -20037508.33,
-            xmax: 20037508.34,
-            ymax: 20037508.34,
-            spatialReference: {
-                wkid: 102100,
-                latestWkid: 3857,
-            },
-        };
-        expect(url?.url).to.equals("https://dummy.com/SomeGuid/ArcGIS/rest/services/SomeService/FeatureServer/0/query?f=PBF&resultType=tile&maxRecordCountFactor=3&returnExceededLimitFeatures=false&outSR=102100&geometryType=esriGeometryEnvelope&geometry=%7B%22xmin%22%3A-20037508.34%2C%22ymin%22%3A-20037508.339999996%2C%22xmax%22%3A20037508.34%2C%22ymax%22%3A20037508.340000004%2C%22spatialReference%22%3A%7B%22wkid%22%3A102100%2C%22latestWkid%22%3A3857%7D%7D&units=esriSRUnit_Meter&inSR=102100");
-        expect(url?.envelope?.xmin).to.be.closeTo(extent.xmin, 0.01);
-        expect(url?.envelope?.ymin).to.be.closeTo(extent.ymin, 0.01);
-        expect(url?.envelope?.xmax).to.be.closeTo(extent.xmax, 0.01);
-        expect(url?.envelope?.ymax).to.be.closeTo(extent.ymax, 0.01);
-        expect(url?.envelope?.spatialReference.wkid).to.be.equal(102100);
-        expect(url?.envelope?.spatialReference.latestWkid).to.be.equal(3857);
-        // Now turn ON 'supportsCoordinatesQuantization' to ON
-        getLayerMetadataStub.restore();
-        getLayerMetadataStub = sandbox.stub(map_layers_formats_1.ArcGisFeatureProvider.prototype, "getLayerMetadata").callsFake(async function (_id) {
-            return {
-                defaultVisibility: true,
-                supportedQueryFormats: "PBF, JSON",
-                supportsCoordinatesQuantization: true,
-            };
-        });
-        const provider2 = new map_layers_formats_1.ArcGisFeatureProvider(settings);
-        await provider2.initialize();
-        url = provider2.constructFeatureUrl(0, 0, 0, "PBF");
-        expect(url?.url).to.equals("https://dummy.com/SomeGuid/ArcGIS/rest/services/SomeService/FeatureServer/0/query?f=PBF&resultType=tile&maxRecordCountFactor=3&returnExceededLimitFeatures=false&outSR=102100&geometryType=esriGeometryEnvelope&geometry=%7B%22xmin%22%3A-20037508.34%2C%22ymin%22%3A-20037508.339999996%2C%22xmax%22%3A20037508.34%2C%22ymax%22%3A20037508.340000004%2C%22spatialReference%22%3A%7B%22wkid%22%3A102100%2C%22latestWkid%22%3A3857%7D%7D&units=esriSRUnit_Meter&inSR=102100&quantizationParameters=%7B%22mode%22%3A%22view%22%2C%22originPosition%22%3A%22upperLeft%22%2C%22tolerance%22%3A78271.516953125%2C%22extent%22%3A%7B%22xmin%22%3A-20037508.34%2C%22ymin%22%3A-20037508.339999996%2C%22xmax%22%3A20037508.34%2C%22ymax%22%3A20037508.340000004%2C%22spatialReference%22%3A%7B%22wkid%22%3A102100%2C%22latestWkid%22%3A3857%7D%7D%7D");
-        expect(url?.envelope?.xmin).to.be.closeTo(extent.xmin, 0.01);
-        expect(url?.envelope?.ymin).to.be.closeTo(extent.ymin, 0.01);
-        expect(url?.envelope?.xmax).to.be.closeTo(extent.xmax, 0.01);
-        expect(url?.envelope?.ymax).to.be.closeTo(extent.ymax, 0.01);
-        expect(url?.envelope?.spatialReference.wkid).to.be.equal(extent.spatialReference.wkid);
-        expect(url?.envelope?.spatialReference.latestWkid).to.be.equal(extent.spatialReference.latestWkid);
-        // Test passing an override geometry
-        const overrideGeom = {
-            type: "esriGeometryEnvelope",
-            geom: {
-                xmin: -50,
-                ymin: -50,
-                xmax: 50,
-                ymax: 50,
-                spatialReference: {
-                    wkid: 102100,
-                    latestWkid: 3857,
-                },
-            },
-        };
-        const provider3 = new map_layers_formats_1.ArcGisFeatureProvider(settings);
-        await provider3.initialize();
-        url = provider3.constructFeatureUrl(0, 0, 0, "PBF", overrideGeom);
-        expect(url?.url).to.equals("https://dummy.com/SomeGuid/ArcGIS/rest/services/SomeService/FeatureServer/0/query?f=PBF&resultType=tile&maxRecordCountFactor=3&returnExceededLimitFeatures=false&outSR=102100&geometryType=esriGeometryEnvelope&geometry=%7B%22xmin%22%3A-50%2C%22ymin%22%3A-50%2C%22xmax%22%3A50%2C%22ymax%22%3A50%2C%22spatialReference%22%3A%7B%22wkid%22%3A102100%2C%22latestWkid%22%3A3857%7D%7D&units=esriSRUnit_Meter&inSR=102100&quantizationParameters=%7B%22mode%22%3A%22view%22%2C%22originPosition%22%3A%22upperLeft%22%2C%22tolerance%22%3A78271.516953125%2C%22extent%22%3A%7B%22xmin%22%3A-20037508.34%2C%22ymin%22%3A-20037508.339999996%2C%22xmax%22%3A20037508.34%2C%22ymax%22%3A20037508.340000004%2C%22spatialReference%22%3A%7B%22wkid%22%3A102100%2C%22latestWkid%22%3A3857%7D%7D%7D");
-        expect(url?.envelope?.xmin).to.be.closeTo(overrideGeom.geom.xmin, 0.01);
-        expect(url?.envelope?.ymin).to.be.closeTo(overrideGeom.geom.ymin, 0.01);
-        expect(url?.envelope?.xmax).to.be.closeTo(overrideGeom.geom.xmax, 0.01);
-        expect(url?.envelope?.ymax).to.be.closeTo(overrideGeom.geom.ymax, 0.01);
-        expect(url?.envelope?.spatialReference.wkid).to.be.equal(overrideGeom.geom.spatialReference.wkid);
-        expect(url?.envelope?.spatialReference.latestWkid).to.be.equal(overrideGeom.geom.spatialReference.latestWkid);
-        // Now test with a different tolerance value
-        url = provider3.constructFeatureUrl(0, 0, 0, "PBF", overrideGeom, undefined, 10);
-        expect(url?.url).to.equals("https://dummy.com/SomeGuid/ArcGIS/rest/services/SomeService/FeatureServer/0/query?f=PBF&resultType=tile&maxRecordCountFactor=3&returnExceededLimitFeatures=false&outSR=102100&geometryType=esriGeometryEnvelope&geometry=%7B%22xmin%22%3A-50%2C%22ymin%22%3A-50%2C%22xmax%22%3A50%2C%22ymax%22%3A50%2C%22spatialReference%22%3A%7B%22wkid%22%3A102100%2C%22latestWkid%22%3A3857%7D%7D&units=esriSRUnit_Meter&inSR=102100&quantizationParameters=%7B%22mode%22%3A%22view%22%2C%22originPosition%22%3A%22upperLeft%22%2C%22tolerance%22%3A78271.516953125%2C%22extent%22%3A%7B%22xmin%22%3A-20037508.34%2C%22ymin%22%3A-20037508.339999996%2C%22xmax%22%3A20037508.34%2C%22ymax%22%3A20037508.340000004%2C%22spatialReference%22%3A%7B%22wkid%22%3A102100%2C%22latestWkid%22%3A3857%7D%7D%7D&distance=782715.16953125");
-        expect(url?.envelope?.xmin).to.be.closeTo(overrideGeom.geom.xmin, 0.01);
-        expect(url?.envelope?.ymin).to.be.closeTo(overrideGeom.geom.ymin, 0.01);
-        expect(url?.envelope?.xmax).to.be.closeTo(overrideGeom.geom.xmax, 0.01);
-        expect(url?.envelope?.ymax).to.be.closeTo(overrideGeom.geom.ymax, 0.01);
-        expect(url?.envelope?.spatialReference.wkid).to.be.equal(overrideGeom.geom.spatialReference.wkid);
-        expect(url?.envelope?.spatialReference.latestWkid).to.be.equal(overrideGeom.geom.spatialReference.latestWkid);
-    });
-    it("should log error when getFeatureInfo cannot be performed", async () => {
-        const settings = core_common_1.ImageMapLayerSettings.fromJSON({
-            ...esriFeatureSampleSource,
-            subLayers: [{ id: 0, name: "layer1", visible: true }, { id: 2, name: "layer2", visible: true }]
-        });
-        sandbox.stub(map_layers_formats_1.ArcGisFeatureProvider.prototype, "getLayerMetadata").callsFake(async function (_id) {
-            return {
-                defaultVisibility: true,
-                supportedQueryFormats: "PBF, JSON",
-                minScale: 600000,
-                maxScale: 5000,
-            };
-        });
-        sandbox.stub(core_frontend_1.ArcGisUtilities, "getServiceJson").callsFake(async function _(_url, _formatId, _userName, _password, _ignoreCache, _requireToken) {
-            return { accessTokenRequired: false, content: { currentVersion: 11, capabilities: "Query" } };
-        });
-        sandbox.stub(map_layers_formats_1.ArcGisFeatureProvider.prototype, "constructFeatureUrl").callsFake(function _(_row, _column, _zoomLevel, _format, _geomOverride, _outFields, _tolerance, _returnGeometry) {
-            return undefined;
-        });
-        const provider = new map_layers_formats_1.ArcGisFeatureProvider(settings);
-        await provider.initialize();
-        const featureInfos = [];
-        const logErrorSpy = sandbox.spy(core_bentley_1.Logger, "logError");
-        await provider.getFeatureInfo(featureInfos, new core_frontend_1.QuadId(0, 0, 0), core_common_1.Cartographic.fromDegrees({ latitude: 46, longitude: -71 }), undefined);
-        expect(featureInfos.length).to.equals(0);
-        expect(logErrorSpy.called).to.be.true;
-    });
-    it("should process data in getFeatureInfo", async () => {
-        const settings = core_common_1.ImageMapLayerSettings.fromJSON({
-            ...esriFeatureSampleSource,
-            subLayers: [{ id: 0, name: "layer1", visible: true }, { id: 2, name: "layer2", visible: true }]
-        });
-        sandbox.stub(map_layers_formats_1.ArcGisFeatureProvider.prototype, "getLayerMetadata").callsFake(async function (_id) {
-            return {
-                defaultVisibility: true,
-                supportedQueryFormats: "PBF, JSON",
-                supportsCoordinatesQuantization: true,
-                minScale: 600000,
-                maxScale: 5000,
-            };
-        });
-        sandbox.stub(core_frontend_1.ArcGisUtilities, "getServiceJson").callsFake(async function _(_url, _formatId, _userName, _password, _ignoreCache, _requireToken) {
-            return { accessTokenRequired: false, content: { currentVersion: 11, capabilities: "Query" } };
-        });
-        fetchStub.restore(); // fetch is always stubbed by default, restore and provide our own stub
-        sandbox.stub(core_frontend_1.ArcGISImageryProvider.prototype, "fetch").callsFake(async function _(_url, _options) {
-            const test = {
-                headers: { "content-type": "pbf" },
-                arrayBuffer: async () => {
-                    const byteArray = core_common_1.Base64EncodedString.toUint8Array(PhillyLandmarksDataset_1.PhillyLandmarksDataset.phillyTransportationGetFeatureInfoQueryEncodedPbf);
-                    return Promise.resolve(byteArray ? core_bentley_1.ByteStream.fromUint8Array(byteArray).arrayBuffer : undefined);
-                },
-                status: 200,
-            }; // By using unknown type, I can define parts of Response I really need
-            return test;
-        });
-        const provider = new map_layers_formats_1.ArcGisFeatureProvider(settings);
-        await provider.initialize();
-        const featureInfos = [];
-        const logErrorSpy = sandbox.spy(core_bentley_1.Logger, "logError");
-        await provider.getFeatureInfo(featureInfos, new core_frontend_1.QuadId(0, 0, 0), core_common_1.Cartographic.fromDegrees({ latitude: 46, longitude: -71 }), undefined);
-        expect(featureInfos.length).to.equals(1);
-        expect(logErrorSpy.calledOnce).to.be.false;
-    });
-    it("should log error when exceed transfert limit", async () => {
-        const settings = core_common_1.ImageMapLayerSettings.fromJSON({
-            ...esriFeatureSampleSource,
-            subLayers: [{ id: 0, name: "layer1", visible: true }, { id: 2, name: "layer2", visible: true }]
-        });
-        sandbox.stub(map_layers_formats_1.ArcGisFeatureProvider.prototype, "getLayerMetadata").callsFake(async function (_id) {
-            return {
-                defaultVisibility: true,
-                supportedQueryFormats: "PBF, JSON",
-                minScale: 600000,
-                maxScale: 5000,
-            };
-        });
-        sandbox.stub(core_frontend_1.ArcGisUtilities, "getServiceJson").callsFake(async function _(_url, _formatId, _userName, _password, _ignoreCache, _requireToken) {
-            return { accessTokenRequired: false, content: { capabilities: "Query" } };
-        });
-        sandbox.stub(ArcGisFeatureResponse_1.ArcGisFeatureResponse.prototype, "getResponseData").callsFake(async function _() {
-            return { exceedTransferLimit: true, data: undefined };
-        });
-        const provider = new map_layers_formats_1.ArcGisFeatureProvider(settings);
-        await provider.initialize();
-        const featureInfos = [];
-        const logErrorSpy = sandbox.spy(core_bentley_1.Logger, "logError");
-        await provider.getFeatureInfo(featureInfos, new core_frontend_1.QuadId(0, 0, 0), core_common_1.Cartographic.fromDegrees({ latitude: 46, longitude: -71 }), undefined);
-        expect(featureInfos.length).to.equals(0);
-        expect(logErrorSpy.calledOnce).to.be.true;
-    });
-    it("should log error when exceed exception thrown limit", async () => {
-        const settings = core_common_1.ImageMapLayerSettings.fromJSON({
-            ...esriFeatureSampleSource,
-            subLayers: [{ id: 0, name: "layer1", visible: true }, { id: 2, name: "layer2", visible: true }]
-        });
-        sandbox.stub(map_layers_formats_1.ArcGisFeatureProvider.prototype, "getLayerMetadata").callsFake(async function (_id) {
-            return {
-                defaultVisibility: true,
-                supportedQueryFormats: "PBF, JSON",
-                minScale: 600000,
-                maxScale: 5000,
-            };
-        });
-        sandbox.stub(core_frontend_1.ArcGisUtilities, "getServiceJson").callsFake(async function _(_url, _formatId, _userName, _password, _ignoreCache, _requireToken) {
-            return { accessTokenRequired: false, content: { capabilities: "Query" } };
-        });
-        sandbox.stub(ArcGisFeatureResponse_1.ArcGisFeatureResponse.prototype, "getResponseData").callsFake(async function _() {
-            throw new Error();
-        });
-        const provider = new map_layers_formats_1.ArcGisFeatureProvider(settings);
-        await provider.initialize();
-        const featureInfos = [];
-        const logErrorSpy = sandbox.spy(core_bentley_1.Logger, "logError");
-        await provider.getFeatureInfo(featureInfos, new core_frontend_1.QuadId(0, 0, 0), core_common_1.Cartographic.fromDegrees({ latitude: 46, longitude: -71 }), undefined);
-        expect(featureInfos.length).to.equals(0);
-        expect(logErrorSpy.calledOnce).to.be.true;
-    });
-    it("should debug Feature Geom", async () => {
-        const settings = core_common_1.ImageMapLayerSettings.fromJSON({
-            ...esriFeatureSampleSource,
-            subLayers: [{ id: 0, name: "layer1", visible: true }, { id: 2, name: "layer2", visible: true }]
-        });
-        sandbox.stub(map_layers_formats_1.ArcGisFeatureProvider.prototype, "getLayerMetadata").callsFake(async function (_id) {
-            return {
-                defaultVisibility: true,
-                supportedQueryFormats: "PBF, JSON",
-                minScale: 600000,
-                maxScale: 5000,
-            };
-        });
-        sandbox.stub(core_frontend_1.ArcGisUtilities, "getServiceJson").callsFake(async function _(_url, _formatId, _userName, _password, _ignoreCache, _requireToken) {
-            return { accessTokenRequired: false, content: { capabilities: "Query" } };
-        });
-        sandbox.stub(ArcGisFeatureResponse_1.ArcGisFeatureResponse.prototype, "getResponseData").callsFake(async function _() {
-            return { data: {
-                    toObject: () => undefined,
-                } };
-        });
-        const provider = new map_layers_formats_1.ArcGisFeatureProvider(settings);
-        await provider.initialize();
-        provider._debugFeatureGeom = true;
-        const featureInfos = [];
-        const logInfoSpy = sandbox.spy(core_bentley_1.Logger, "logInfo");
-        await provider.getFeatureInfo(featureInfos, new core_frontend_1.QuadId(0, 0, 0), core_common_1.Cartographic.fromDegrees({ latitude: 46, longitude: -71 }), undefined);
-        expect(featureInfos.length).to.equals(0);
-        expect(logInfoSpy.callCount).to.equals(2);
-    });
-    it("should compute computeTileWorld2CanvasTransform", async () => {
-        const settings = core_common_1.ImageMapLayerSettings.fromJSON({
-            ...esriFeatureSampleSource,
-            subLayers: [{ id: 0, name: "layer1", visible: true }, { id: 2, name: "layer2", visible: true }]
-        });
-        const worldSize = 100;
-        const canvasSize = 10;
-        const provider = new map_layers_formats_1.ArcGisFeatureProvider(settings);
-        const getEPSG3857ExtentStub = sandbox.stub(map_layers_formats_1.ArcGisFeatureProvider.prototype, "getEPSG3857Extent").callsFake(function (_row, _column, _zoomLevel) {
-            return { left: 0, right: worldSize, bottom: 0, top: worldSize };
-        });
-        sandbox.stub(provider, "tileSize").get(function () {
-            return canvasSize; // return a size of 10 to simplicity
-        });
-        let transform = provider.computeTileWorld2CanvasTransform(0, 0, 0);
-        let worldPoint = core_geometry_1.Point3d.createFrom({ x: worldSize * 0.5, y: worldSize * 0.5, z: 0 });
-        let transformedPoint = transform?.multiplyPoint3d(worldPoint);
-        // Make sure center point remains in the center
-        expect(transformedPoint).to.not.undefined;
-        expect(transformedPoint.x).to.equals(canvasSize * 0.5);
-        expect(transformedPoint.y).to.equals(canvasSize * 0.5);
-        expect(transformedPoint.z).to.equals(0);
-        // Check that y-axis get flipped
-        worldPoint = core_geometry_1.Point3d.createFrom({ x: 0, y: 10, z: 0 });
-        transformedPoint = transform?.multiplyPoint3d(worldPoint);
-        expect(transformedPoint.x).to.equals(0);
-        expect(transformedPoint.y).to.equals(9);
-        expect(transformedPoint.z).to.equals(0);
-        // Now check translation has been applied (origin shift)
-        getEPSG3857ExtentStub.restore();
-        sandbox.stub(map_layers_formats_1.ArcGisFeatureProvider.prototype, "getEPSG3857Extent").callsFake(function (_row, _column, _zoomLevel) {
-            return { left: worldSize, right: worldSize * 2, bottom: worldSize, top: worldSize * 2 };
-        });
-        worldPoint = core_geometry_1.Point3d.createFrom({ x: worldSize, y: worldSize, z: 0 });
-        transform = provider.computeTileWorld2CanvasTransform(0, 0, 0);
-        transformedPoint = transform?.multiplyPoint3d(worldPoint);
-        expect(transformedPoint).to.not.undefined;
-        expect(transformedPoint.x).to.equals(0);
-        expect(transformedPoint.y).to.equals(10);
-        expect(transformedPoint.z).to.equals(0);
-    });
-    it("should loadTile from PBF request", async () => {
-        const settings = core_common_1.ImageMapLayerSettings.fromJSON({
-            ...esriFeatureSampleSource,
-            subLayers: [{ id: 0, name: "layer1", visible: true }, { id: 2, name: "layer2", visible: true }]
-        });
-        sandbox.stub(map_layers_formats_1.ArcGisFeatureProvider.prototype, "getLayerMetadata").callsFake(async function (_id) {
-            return {
-                defaultVisibility: true,
-                supportedQueryFormats: "PBF",
-                supportsCoordinatesQuantization: true,
-            };
-        });
-        sandbox.stub(core_frontend_1.ArcGisUtilities, "getServiceJson").callsFake(async function _(_url, _formatId, _userName, _password, _ignoreCache, _requireToken) {
-            return { accessTokenRequired: false, content: { currentVersion: 11, capabilities: "Query" } };
-        });
-        sandbox.stub(HTMLCanvasElement.prototype, "getContext").callsFake(function _(_contextId, _options) {
-            return {};
-        });
-        sandbox.stub(HTMLCanvasElement.prototype, "toDataURL").callsFake(function _(_type, _quality) {
-            return `data:image/png;base64,${pngTransparent1x1}`;
-        });
-        const providerStub = sandbox.stub(map_layers_formats_1.ArcGisFeatureProvider.prototype, "fetchTile").callsFake(async function _() {
-            return new ArcGisFeatureResponse_1.ArcGisFeatureResponse("PBF", Promise.resolve({}));
-        });
-        sandbox.stub(ArcGisFeatureResponse_1.ArcGisFeatureResponse.prototype, "getResponseData").callsFake(async function _() {
-            return {
-                exceedTransferLimit: false,
-                data: { toObject: () => undefined },
-            };
-        });
-        //    toDataURL string;
-        const readAndRenderSpy = sandbox.spy(ArcGisFeaturePBF_1.ArcGisFeaturePBF.prototype, "readAndRender");
-        const computeTransfoSpy = sandbox.spy(map_layers_formats_1.ArcGisFeatureProvider.prototype, "computeTileWorld2CanvasTransform");
-        const provider = new map_layers_formats_1.ArcGisFeatureProvider(settings);
-        await provider.initialize();
-        const tileData = await provider.loadTile(0, 0, 0);
-        expect(tileData).to.not.undefined;
-        expect(tileData?.data instanceof Uint8Array).to.be.true;
-        expect(tileData?.data).to.eqls((0, core_bentley_1.base64StringToUint8Array)(pngTransparent1x1));
-        expect(tileData?.format).to.equals(core_common_1.ImageSourceFormat.Png);
-        expect(providerStub.calledOnce).to.be.true;
-        expect(readAndRenderSpy.calledOnce).to.be.true;
-        expect(computeTransfoSpy.calledOnce).to.be.false; // Should not be called since we have supportsCoordinatesQuantization in layer metadata
-    });
-    it("should loadTile from JSON request", async () => {
-        const settings = core_common_1.ImageMapLayerSettings.fromJSON({
-            ...esriFeatureSampleSource,
-            subLayers: [{ id: 0, name: "layer1", visible: true }, { id: 2, name: "layer2", visible: true }]
-        });
-        sandbox.stub(map_layers_formats_1.ArcGisFeatureProvider.prototype, "getLayerMetadata").callsFake(async function (_id) {
-            return {
-                defaultVisibility: true,
-                supportedQueryFormats: "JSON",
-            };
-        });
-        sandbox.stub(core_frontend_1.ArcGisUtilities, "getServiceJson").callsFake(async function _(_url, _formatId, _userName, _password, _ignoreCache, _requireToken) {
-            return { accessTokenRequired: false, content: { capabilities: "Query" } };
-        });
-        sandbox.stub(HTMLCanvasElement.prototype, "getContext").callsFake(function _(_contextId, _options) {
-            return {};
-        });
-        sandbox.stub(HTMLCanvasElement.prototype, "toDataURL").callsFake(function _(_type, _quality) {
-            return `data:image/png;base64,${pngTransparent1x1}`;
-        });
-        const providerStub = sandbox.stub(map_layers_formats_1.ArcGisFeatureProvider.prototype, "fetchTile").callsFake(async function _() {
-            return new ArcGisFeatureResponse_1.ArcGisFeatureResponse("JSON", Promise.resolve({}));
-        });
-        sandbox.stub(ArcGisFeatureResponse_1.ArcGisFeatureResponse.prototype, "getResponseData").callsFake(async function _() {
-            return {
-                exceedTransferLimit: false,
-                data: { toObject: () => undefined },
-            };
-        });
-        const readAndRenderSpy = sandbox.spy(ArcGisFeatureJSON_1.ArcGisFeatureJSON.prototype, "readAndRender");
-        const computeTransfoSpy = sandbox.spy(map_layers_formats_1.ArcGisFeatureProvider.prototype, "computeTileWorld2CanvasTransform");
-        const provider = new map_layers_formats_1.ArcGisFeatureProvider(settings);
-        await provider.initialize();
-        const tileData = await provider.loadTile(0, 0, 0);
-        expect(tileData).to.not.undefined;
-        expect(tileData?.data instanceof Uint8Array).to.be.true;
-        expect(tileData?.data).to.eqls((0, core_bentley_1.base64StringToUint8Array)(pngTransparent1x1));
-        expect(tileData?.format).to.equals(core_common_1.ImageSourceFormat.Png);
-        expect(providerStub.calledOnce).to.be.true;
-        expect(readAndRenderSpy.calledOnce).to.be.true;
-        expect(computeTransfoSpy.calledOnce).to.be.true; // Should be called since we dont have _supportsCoordinatesQuantization in layer metadata
-    });
-    it("should make sub request if loadtile request return 'exceedTransferLimit'", async () => {
-        const settings = core_common_1.ImageMapLayerSettings.fromJSON({
-            ...esriFeatureSampleSource,
-            subLayers: [{ id: 0, name: "layer1", visible: true }, { id: 2, name: "layer2", visible: true }]
-        });
-        sandbox.stub(map_layers_formats_1.ArcGisFeatureProvider.prototype, "getLayerMetadata").callsFake(async function (_id) {
-            return {
-                defaultVisibility: true,
-                supportedQueryFormats: "JSON",
-            };
-        });
-        sandbox.stub(core_frontend_1.ArcGisUtilities, "getServiceJson").callsFake(async function _(_url, _formatId, _userName, _password, _ignoreCache, _requireToken) {
-            return { accessTokenRequired: false, content: { capabilities: "Query" } };
-        });
-        sandbox.stub(HTMLCanvasElement.prototype, "getContext").callsFake(function _(_contextId, _options) {
-            return {};
-        });
-        sandbox.stub(HTMLCanvasElement.prototype, "toDataURL").callsFake(function _(_type, _quality) {
-            return `data:image/png;base64,${pngTransparent1x1}`;
-        });
-        const extentSize = 100;
-        const fetchTileStub = sandbox.stub(map_layers_formats_1.ArcGisFeatureProvider.prototype, "fetchTile").callsFake(async function _() {
-            const envelope = {
-                xmin: 0,
-                ymin: 0,
-                xmax: extentSize,
-                ymax: extentSize,
-                spatialReference: {
-                    wkid: 102100,
-                    latestWkid: 3857,
-                }
-            };
-            return new ArcGisFeatureResponse_1.ArcGisFeatureResponse("JSON", Promise.resolve({}), envelope);
-        });
-        let firstCall = true;
-        sandbox.stub(ArcGisFeatureResponse_1.ArcGisFeatureResponse.prototype, "getResponseData").callsFake(async function _() {
-            const exceed = firstCall === true;
-            firstCall = false;
-            return {
-                exceedTransferLimit: exceed,
-                data: { toObject: () => undefined },
-            };
-        });
-        const readAndRenderSpy = sandbox.spy(ArcGisFeatureJSON_1.ArcGisFeatureJSON.prototype, "readAndRender");
-        const provider = new map_layers_formats_1.ArcGisFeatureProvider(settings);
-        await provider.initialize();
-        await provider.loadTile(0, 0, 0);
-        // We should have 5 calls:
-        // Call #1 : initial call for 0,0,0 and it returns 'exceedTransferLimit'
-        // Calls #2-5: Four calls which represent a call for each sub-envelope (initial extent divided by 4)
-        expect(fetchTileStub.getCalls().length).to.equals(5);
-        expect(fetchTileStub.getCalls()[1].args[3]).to.eqls({
-            xmin: 0, ymin: 0, xmax: extentSize * 0.5, ymax: extentSize * 0.5,
-            spatialReference: { wkid: 102100, latestWkid: 3857,
-            }
-        });
-        expect(fetchTileStub.getCalls()[2].args[3]).to.eqls({
-            xmin: 0, ymin: extentSize * 0.5, xmax: extentSize * 0.5, ymax: extentSize,
-            spatialReference: { wkid: 102100, latestWkid: 3857,
-            }
-        });
-        expect(fetchTileStub.getCalls()[3].args[3]).to.eqls({
-            xmin: extentSize * 0.5, ymin: 0, xmax: extentSize, ymax: extentSize * 0.5,
-            spatialReference: { wkid: 102100, latestWkid: 3857,
-            }
-        });
-        expect(fetchTileStub.getCalls()[4].args[3]).to.eqls({
-            xmin: extentSize * 0.5, ymin: extentSize * 0.5, xmax: extentSize, ymax: extentSize,
-            spatialReference: { wkid: 102100, latestWkid: 3857,
-            }
-        });
-        expect(readAndRenderSpy.getCalls().length).to.equals(4);
-    });
-    it("fetchTile should return undefined when to format defined", async () => {
-        const settings = core_common_1.ImageMapLayerSettings.fromJSON({
-            ...esriFeatureSampleSource,
-            subLayers: [{ id: 0, name: "layer1", visible: true }, { id: 2, name: "layer2", visible: true }]
-        });
-        const provider = new map_layers_formats_1.ArcGisFeatureProvider(settings);
-        // make a first request with init, should return undefined because of missing format
-        const tileData = await provider.fetchTile(0, 0, 0);
-        expect(tileData).to.be.undefined;
-    });
-    it("fetchTile should call fetch with the proper URL", async () => {
-        const settings = core_common_1.ImageMapLayerSettings.fromJSON({
-            ...esriFeatureSampleSource,
-            subLayers: [{ id: 0, name: "layer1", visible: true }, { id: 2, name: "layer2", visible: true }]
-        });
-        sandbox.stub(map_layers_formats_1.ArcGisFeatureProvider.prototype, "getLayerMetadata").callsFake(async function (_id) {
-            return {
-                defaultVisibility: true,
-                supportedQueryFormats: "JSON",
-            };
-        });
-        sandbox.stub(core_frontend_1.ArcGisUtilities, "getServiceJson").callsFake(async function _(_url, _formatId, _userName, _password, _ignoreCache, _requireToken) {
-            return { accessTokenRequired: false, content: { capabilities: "Query" } };
-        });
-        sandbox.stub(map_layers_formats_1.ArcGisFeatureProvider.prototype, "constructFeatureUrl").callsFake(function _(_row, _column, _zoomLevel, _format, _geomOverride, _outFields, _tolerance, _returnGeometry) {
-            return { url: settings.url };
-        });
-        const provider = new map_layers_formats_1.ArcGisFeatureProvider(settings);
-        await provider.initialize();
-        const response = await provider.fetchTile(0, 0, 0);
-        expect(response).to.not.undefined;
-        expect(fetchStub.calledOnce).to.be.true;
-        const test1 = fetchStub.getCall(0).firstArg;
-        expect(test1.toString()).to.equals(new URL(settings.url).toString());
-    });
-});
-//# sourceMappingURL=ArcGisFeatureProvider.test.js.map