@itwin/map-layers-formats 4.0.0-dev.8 → 4.0.0-dev.81

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

@@ -1,679 +1,678 @@
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
-import { Base64EncodedString, Cartographic, ImageMapLayerSettings, ImageSourceFormat, ServerError } from "@itwin/core-common";
-import * as chai from "chai";
-import * as chaiAsPromised from "chai-as-promised";
-import { ArcGisFeatureMapLayerFormat } from "../../ArcGisFeature/ArcGisFeatureFormat";
-import { ArcGisFeatureProvider } from "../../map-layers-formats";
-import * as sinon from "sinon";
-import { ArcGISImageryProvider, ArcGisUtilities, MapLayerImageryProviderStatus, QuadId } from "@itwin/core-frontend";
-import { NewYorkDataset } from "./NewYorkDataset";
-import { base64StringToUint8Array, ByteStream, Logger } from "@itwin/core-bentley";
-import { PhillyLandmarksDataset } from "./PhillyLandmarksDataset";
-import { ArcGisFeatureResponse } from "../../ArcGisFeature/ArcGisFeatureResponse";
-import { Point3d } from "@itwin/core-geometry";
-import { ArcGisFeaturePBF } from "../../ArcGisFeature/ArcGisFeaturePBF";
-import { ArcGisFeatureJSON } from "../../ArcGisFeature/ArcGisFeatureJSON";
-const expect = chai.expect;
-chai.use(chaiAsPromised);
-const esriFeatureSampleSource = { name: "dummyFeatureLayer", url: "https://dummy.com", formatId: ArcGisFeatureMapLayerFormat.formatId };
-const pngTransparent1x1 = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==";
-describe("ArcGisFeatureProvider", () => {
-    const sandbox = sinon.createSandbox();
-    afterEach(async () => {
-        sandbox.restore();
-    });
-    it("should initialize with valid data", async () => {
-        sandbox.stub(ArcGisUtilities, "getServiceJson").callsFake(async function _(_url, _formatId, _userName, _password, _ignoreCache, _requireToken) {
-            return { accessTokenRequired: false, content: NewYorkDataset.serviceCapabilities };
-        });
-        sandbox.stub(ArcGisFeatureProvider.prototype, "getLayerMetadata").callsFake(async function _(_layerId) {
-            return NewYorkDataset.streetsLayerCapabilities;
-        });
-        const settings = ImageMapLayerSettings.fromJSON(esriFeatureSampleSource);
-        const provider = new ArcGisFeatureProvider(settings);
-        await provider.initialize();
-        expect(provider._minDepthFromLod).to.equals(11);
-        expect(provider._maxDepthFromLod).to.equals(22);
-    });
-    it("should not initialize with no service metadata", async () => {
-        sandbox.stub(ArcGisUtilities, "getServiceJson").callsFake(async function _(_url, _formatId, _userName, _password, _ignoreCache, _requireToken) {
-            return undefined;
-        });
-        const settings = ImageMapLayerSettings.fromJSON(esriFeatureSampleSource);
-        const provider = new ArcGisFeatureProvider(settings);
-        await expect(provider.initialize()).to.be.rejectedWith(ServerError);
-    });
-    it("should update status when invalid token error from service", async () => {
-        sandbox.stub(ArcGisUtilities, "getServiceJson").callsFake(async function _(_url, _formatId, _userName, _password, _ignoreCache, _requireToken) {
-            return { accessTokenRequired: false, content: { error: { code: 499 } } };
-        });
-        const settings = ImageMapLayerSettings.fromJSON(esriFeatureSampleSource);
-        const provider = new ArcGisFeatureProvider(settings);
-        const raiseEventSpy = sandbox.spy(provider.onStatusChanged, "raiseEvent");
-        await provider.initialize();
-        expect(provider.status).to.equals(MapLayerImageryProviderStatus.RequireAuth);
-        expect(raiseEventSpy.calledOnceWith(provider)).to.be.true;
-    });
-    it("should throw    query capability not supported", async () => {
-        sandbox.stub(ArcGisUtilities, "getServiceJson").callsFake(async function _(_url, _formatId, _userName, _password, _ignoreCache, _requireToken) {
-            return { accessTokenRequired: false, content: { capabilities: "Test" } };
-        });
-        const settings = ImageMapLayerSettings.fromJSON(esriFeatureSampleSource);
-        const provider = new ArcGisFeatureProvider(settings);
-        await expect(provider.initialize()).to.be.rejectedWith(ServerError);
-    });
-    it("should pick the first visible sub-layer when multiple visible sub-layers", async () => {
-        sandbox.stub(ArcGisUtilities, "getServiceJson").callsFake(async function _(_url, _formatId, _userName, _password, _ignoreCache, _requireToken) {
-            return { accessTokenRequired: false, content: { capabilities: "Query" } };
-        });
-        const settings = ImageMapLayerSettings.fromJSON({
-            ...esriFeatureSampleSource,
-            subLayers: [{ id: 0, name: "layer1", visible: true }, { id: 2, name: "layer2", visible: true }]
-        });
-        const provider = new 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(ArcGisUtilities, "getServiceJson").callsFake(async function _(_url, _formatId, _userName, _password, _ignoreCache, _requireToken) {
-            return { accessTokenRequired: false, content: { capabilities: "Query",
-                    layers: [
-                        {
-                            id: 0,
-                        },
-                        {
-                            id: 1,
-                        },
-                    ] },
-            };
-        });
-        sandbox.stub(ArcGisFeatureProvider.prototype, "getLayerMetadata").callsFake(async function (id) {
-            if (id === 1) {
-                return { defaultVisibility: true };
-            }
-            return undefined;
-        });
-        const settings = ImageMapLayerSettings.fromJSON(esriFeatureSampleSource);
-        const provider = new 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(ArcGisUtilities, "getServiceJson").callsFake(async function _(_url, _formatId, _userName, _password, _ignoreCache, _requireToken) {
-            return { accessTokenRequired: false, content: { capabilities: "Query", layers: [] } };
-        });
-        const settings = ImageMapLayerSettings.fromJSON(esriFeatureSampleSource);
-        const provider = new ArcGisFeatureProvider(settings);
-        await expect(provider.initialize()).to.be.rejectedWith(ServerError);
-    });
-    it("should throw if no layer metadata from service", async () => {
-        const settings = ImageMapLayerSettings.fromJSON({
-            ...esriFeatureSampleSource,
-            subLayers: [{ id: 0, name: "layer1", visible: true }, { id: 2, name: "layer2", visible: true }]
-        });
-        sandbox.stub(ArcGisUtilities, "getServiceJson").callsFake(async function _(_url, _formatId, _userName, _password, _ignoreCache, _requireToken) {
-            return { accessTokenRequired: false, content: { capabilities: "Query" } };
-        });
-        sandbox.stub(ArcGisFeatureProvider.prototype, "getLayerMetadata").callsFake(async function (_id) {
-            return undefined;
-        });
-        const provider = new ArcGisFeatureProvider(settings);
-        await expect(provider.initialize()).to.be.rejectedWith(ServerError);
-    });
-    it("should read supported supported format", async () => {
-        const settings = ImageMapLayerSettings.fromJSON({
-            ...esriFeatureSampleSource,
-            subLayers: [{ id: 0, name: "layer1", visible: true }, { id: 2, name: "layer2", visible: true }]
-        });
-        let getLayerMetadataStub = sandbox.stub(ArcGisFeatureProvider.prototype, "getLayerMetadata").callsFake(async function (_id) {
-            return { defaultVisibility: true, supportedQueryFormats: "PBF, JSON" };
-        });
-        const getServiceJsonStub = sandbox.stub(ArcGisUtilities, "getServiceJson").callsFake(async function _(_url, _formatId, _userName, _password, _ignoreCache, _requireToken) {
-            return { accessTokenRequired: false, content: { capabilities: "Query" } };
-        });
-        let provider = new ArcGisFeatureProvider(settings);
-        await provider.initialize();
-        expect(provider.format).to.equals("JSON");
-        // PBF requires 'supportsCoordinatesQuantization'
-        getServiceJsonStub.restore();
-        sandbox.stub(ArcGisUtilities, "getServiceJson").callsFake(async function _(_url, _formatId, _userName, _password, _ignoreCache, _requireToken) {
-            return { accessTokenRequired: false, content: { currentVersion: 11, capabilities: "Query" } };
-        });
-        getLayerMetadataStub.restore();
-        getLayerMetadataStub = sandbox.stub(ArcGisFeatureProvider.prototype, "getLayerMetadata").callsFake(async function (_id) {
-            return { defaultVisibility: true, supportsCoordinatesQuantization: true, supportedQueryFormats: "PBF, JSON" };
-        });
-        provider = new ArcGisFeatureProvider(settings);
-        await provider.initialize();
-        expect(provider.format).to.equals("PBF");
-        getLayerMetadataStub.restore();
-        getLayerMetadataStub = sandbox.stub(ArcGisFeatureProvider.prototype, "getLayerMetadata").callsFake(async function (_id) {
-            return { defaultVisibility: true, supportedQueryFormats: "JSON" };
-        });
-        getServiceJsonStub.restore();
-        sandbox.stub(ArcGisUtilities, "getServiceJson").callsFake(async function _(_url, _formatId, _userName, _password, _ignoreCache, _requireToken) {
-            return { accessTokenRequired: false, content: { currentVersion: 10.91, capabilities: "Query", supportsCoordinatesQuantization: true } };
-        });
-        provider = new ArcGisFeatureProvider(settings);
-        await provider.initialize();
-        expect(provider.format).to.equals("JSON");
-        getLayerMetadataStub.restore();
-        getLayerMetadataStub = sandbox.stub(ArcGisFeatureProvider.prototype, "getLayerMetadata").callsFake(async function (_id) {
-            return { defaultVisibility: true, supportedQueryFormats: "JSON" };
-        });
-        provider = new ArcGisFeatureProvider(settings);
-        await provider.initialize();
-        expect(provider.format).to.equals("JSON");
-        getLayerMetadataStub.restore();
-        getLayerMetadataStub = sandbox.stub(ArcGisFeatureProvider.prototype, "getLayerMetadata").callsFake(async function (_id) {
-            return { defaultVisibility: true, supportedQueryFormats: "" };
-        });
-        provider = new ArcGisFeatureProvider(settings);
-        await expect(provider.initialize()).to.be.rejectedWith(ServerError);
-    });
-    it("should compute minLod/maxLod", async () => {
-        const settings = ImageMapLayerSettings.fromJSON({
-            ...esriFeatureSampleSource,
-            subLayers: [{ id: 0, name: "layer1", visible: true }, { id: 2, name: "layer2", visible: true }]
-        });
-        sandbox.stub(ArcGisFeatureProvider.prototype, "getLayerMetadata").callsFake(async function (_id) {
-            return {
-                defaultVisibility: true,
-                supportedQueryFormats: "PBF, JSON",
-                minScale: 600000,
-                maxScale: 5000,
-            };
-        });
-        sandbox.stub(ArcGisUtilities, "getServiceJson").callsFake(async function _(_url, _formatId, _userName, _password, _ignoreCache, _requireToken) {
-            return { accessTokenRequired: false, content: { capabilities: "Query" } };
-        });
-        const provider = new 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 = ImageMapLayerSettings.fromJSON(esriFeatureSampleSource);
-        const provider = new ArcGisFeatureProvider(settings);
-        const url = await provider.constructUrl(0, 0, 0);
-        expect(url).to.equals("");
-    });
-    it("should construct feature query url", async () => {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z;
-        const settings = ImageMapLayerSettings.fromJSON({
-            ...esriFeatureSampleSource,
-            subLayers: [{ id: 0, name: "layer1", visible: true }, { id: 2, name: "layer2", visible: true }]
-        });
-        let getLayerMetadataStub = sandbox.stub(ArcGisFeatureProvider.prototype, "getLayerMetadata").callsFake(async function (_id) {
-            return {
-                defaultVisibility: true,
-                supportedQueryFormats: "PBF, JSON",
-            };
-        });
-        sandbox.stub(ArcGisUtilities, "getServiceJson").callsFake(async function _(_url, _formatId, _userName, _password, _ignoreCache, _requireToken) {
-            return { accessTokenRequired: false, content: { currentVersion: 11, capabilities: "Query" } };
-        });
-        const provider = new 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 === null || url === void 0 ? void 0 : url.url).to.equals(`https://dummy.com/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((_a = url === null || url === void 0 ? void 0 : url.envelope) === null || _a === void 0 ? void 0 : _a.xmin).to.be.closeTo(extent.xmin, 0.01);
-        expect((_b = url === null || url === void 0 ? void 0 : url.envelope) === null || _b === void 0 ? void 0 : _b.ymin).to.be.closeTo(extent.ymin, 0.01);
-        expect((_c = url === null || url === void 0 ? void 0 : url.envelope) === null || _c === void 0 ? void 0 : _c.xmax).to.be.closeTo(extent.xmax, 0.01);
-        expect((_d = url === null || url === void 0 ? void 0 : url.envelope) === null || _d === void 0 ? void 0 : _d.ymax).to.be.closeTo(extent.ymax, 0.01);
-        expect((_e = url === null || url === void 0 ? void 0 : url.envelope) === null || _e === void 0 ? void 0 : _e.spatialReference.wkid).to.be.equal(102100);
-        expect((_f = url === null || url === void 0 ? void 0 : url.envelope) === null || _f === void 0 ? void 0 : _f.spatialReference.latestWkid).to.be.equal(3857);
-        // Now turn ON 'supportsCoordinatesQuantization' to ON
-        getLayerMetadataStub.restore();
-        getLayerMetadataStub = sandbox.stub(ArcGisFeatureProvider.prototype, "getLayerMetadata").callsFake(async function (_id) {
-            return {
-                defaultVisibility: true,
-                supportedQueryFormats: "PBF, JSON",
-                supportsCoordinatesQuantization: true,
-            };
-        });
-        const provider2 = new ArcGisFeatureProvider(settings);
-        await provider2.initialize();
-        url = provider2.constructFeatureUrl(0, 0, 0, "PBF");
-        expect(url === null || url === void 0 ? void 0 : url.url).to.equals(`https://dummy.com/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((_g = url === null || url === void 0 ? void 0 : url.envelope) === null || _g === void 0 ? void 0 : _g.xmin).to.be.closeTo(extent.xmin, 0.01);
-        expect((_h = url === null || url === void 0 ? void 0 : url.envelope) === null || _h === void 0 ? void 0 : _h.ymin).to.be.closeTo(extent.ymin, 0.01);
-        expect((_j = url === null || url === void 0 ? void 0 : url.envelope) === null || _j === void 0 ? void 0 : _j.xmax).to.be.closeTo(extent.xmax, 0.01);
-        expect((_k = url === null || url === void 0 ? void 0 : url.envelope) === null || _k === void 0 ? void 0 : _k.ymax).to.be.closeTo(extent.ymax, 0.01);
-        expect((_l = url === null || url === void 0 ? void 0 : url.envelope) === null || _l === void 0 ? void 0 : _l.spatialReference.wkid).to.be.equal(extent.spatialReference.wkid);
-        expect((_m = url === null || url === void 0 ? void 0 : url.envelope) === null || _m === void 0 ? void 0 : _m.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 ArcGisFeatureProvider(settings);
-        await provider3.initialize();
-        url = provider3.constructFeatureUrl(0, 0, 0, "PBF", overrideGeom);
-        expect(url === null || url === void 0 ? void 0 : url.url).to.equals(`https://dummy.com/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((_o = url === null || url === void 0 ? void 0 : url.envelope) === null || _o === void 0 ? void 0 : _o.xmin).to.be.closeTo(overrideGeom.geom.xmin, 0.01);
-        expect((_p = url === null || url === void 0 ? void 0 : url.envelope) === null || _p === void 0 ? void 0 : _p.ymin).to.be.closeTo(overrideGeom.geom.ymin, 0.01);
-        expect((_q = url === null || url === void 0 ? void 0 : url.envelope) === null || _q === void 0 ? void 0 : _q.xmax).to.be.closeTo(overrideGeom.geom.xmax, 0.01);
-        expect((_r = url === null || url === void 0 ? void 0 : url.envelope) === null || _r === void 0 ? void 0 : _r.ymax).to.be.closeTo(overrideGeom.geom.ymax, 0.01);
-        expect((_s = url === null || url === void 0 ? void 0 : url.envelope) === null || _s === void 0 ? void 0 : _s.spatialReference.wkid).to.be.equal(overrideGeom.geom.spatialReference.wkid);
-        expect((_t = url === null || url === void 0 ? void 0 : url.envelope) === null || _t === void 0 ? void 0 : _t.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 === null || url === void 0 ? void 0 : url.url).to.equals(`https://dummy.com/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((_u = url === null || url === void 0 ? void 0 : url.envelope) === null || _u === void 0 ? void 0 : _u.xmin).to.be.closeTo(overrideGeom.geom.xmin, 0.01);
-        expect((_v = url === null || url === void 0 ? void 0 : url.envelope) === null || _v === void 0 ? void 0 : _v.ymin).to.be.closeTo(overrideGeom.geom.ymin, 0.01);
-        expect((_w = url === null || url === void 0 ? void 0 : url.envelope) === null || _w === void 0 ? void 0 : _w.xmax).to.be.closeTo(overrideGeom.geom.xmax, 0.01);
-        expect((_x = url === null || url === void 0 ? void 0 : url.envelope) === null || _x === void 0 ? void 0 : _x.ymax).to.be.closeTo(overrideGeom.geom.ymax, 0.01);
-        expect((_y = url === null || url === void 0 ? void 0 : url.envelope) === null || _y === void 0 ? void 0 : _y.spatialReference.wkid).to.be.equal(overrideGeom.geom.spatialReference.wkid);
-        expect((_z = url === null || url === void 0 ? void 0 : url.envelope) === null || _z === void 0 ? void 0 : _z.spatialReference.latestWkid).to.be.equal(overrideGeom.geom.spatialReference.latestWkid);
-    });
-    it("should log error when getFeatureInfo cannot be performed", async () => {
-        const settings = ImageMapLayerSettings.fromJSON({
-            ...esriFeatureSampleSource,
-            subLayers: [{ id: 0, name: "layer1", visible: true }, { id: 2, name: "layer2", visible: true }]
-        });
-        sandbox.stub(ArcGisFeatureProvider.prototype, "getLayerMetadata").callsFake(async function (_id) {
-            return {
-                defaultVisibility: true,
-                supportedQueryFormats: "PBF, JSON",
-                minScale: 600000,
-                maxScale: 5000,
-            };
-        });
-        sandbox.stub(ArcGisUtilities, "getServiceJson").callsFake(async function _(_url, _formatId, _userName, _password, _ignoreCache, _requireToken) {
-            return { accessTokenRequired: false, content: { currentVersion: 11, capabilities: "Query" } };
-        });
-        sandbox.stub(ArcGisFeatureProvider.prototype, "constructFeatureUrl").callsFake(function _(_row, _column, _zoomLevel, _format, _geomOverride, _outFields, _tolerance, _returnGeometry) {
-            return undefined;
-        });
-        const provider = new ArcGisFeatureProvider(settings);
-        await provider.initialize();
-        const featureInfos = [];
-        const logErrorSpy = sandbox.spy(Logger, "logError");
-        await provider.getFeatureInfo(featureInfos, new QuadId(0, 0, 0), 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 = ImageMapLayerSettings.fromJSON({
-            ...esriFeatureSampleSource,
-            subLayers: [{ id: 0, name: "layer1", visible: true }, { id: 2, name: "layer2", visible: true }]
-        });
-        sandbox.stub(ArcGisFeatureProvider.prototype, "getLayerMetadata").callsFake(async function (_id) {
-            return {
-                defaultVisibility: true,
-                supportedQueryFormats: "PBF, JSON",
-                supportsCoordinatesQuantization: true,
-                minScale: 600000,
-                maxScale: 5000,
-            };
-        });
-        sandbox.stub(ArcGisUtilities, "getServiceJson").callsFake(async function _(_url, _formatId, _userName, _password, _ignoreCache, _requireToken) {
-            return { accessTokenRequired: false, content: { currentVersion: 11, capabilities: "Query" } };
-        });
-        sandbox.stub(ArcGISImageryProvider.prototype, "fetch").callsFake(async function _(_url, _options) {
-            const test = {
-                headers: { "content-type": "pbf" },
-                arrayBuffer: async () => {
-                    const byteArray = Base64EncodedString.toUint8Array(PhillyLandmarksDataset.phillyTransportationGetFeatureInfoQueryEncodedPbf);
-                    return Promise.resolve(byteArray ? 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 ArcGisFeatureProvider(settings);
-        await provider.initialize();
-        const featureInfos = [];
-        const logErrorSpy = sandbox.spy(Logger, "logError");
-        await provider.getFeatureInfo(featureInfos, new QuadId(0, 0, 0), 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 = ImageMapLayerSettings.fromJSON({
-            ...esriFeatureSampleSource,
-            subLayers: [{ id: 0, name: "layer1", visible: true }, { id: 2, name: "layer2", visible: true }]
-        });
-        sandbox.stub(ArcGisFeatureProvider.prototype, "getLayerMetadata").callsFake(async function (_id) {
-            return {
-                defaultVisibility: true,
-                supportedQueryFormats: "PBF, JSON",
-                minScale: 600000,
-                maxScale: 5000,
-            };
-        });
-        sandbox.stub(ArcGisUtilities, "getServiceJson").callsFake(async function _(_url, _formatId, _userName, _password, _ignoreCache, _requireToken) {
-            return { accessTokenRequired: false, content: { capabilities: "Query" } };
-        });
-        sandbox.stub(ArcGisFeatureResponse.prototype, "getResponseData").callsFake(async function _() {
-            return { exceedTransferLimit: true, data: undefined };
-        });
-        const provider = new ArcGisFeatureProvider(settings);
-        await provider.initialize();
-        const featureInfos = [];
-        const logErrorSpy = sandbox.spy(Logger, "logError");
-        await provider.getFeatureInfo(featureInfos, new QuadId(0, 0, 0), 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 = ImageMapLayerSettings.fromJSON({
-            ...esriFeatureSampleSource,
-            subLayers: [{ id: 0, name: "layer1", visible: true }, { id: 2, name: "layer2", visible: true }]
-        });
-        sandbox.stub(ArcGisFeatureProvider.prototype, "getLayerMetadata").callsFake(async function (_id) {
-            return {
-                defaultVisibility: true,
-                supportedQueryFormats: "PBF, JSON",
-                minScale: 600000,
-                maxScale: 5000,
-            };
-        });
-        sandbox.stub(ArcGisUtilities, "getServiceJson").callsFake(async function _(_url, _formatId, _userName, _password, _ignoreCache, _requireToken) {
-            return { accessTokenRequired: false, content: { capabilities: "Query" } };
-        });
-        sandbox.stub(ArcGisFeatureResponse.prototype, "getResponseData").callsFake(async function _() {
-            throw new Error();
-        });
-        const provider = new ArcGisFeatureProvider(settings);
-        await provider.initialize();
-        const featureInfos = [];
-        const logErrorSpy = sandbox.spy(Logger, "logError");
-        await provider.getFeatureInfo(featureInfos, new QuadId(0, 0, 0), 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 = ImageMapLayerSettings.fromJSON({
-            ...esriFeatureSampleSource,
-            subLayers: [{ id: 0, name: "layer1", visible: true }, { id: 2, name: "layer2", visible: true }]
-        });
-        sandbox.stub(ArcGisFeatureProvider.prototype, "getLayerMetadata").callsFake(async function (_id) {
-            return {
-                defaultVisibility: true,
-                supportedQueryFormats: "PBF, JSON",
-                minScale: 600000,
-                maxScale: 5000,
-            };
-        });
-        sandbox.stub(ArcGisUtilities, "getServiceJson").callsFake(async function _(_url, _formatId, _userName, _password, _ignoreCache, _requireToken) {
-            return { accessTokenRequired: false, content: { capabilities: "Query" } };
-        });
-        sandbox.stub(ArcGisFeatureResponse.prototype, "getResponseData").callsFake(async function _() {
-            return { data: {
-                    toObject: () => undefined,
-                } };
-        });
-        const provider = new ArcGisFeatureProvider(settings);
-        await provider.initialize();
-        provider._debugFeatureGeom = true;
-        const featureInfos = [];
-        const logInfoSpy = sandbox.spy(Logger, "logInfo");
-        await provider.getFeatureInfo(featureInfos, new QuadId(0, 0, 0), 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 = 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 ArcGisFeatureProvider(settings);
-        const getEPSG3857ExtentStub = sandbox.stub(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 = Point3d.createFrom({ x: worldSize * 0.5, y: worldSize * 0.5, z: 0 });
-        let transformedPoint = transform === null || transform === void 0 ? void 0 : 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 = Point3d.createFrom({ x: 0, y: 10, z: 0 });
-        transformedPoint = transform === null || transform === void 0 ? void 0 : 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(ArcGisFeatureProvider.prototype, "getEPSG3857Extent").callsFake(function (_row, _column, _zoomLevel) {
-            return { left: worldSize, right: worldSize * 2, bottom: worldSize, top: worldSize * 2 };
-        });
-        worldPoint = Point3d.createFrom({ x: worldSize, y: worldSize, z: 0 });
-        transform = provider.computeTileWorld2CanvasTransform(0, 0, 0);
-        transformedPoint = transform === null || transform === void 0 ? void 0 : 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 = ImageMapLayerSettings.fromJSON({
-            ...esriFeatureSampleSource,
-            subLayers: [{ id: 0, name: "layer1", visible: true }, { id: 2, name: "layer2", visible: true }]
-        });
-        sandbox.stub(ArcGisFeatureProvider.prototype, "getLayerMetadata").callsFake(async function (_id) {
-            return {
-                defaultVisibility: true,
-                supportedQueryFormats: "PBF",
-                supportsCoordinatesQuantization: true,
-            };
-        });
-        sandbox.stub(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(ArcGisFeatureProvider.prototype, "fetchTile").callsFake(async function _() {
-            return new ArcGisFeatureResponse("PBF", Promise.resolve({}));
-        });
-        sandbox.stub(ArcGisFeatureResponse.prototype, "getResponseData").callsFake(async function _() {
-            return {
-                exceedTransferLimit: false,
-                data: { toObject: () => undefined },
-            };
-        });
-        //    toDataURL string;
-        const readAndRenderSpy = sandbox.spy(ArcGisFeaturePBF.prototype, "readAndRender");
-        const computeTransfoSpy = sandbox.spy(ArcGisFeatureProvider.prototype, "computeTileWorld2CanvasTransform");
-        const provider = new ArcGisFeatureProvider(settings);
-        await provider.initialize();
-        const tileData = await provider.loadTile(0, 0, 0);
-        expect(tileData).to.not.undefined;
-        expect((tileData === null || tileData === void 0 ? void 0 : tileData.data) instanceof Uint8Array).to.be.true;
-        expect(tileData === null || tileData === void 0 ? void 0 : tileData.data).to.eqls(base64StringToUint8Array(pngTransparent1x1));
-        expect(tileData === null || tileData === void 0 ? void 0 : tileData.format).to.equals(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 = ImageMapLayerSettings.fromJSON({
-            ...esriFeatureSampleSource,
-            subLayers: [{ id: 0, name: "layer1", visible: true }, { id: 2, name: "layer2", visible: true }]
-        });
-        sandbox.stub(ArcGisFeatureProvider.prototype, "getLayerMetadata").callsFake(async function (_id) {
-            return {
-                defaultVisibility: true,
-                supportedQueryFormats: "JSON",
-            };
-        });
-        sandbox.stub(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(ArcGisFeatureProvider.prototype, "fetchTile").callsFake(async function _() {
-            return new ArcGisFeatureResponse("JSON", Promise.resolve({}));
-        });
-        sandbox.stub(ArcGisFeatureResponse.prototype, "getResponseData").callsFake(async function _() {
-            return {
-                exceedTransferLimit: false,
-                data: { toObject: () => undefined },
-            };
-        });
-        const readAndRenderSpy = sandbox.spy(ArcGisFeatureJSON.prototype, "readAndRender");
-        const computeTransfoSpy = sandbox.spy(ArcGisFeatureProvider.prototype, "computeTileWorld2CanvasTransform");
-        const provider = new ArcGisFeatureProvider(settings);
-        await provider.initialize();
-        const tileData = await provider.loadTile(0, 0, 0);
-        expect(tileData).to.not.undefined;
-        expect((tileData === null || tileData === void 0 ? void 0 : tileData.data) instanceof Uint8Array).to.be.true;
-        expect(tileData === null || tileData === void 0 ? void 0 : tileData.data).to.eqls(base64StringToUint8Array(pngTransparent1x1));
-        expect(tileData === null || tileData === void 0 ? void 0 : tileData.format).to.equals(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 = ImageMapLayerSettings.fromJSON({
-            ...esriFeatureSampleSource,
-            subLayers: [{ id: 0, name: "layer1", visible: true }, { id: 2, name: "layer2", visible: true }]
-        });
-        sandbox.stub(ArcGisFeatureProvider.prototype, "getLayerMetadata").callsFake(async function (_id) {
-            return {
-                defaultVisibility: true,
-                supportedQueryFormats: "JSON",
-            };
-        });
-        sandbox.stub(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(ArcGisFeatureProvider.prototype, "fetchTile").callsFake(async function _() {
-            const envelope = {
-                xmin: 0,
-                ymin: 0,
-                xmax: extentSize,
-                ymax: extentSize,
-                spatialReference: {
-                    wkid: 102100,
-                    latestWkid: 3857,
-                }
-            };
-            return new ArcGisFeatureResponse("JSON", Promise.resolve({}), envelope);
-        });
-        let firstCall = true;
-        sandbox.stub(ArcGisFeatureResponse.prototype, "getResponseData").callsFake(async function _() {
-            const exceed = firstCall === true;
-            firstCall = false;
-            return {
-                exceedTransferLimit: exceed,
-                data: { toObject: () => undefined },
-            };
-        });
-        const readAndRenderSpy = sandbox.spy(ArcGisFeatureJSON.prototype, "readAndRender");
-        const provider = new 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 = ImageMapLayerSettings.fromJSON({
-            ...esriFeatureSampleSource,
-            subLayers: [{ id: 0, name: "layer1", visible: true }, { id: 2, name: "layer2", visible: true }]
-        });
-        const provider = new 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 = ImageMapLayerSettings.fromJSON({
-            ...esriFeatureSampleSource,
-            subLayers: [{ id: 0, name: "layer1", visible: true }, { id: 2, name: "layer2", visible: true }]
-        });
-        sandbox.stub(ArcGisFeatureProvider.prototype, "getLayerMetadata").callsFake(async function (_id) {
-            return {
-                defaultVisibility: true,
-                supportedQueryFormats: "JSON",
-            };
-        });
-        sandbox.stub(ArcGisUtilities, "getServiceJson").callsFake(async function _(_url, _formatId, _userName, _password, _ignoreCache, _requireToken) {
-            return { accessTokenRequired: false, content: { capabilities: "Query" } };
-        });
-        const fetchStub = sandbox.stub(ArcGISImageryProvider.prototype, "fetch");
-        sandbox.stub(ArcGisFeatureProvider.prototype, "constructFeatureUrl").callsFake(function _(_row, _column, _zoomLevel, _format, _geomOverride, _outFields, _tolerance, _returnGeometry) {
-            return { url: settings.url };
-        });
-        const provider = new 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());
-    });
-});
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+import { Base64EncodedString, Cartographic, ImageMapLayerSettings, ImageSourceFormat, ServerError } from "@itwin/core-common";
+import * as chai from "chai";
+import * as chaiAsPromised from "chai-as-promised";
+import { ArcGisFeatureMapLayerFormat } from "../../ArcGisFeature/ArcGisFeatureFormat";
+import { ArcGisFeatureProvider } from "../../map-layers-formats";
+import * as sinon from "sinon";
+import { ArcGISImageryProvider, ArcGisUtilities, MapLayerImageryProviderStatus, QuadId } from "@itwin/core-frontend";
+import { NewYorkDataset } from "./NewYorkDataset";
+import { base64StringToUint8Array, ByteStream, Logger } from "@itwin/core-bentley";
+import { PhillyLandmarksDataset } from "./PhillyLandmarksDataset";
+import { ArcGisFeatureResponse } from "../../ArcGisFeature/ArcGisFeatureResponse";
+import { Point3d } from "@itwin/core-geometry";
+import { ArcGisFeaturePBF } from "../../ArcGisFeature/ArcGisFeaturePBF";
+import { ArcGisFeatureJSON } from "../../ArcGisFeature/ArcGisFeatureJSON";
+const expect = chai.expect;
+chai.use(chaiAsPromised);
+const esriFeatureSampleSource = { name: "dummyFeatureLayer", url: "https://dummy.com", formatId: ArcGisFeatureMapLayerFormat.formatId };
+const pngTransparent1x1 = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==";
+describe("ArcGisFeatureProvider", () => {
+    const sandbox = sinon.createSandbox();
+    afterEach(async () => {
+        sandbox.restore();
+    });
+    it("should initialize with valid data", async () => {
+        sandbox.stub(ArcGisUtilities, "getServiceJson").callsFake(async function _(_url, _formatId, _userName, _password, _ignoreCache, _requireToken) {
+            return { accessTokenRequired: false, content: NewYorkDataset.serviceCapabilities };
+        });
+        sandbox.stub(ArcGisFeatureProvider.prototype, "getLayerMetadata").callsFake(async function _(_layerId) {
+            return NewYorkDataset.streetsLayerCapabilities;
+        });
+        const settings = ImageMapLayerSettings.fromJSON(esriFeatureSampleSource);
+        const provider = new ArcGisFeatureProvider(settings);
+        await provider.initialize();
+        expect(provider._minDepthFromLod).to.equals(11);
+        expect(provider._maxDepthFromLod).to.equals(22);
+    });
+    it("should not initialize with no service metadata", async () => {
+        sandbox.stub(ArcGisUtilities, "getServiceJson").callsFake(async function _(_url, _formatId, _userName, _password, _ignoreCache, _requireToken) {
+            return undefined;
+        });
+        const settings = ImageMapLayerSettings.fromJSON(esriFeatureSampleSource);
+        const provider = new ArcGisFeatureProvider(settings);
+        await expect(provider.initialize()).to.be.rejectedWith(ServerError);
+    });
+    it("should update status when invalid token error from service", async () => {
+        sandbox.stub(ArcGisUtilities, "getServiceJson").callsFake(async function _(_url, _formatId, _userName, _password, _ignoreCache, _requireToken) {
+            return { accessTokenRequired: false, content: { error: { code: 499 } } };
+        });
+        const settings = ImageMapLayerSettings.fromJSON(esriFeatureSampleSource);
+        const provider = new ArcGisFeatureProvider(settings);
+        const raiseEventSpy = sandbox.spy(provider.onStatusChanged, "raiseEvent");
+        await provider.initialize();
+        expect(provider.status).to.equals(MapLayerImageryProviderStatus.RequireAuth);
+        expect(raiseEventSpy.calledOnceWith(provider)).to.be.true;
+    });
+    it("should throw    query capability not supported", async () => {
+        sandbox.stub(ArcGisUtilities, "getServiceJson").callsFake(async function _(_url, _formatId, _userName, _password, _ignoreCache, _requireToken) {
+            return { accessTokenRequired: false, content: { capabilities: "Test" } };
+        });
+        const settings = ImageMapLayerSettings.fromJSON(esriFeatureSampleSource);
+        const provider = new ArcGisFeatureProvider(settings);
+        await expect(provider.initialize()).to.be.rejectedWith(ServerError);
+    });
+    it("should pick the first visible sub-layer when multiple visible sub-layers", async () => {
+        sandbox.stub(ArcGisUtilities, "getServiceJson").callsFake(async function _(_url, _formatId, _userName, _password, _ignoreCache, _requireToken) {
+            return { accessTokenRequired: false, content: { capabilities: "Query" } };
+        });
+        const settings = ImageMapLayerSettings.fromJSON({
+            ...esriFeatureSampleSource,
+            subLayers: [{ id: 0, name: "layer1", visible: true }, { id: 2, name: "layer2", visible: true }]
+        });
+        const provider = new 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(ArcGisUtilities, "getServiceJson").callsFake(async function _(_url, _formatId, _userName, _password, _ignoreCache, _requireToken) {
+            return { accessTokenRequired: false, content: { capabilities: "Query",
+                    layers: [
+                        {
+                            id: 0,
+                        },
+                        {
+                            id: 1,
+                        },
+                    ] },
+            };
+        });
+        sandbox.stub(ArcGisFeatureProvider.prototype, "getLayerMetadata").callsFake(async function (id) {
+            if (id === 1) {
+                return { defaultVisibility: true };
+            }
+            return undefined;
+        });
+        const settings = ImageMapLayerSettings.fromJSON(esriFeatureSampleSource);
+        const provider = new 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(ArcGisUtilities, "getServiceJson").callsFake(async function _(_url, _formatId, _userName, _password, _ignoreCache, _requireToken) {
+            return { accessTokenRequired: false, content: { capabilities: "Query", layers: [] } };
+        });
+        const settings = ImageMapLayerSettings.fromJSON(esriFeatureSampleSource);
+        const provider = new ArcGisFeatureProvider(settings);
+        await expect(provider.initialize()).to.be.rejectedWith(ServerError);
+    });
+    it("should throw if no layer metadata from service", async () => {
+        const settings = ImageMapLayerSettings.fromJSON({
+            ...esriFeatureSampleSource,
+            subLayers: [{ id: 0, name: "layer1", visible: true }, { id: 2, name: "layer2", visible: true }]
+        });
+        sandbox.stub(ArcGisUtilities, "getServiceJson").callsFake(async function _(_url, _formatId, _userName, _password, _ignoreCache, _requireToken) {
+            return { accessTokenRequired: false, content: { capabilities: "Query" } };
+        });
+        sandbox.stub(ArcGisFeatureProvider.prototype, "getLayerMetadata").callsFake(async function (_id) {
+            return undefined;
+        });
+        const provider = new ArcGisFeatureProvider(settings);
+        await expect(provider.initialize()).to.be.rejectedWith(ServerError);
+    });
+    it("should read supported supported format", async () => {
+        const settings = ImageMapLayerSettings.fromJSON({
+            ...esriFeatureSampleSource,
+            subLayers: [{ id: 0, name: "layer1", visible: true }, { id: 2, name: "layer2", visible: true }]
+        });
+        let getLayerMetadataStub = sandbox.stub(ArcGisFeatureProvider.prototype, "getLayerMetadata").callsFake(async function (_id) {
+            return { defaultVisibility: true, supportedQueryFormats: "PBF, JSON" };
+        });
+        const getServiceJsonStub = sandbox.stub(ArcGisUtilities, "getServiceJson").callsFake(async function _(_url, _formatId, _userName, _password, _ignoreCache, _requireToken) {
+            return { accessTokenRequired: false, content: { capabilities: "Query" } };
+        });
+        let provider = new ArcGisFeatureProvider(settings);
+        await provider.initialize();
+        expect(provider.format).to.equals("JSON");
+        // PBF requires 'supportsCoordinatesQuantization'
+        getServiceJsonStub.restore();
+        sandbox.stub(ArcGisUtilities, "getServiceJson").callsFake(async function _(_url, _formatId, _userName, _password, _ignoreCache, _requireToken) {
+            return { accessTokenRequired: false, content: { currentVersion: 11, capabilities: "Query" } };
+        });
+        getLayerMetadataStub.restore();
+        getLayerMetadataStub = sandbox.stub(ArcGisFeatureProvider.prototype, "getLayerMetadata").callsFake(async function (_id) {
+            return { defaultVisibility: true, supportsCoordinatesQuantization: true, supportedQueryFormats: "PBF, JSON" };
+        });
+        provider = new ArcGisFeatureProvider(settings);
+        await provider.initialize();
+        expect(provider.format).to.equals("PBF");
+        getLayerMetadataStub.restore();
+        getLayerMetadataStub = sandbox.stub(ArcGisFeatureProvider.prototype, "getLayerMetadata").callsFake(async function (_id) {
+            return { defaultVisibility: true, supportedQueryFormats: "JSON" };
+        });
+        getServiceJsonStub.restore();
+        sandbox.stub(ArcGisUtilities, "getServiceJson").callsFake(async function _(_url, _formatId, _userName, _password, _ignoreCache, _requireToken) {
+            return { accessTokenRequired: false, content: { currentVersion: 10.91, capabilities: "Query", supportsCoordinatesQuantization: true } };
+        });
+        provider = new ArcGisFeatureProvider(settings);
+        await provider.initialize();
+        expect(provider.format).to.equals("JSON");
+        getLayerMetadataStub.restore();
+        getLayerMetadataStub = sandbox.stub(ArcGisFeatureProvider.prototype, "getLayerMetadata").callsFake(async function (_id) {
+            return { defaultVisibility: true, supportedQueryFormats: "JSON" };
+        });
+        provider = new ArcGisFeatureProvider(settings);
+        await provider.initialize();
+        expect(provider.format).to.equals("JSON");
+        getLayerMetadataStub.restore();
+        getLayerMetadataStub = sandbox.stub(ArcGisFeatureProvider.prototype, "getLayerMetadata").callsFake(async function (_id) {
+            return { defaultVisibility: true, supportedQueryFormats: "" };
+        });
+        provider = new ArcGisFeatureProvider(settings);
+        await expect(provider.initialize()).to.be.rejectedWith(ServerError);
+    });
+    it("should compute minLod/maxLod", async () => {
+        const settings = ImageMapLayerSettings.fromJSON({
+            ...esriFeatureSampleSource,
+            subLayers: [{ id: 0, name: "layer1", visible: true }, { id: 2, name: "layer2", visible: true }]
+        });
+        sandbox.stub(ArcGisFeatureProvider.prototype, "getLayerMetadata").callsFake(async function (_id) {
+            return {
+                defaultVisibility: true,
+                supportedQueryFormats: "PBF, JSON",
+                minScale: 600000,
+                maxScale: 5000,
+            };
+        });
+        sandbox.stub(ArcGisUtilities, "getServiceJson").callsFake(async function _(_url, _formatId, _userName, _password, _ignoreCache, _requireToken) {
+            return { accessTokenRequired: false, content: { capabilities: "Query" } };
+        });
+        const provider = new 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 = ImageMapLayerSettings.fromJSON(esriFeatureSampleSource);
+        const provider = new ArcGisFeatureProvider(settings);
+        const url = await provider.constructUrl(0, 0, 0);
+        expect(url).to.equals("");
+    });
+    it("should construct feature query url", async () => {
+        const settings = ImageMapLayerSettings.fromJSON({
+            ...esriFeatureSampleSource,
+            subLayers: [{ id: 0, name: "layer1", visible: true }, { id: 2, name: "layer2", visible: true }]
+        });
+        let getLayerMetadataStub = sandbox.stub(ArcGisFeatureProvider.prototype, "getLayerMetadata").callsFake(async function (_id) {
+            return {
+                defaultVisibility: true,
+                supportedQueryFormats: "PBF, JSON",
+            };
+        });
+        sandbox.stub(ArcGisUtilities, "getServiceJson").callsFake(async function _(_url, _formatId, _userName, _password, _ignoreCache, _requireToken) {
+            return { accessTokenRequired: false, content: { currentVersion: 11, capabilities: "Query" } };
+        });
+        const provider = new 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/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(ArcGisFeatureProvider.prototype, "getLayerMetadata").callsFake(async function (_id) {
+            return {
+                defaultVisibility: true,
+                supportedQueryFormats: "PBF, JSON",
+                supportsCoordinatesQuantization: true,
+            };
+        });
+        const provider2 = new ArcGisFeatureProvider(settings);
+        await provider2.initialize();
+        url = provider2.constructFeatureUrl(0, 0, 0, "PBF");
+        expect(url?.url).to.equals(`https://dummy.com/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 ArcGisFeatureProvider(settings);
+        await provider3.initialize();
+        url = provider3.constructFeatureUrl(0, 0, 0, "PBF", overrideGeom);
+        expect(url?.url).to.equals(`https://dummy.com/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/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 = ImageMapLayerSettings.fromJSON({
+            ...esriFeatureSampleSource,
+            subLayers: [{ id: 0, name: "layer1", visible: true }, { id: 2, name: "layer2", visible: true }]
+        });
+        sandbox.stub(ArcGisFeatureProvider.prototype, "getLayerMetadata").callsFake(async function (_id) {
+            return {
+                defaultVisibility: true,
+                supportedQueryFormats: "PBF, JSON",
+                minScale: 600000,
+                maxScale: 5000,
+            };
+        });
+        sandbox.stub(ArcGisUtilities, "getServiceJson").callsFake(async function _(_url, _formatId, _userName, _password, _ignoreCache, _requireToken) {
+            return { accessTokenRequired: false, content: { currentVersion: 11, capabilities: "Query" } };
+        });
+        sandbox.stub(ArcGisFeatureProvider.prototype, "constructFeatureUrl").callsFake(function _(_row, _column, _zoomLevel, _format, _geomOverride, _outFields, _tolerance, _returnGeometry) {
+            return undefined;
+        });
+        const provider = new ArcGisFeatureProvider(settings);
+        await provider.initialize();
+        const featureInfos = [];
+        const logErrorSpy = sandbox.spy(Logger, "logError");
+        await provider.getFeatureInfo(featureInfos, new QuadId(0, 0, 0), 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 = ImageMapLayerSettings.fromJSON({
+            ...esriFeatureSampleSource,
+            subLayers: [{ id: 0, name: "layer1", visible: true }, { id: 2, name: "layer2", visible: true }]
+        });
+        sandbox.stub(ArcGisFeatureProvider.prototype, "getLayerMetadata").callsFake(async function (_id) {
+            return {
+                defaultVisibility: true,
+                supportedQueryFormats: "PBF, JSON",
+                supportsCoordinatesQuantization: true,
+                minScale: 600000,
+                maxScale: 5000,
+            };
+        });
+        sandbox.stub(ArcGisUtilities, "getServiceJson").callsFake(async function _(_url, _formatId, _userName, _password, _ignoreCache, _requireToken) {
+            return { accessTokenRequired: false, content: { currentVersion: 11, capabilities: "Query" } };
+        });
+        sandbox.stub(ArcGISImageryProvider.prototype, "fetch").callsFake(async function _(_url, _options) {
+            const test = {
+                headers: { "content-type": "pbf" },
+                arrayBuffer: async () => {
+                    const byteArray = Base64EncodedString.toUint8Array(PhillyLandmarksDataset.phillyTransportationGetFeatureInfoQueryEncodedPbf);
+                    return Promise.resolve(byteArray ? 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 ArcGisFeatureProvider(settings);
+        await provider.initialize();
+        const featureInfos = [];
+        const logErrorSpy = sandbox.spy(Logger, "logError");
+        await provider.getFeatureInfo(featureInfos, new QuadId(0, 0, 0), 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 = ImageMapLayerSettings.fromJSON({
+            ...esriFeatureSampleSource,
+            subLayers: [{ id: 0, name: "layer1", visible: true }, { id: 2, name: "layer2", visible: true }]
+        });
+        sandbox.stub(ArcGisFeatureProvider.prototype, "getLayerMetadata").callsFake(async function (_id) {
+            return {
+                defaultVisibility: true,
+                supportedQueryFormats: "PBF, JSON",
+                minScale: 600000,
+                maxScale: 5000,
+            };
+        });
+        sandbox.stub(ArcGisUtilities, "getServiceJson").callsFake(async function _(_url, _formatId, _userName, _password, _ignoreCache, _requireToken) {
+            return { accessTokenRequired: false, content: { capabilities: "Query" } };
+        });
+        sandbox.stub(ArcGisFeatureResponse.prototype, "getResponseData").callsFake(async function _() {
+            return { exceedTransferLimit: true, data: undefined };
+        });
+        const provider = new ArcGisFeatureProvider(settings);
+        await provider.initialize();
+        const featureInfos = [];
+        const logErrorSpy = sandbox.spy(Logger, "logError");
+        await provider.getFeatureInfo(featureInfos, new QuadId(0, 0, 0), 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 = ImageMapLayerSettings.fromJSON({
+            ...esriFeatureSampleSource,
+            subLayers: [{ id: 0, name: "layer1", visible: true }, { id: 2, name: "layer2", visible: true }]
+        });
+        sandbox.stub(ArcGisFeatureProvider.prototype, "getLayerMetadata").callsFake(async function (_id) {
+            return {
+                defaultVisibility: true,
+                supportedQueryFormats: "PBF, JSON",
+                minScale: 600000,
+                maxScale: 5000,
+            };
+        });
+        sandbox.stub(ArcGisUtilities, "getServiceJson").callsFake(async function _(_url, _formatId, _userName, _password, _ignoreCache, _requireToken) {
+            return { accessTokenRequired: false, content: { capabilities: "Query" } };
+        });
+        sandbox.stub(ArcGisFeatureResponse.prototype, "getResponseData").callsFake(async function _() {
+            throw new Error();
+        });
+        const provider = new ArcGisFeatureProvider(settings);
+        await provider.initialize();
+        const featureInfos = [];
+        const logErrorSpy = sandbox.spy(Logger, "logError");
+        await provider.getFeatureInfo(featureInfos, new QuadId(0, 0, 0), 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 = ImageMapLayerSettings.fromJSON({
+            ...esriFeatureSampleSource,
+            subLayers: [{ id: 0, name: "layer1", visible: true }, { id: 2, name: "layer2", visible: true }]
+        });
+        sandbox.stub(ArcGisFeatureProvider.prototype, "getLayerMetadata").callsFake(async function (_id) {
+            return {
+                defaultVisibility: true,
+                supportedQueryFormats: "PBF, JSON",
+                minScale: 600000,
+                maxScale: 5000,
+            };
+        });
+        sandbox.stub(ArcGisUtilities, "getServiceJson").callsFake(async function _(_url, _formatId, _userName, _password, _ignoreCache, _requireToken) {
+            return { accessTokenRequired: false, content: { capabilities: "Query" } };
+        });
+        sandbox.stub(ArcGisFeatureResponse.prototype, "getResponseData").callsFake(async function _() {
+            return { data: {
+                    toObject: () => undefined,
+                } };
+        });
+        const provider = new ArcGisFeatureProvider(settings);
+        await provider.initialize();
+        provider._debugFeatureGeom = true;
+        const featureInfos = [];
+        const logInfoSpy = sandbox.spy(Logger, "logInfo");
+        await provider.getFeatureInfo(featureInfos, new QuadId(0, 0, 0), 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 = 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 ArcGisFeatureProvider(settings);
+        const getEPSG3857ExtentStub = sandbox.stub(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 = 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 = 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(ArcGisFeatureProvider.prototype, "getEPSG3857Extent").callsFake(function (_row, _column, _zoomLevel) {
+            return { left: worldSize, right: worldSize * 2, bottom: worldSize, top: worldSize * 2 };
+        });
+        worldPoint = 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 = ImageMapLayerSettings.fromJSON({
+            ...esriFeatureSampleSource,
+            subLayers: [{ id: 0, name: "layer1", visible: true }, { id: 2, name: "layer2", visible: true }]
+        });
+        sandbox.stub(ArcGisFeatureProvider.prototype, "getLayerMetadata").callsFake(async function (_id) {
+            return {
+                defaultVisibility: true,
+                supportedQueryFormats: "PBF",
+                supportsCoordinatesQuantization: true,
+            };
+        });
+        sandbox.stub(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(ArcGisFeatureProvider.prototype, "fetchTile").callsFake(async function _() {
+            return new ArcGisFeatureResponse("PBF", Promise.resolve({}));
+        });
+        sandbox.stub(ArcGisFeatureResponse.prototype, "getResponseData").callsFake(async function _() {
+            return {
+                exceedTransferLimit: false,
+                data: { toObject: () => undefined },
+            };
+        });
+        //    toDataURL string;
+        const readAndRenderSpy = sandbox.spy(ArcGisFeaturePBF.prototype, "readAndRender");
+        const computeTransfoSpy = sandbox.spy(ArcGisFeatureProvider.prototype, "computeTileWorld2CanvasTransform");
+        const provider = new 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(base64StringToUint8Array(pngTransparent1x1));
+        expect(tileData?.format).to.equals(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 = ImageMapLayerSettings.fromJSON({
+            ...esriFeatureSampleSource,
+            subLayers: [{ id: 0, name: "layer1", visible: true }, { id: 2, name: "layer2", visible: true }]
+        });
+        sandbox.stub(ArcGisFeatureProvider.prototype, "getLayerMetadata").callsFake(async function (_id) {
+            return {
+                defaultVisibility: true,
+                supportedQueryFormats: "JSON",
+            };
+        });
+        sandbox.stub(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(ArcGisFeatureProvider.prototype, "fetchTile").callsFake(async function _() {
+            return new ArcGisFeatureResponse("JSON", Promise.resolve({}));
+        });
+        sandbox.stub(ArcGisFeatureResponse.prototype, "getResponseData").callsFake(async function _() {
+            return {
+                exceedTransferLimit: false,
+                data: { toObject: () => undefined },
+            };
+        });
+        const readAndRenderSpy = sandbox.spy(ArcGisFeatureJSON.prototype, "readAndRender");
+        const computeTransfoSpy = sandbox.spy(ArcGisFeatureProvider.prototype, "computeTileWorld2CanvasTransform");
+        const provider = new 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(base64StringToUint8Array(pngTransparent1x1));
+        expect(tileData?.format).to.equals(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 = ImageMapLayerSettings.fromJSON({
+            ...esriFeatureSampleSource,
+            subLayers: [{ id: 0, name: "layer1", visible: true }, { id: 2, name: "layer2", visible: true }]
+        });
+        sandbox.stub(ArcGisFeatureProvider.prototype, "getLayerMetadata").callsFake(async function (_id) {
+            return {
+                defaultVisibility: true,
+                supportedQueryFormats: "JSON",
+            };
+        });
+        sandbox.stub(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(ArcGisFeatureProvider.prototype, "fetchTile").callsFake(async function _() {
+            const envelope = {
+                xmin: 0,
+                ymin: 0,
+                xmax: extentSize,
+                ymax: extentSize,
+                spatialReference: {
+                    wkid: 102100,
+                    latestWkid: 3857,
+                }
+            };
+            return new ArcGisFeatureResponse("JSON", Promise.resolve({}), envelope);
+        });
+        let firstCall = true;
+        sandbox.stub(ArcGisFeatureResponse.prototype, "getResponseData").callsFake(async function _() {
+            const exceed = firstCall === true;
+            firstCall = false;
+            return {
+                exceedTransferLimit: exceed,
+                data: { toObject: () => undefined },
+            };
+        });
+        const readAndRenderSpy = sandbox.spy(ArcGisFeatureJSON.prototype, "readAndRender");
+        const provider = new 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 = ImageMapLayerSettings.fromJSON({
+            ...esriFeatureSampleSource,
+            subLayers: [{ id: 0, name: "layer1", visible: true }, { id: 2, name: "layer2", visible: true }]
+        });
+        const provider = new 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 = ImageMapLayerSettings.fromJSON({
+            ...esriFeatureSampleSource,
+            subLayers: [{ id: 0, name: "layer1", visible: true }, { id: 2, name: "layer2", visible: true }]
+        });
+        sandbox.stub(ArcGisFeatureProvider.prototype, "getLayerMetadata").callsFake(async function (_id) {
+            return {
+                defaultVisibility: true,
+                supportedQueryFormats: "JSON",
+            };
+        });
+        sandbox.stub(ArcGisUtilities, "getServiceJson").callsFake(async function _(_url, _formatId, _userName, _password, _ignoreCache, _requireToken) {
+            return { accessTokenRequired: false, content: { capabilities: "Query" } };
+        });
+        const fetchStub = sandbox.stub(ArcGISImageryProvider.prototype, "fetch");
+        sandbox.stub(ArcGisFeatureProvider.prototype, "constructFeatureUrl").callsFake(function _(_row, _column, _zoomLevel, _format, _geomOverride, _outFields, _tolerance, _returnGeometry) {
+            return { url: settings.url };
+        });
+        const provider = new 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