982 lines
35 KiB
JavaScript
982 lines
35 KiB
JavaScript
defineSuite([
|
|
'Scene/ArcGisMapServerImageryProvider',
|
|
'Core/appendForwardSlash',
|
|
'Core/Cartesian2',
|
|
'Core/Cartesian3',
|
|
'Core/Cartographic',
|
|
'Core/DefaultProxy',
|
|
'Core/defined',
|
|
'Core/GeographicTilingScheme',
|
|
'Core/getAbsoluteUri',
|
|
'Core/objectToQuery',
|
|
'Core/queryToObject',
|
|
'Core/Rectangle',
|
|
'Core/RequestScheduler',
|
|
'Core/Resource',
|
|
'Core/WebMercatorProjection',
|
|
'Core/WebMercatorTilingScheme',
|
|
'Scene/DiscardMissingTileImagePolicy',
|
|
'Scene/Imagery',
|
|
'Scene/ImageryLayer',
|
|
'Scene/ImageryLayerFeatureInfo',
|
|
'Scene/ImageryProvider',
|
|
'Scene/ImageryState',
|
|
'Specs/pollToPromise',
|
|
'ThirdParty/Uri'
|
|
], function(
|
|
ArcGisMapServerImageryProvider,
|
|
appendForwardSlash,
|
|
Cartesian2,
|
|
Cartesian3,
|
|
Cartographic,
|
|
DefaultProxy,
|
|
defined,
|
|
GeographicTilingScheme,
|
|
getAbsoluteUri,
|
|
objectToQuery,
|
|
queryToObject,
|
|
Rectangle,
|
|
RequestScheduler,
|
|
Resource,
|
|
WebMercatorProjection,
|
|
WebMercatorTilingScheme,
|
|
DiscardMissingTileImagePolicy,
|
|
Imagery,
|
|
ImageryLayer,
|
|
ImageryLayerFeatureInfo,
|
|
ImageryProvider,
|
|
ImageryState,
|
|
pollToPromise,
|
|
Uri) {
|
|
'use strict';
|
|
|
|
beforeEach(function() {
|
|
RequestScheduler.clearForSpecs();
|
|
});
|
|
|
|
afterEach(function() {
|
|
Resource._Implementations.loadAndExecuteScript = Resource._DefaultImplementations.loadAndExecuteScript;
|
|
Resource._Implementations.createImage = Resource._DefaultImplementations.createImage;
|
|
Resource._Implementations.loadWithXhr = Resource._DefaultImplementations.loadWithXhr;
|
|
});
|
|
|
|
function expectCorrectUrl(expectedBaseUrl, actualUrl, functionName, withProxy, token) {
|
|
var uri = new Uri(actualUrl);
|
|
|
|
if (withProxy) {
|
|
uri = new Uri(decodeURIComponent(uri.query));
|
|
}
|
|
|
|
var params = queryToObject(uri.query);
|
|
|
|
var uriWithoutQuery = new Uri(uri);
|
|
uriWithoutQuery.query = '';
|
|
|
|
expect(uriWithoutQuery.toString()).toEqual(appendForwardSlash(expectedBaseUrl));
|
|
|
|
var expectedParams = {
|
|
callback : functionName,
|
|
'f' : 'json'
|
|
};
|
|
if (defined(token)) {
|
|
expectedParams.token = token;
|
|
}
|
|
expect(params).toEqual(expectedParams);
|
|
}
|
|
|
|
function stubJSONPCall(baseUrl, result, withProxy, token) {
|
|
Resource._Implementations.loadAndExecuteScript = function(url, functionName) {
|
|
expectCorrectUrl(baseUrl, url, functionName, withProxy, token);
|
|
setTimeout(function() {
|
|
window[functionName](result);
|
|
}, 1);
|
|
};
|
|
}
|
|
|
|
it('conforms to ImageryProvider interface', function() {
|
|
expect(ArcGisMapServerImageryProvider).toConformToInterface(ImageryProvider);
|
|
});
|
|
|
|
it('constructor throws if url is not specified', function() {
|
|
expect(function() {
|
|
return new ArcGisMapServerImageryProvider({});
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
var webMercatorResult = {
|
|
'currentVersion' : 10.01,
|
|
'copyrightText' : 'Test copyright text',
|
|
'tileInfo' : {
|
|
'rows' : 128,
|
|
'cols' : 256,
|
|
'origin' : {
|
|
'x' : -20037508.342787,
|
|
'y' : 20037508.342787
|
|
},
|
|
'spatialReference' : {
|
|
'wkid' : 102100
|
|
},
|
|
'lods' : [{
|
|
'level' : 0,
|
|
'resolution' : 156543.033928,
|
|
'scale' : 591657527.591555
|
|
}, {
|
|
'level' : 1,
|
|
'resolution' : 78271.5169639999,
|
|
'scale' : 295828763.795777
|
|
}, {
|
|
'level' : 2,
|
|
'resolution' : 39135.7584820001,
|
|
'scale' : 147914381.897889
|
|
}]
|
|
}
|
|
};
|
|
|
|
it('resolves readyPromise', function() {
|
|
var baseUrl = '//tiledArcGisMapServer.invalid';
|
|
|
|
stubJSONPCall(baseUrl, webMercatorResult);
|
|
|
|
var provider = new ArcGisMapServerImageryProvider({
|
|
url : baseUrl
|
|
});
|
|
|
|
return provider.readyPromise.then(function(result) {
|
|
expect(result).toBe(true);
|
|
expect(provider.ready).toBe(true);
|
|
});
|
|
});
|
|
|
|
it('resolves readyPromise with Resource', function() {
|
|
var baseUrl = '//tiledArcGisMapServer.invalid';
|
|
|
|
stubJSONPCall(baseUrl, webMercatorResult);
|
|
|
|
var resource = new Resource({
|
|
url : baseUrl
|
|
});
|
|
|
|
var provider = new ArcGisMapServerImageryProvider({
|
|
url : resource
|
|
});
|
|
|
|
return provider.readyPromise.then(function(result) {
|
|
expect(result).toBe(true);
|
|
expect(provider.ready).toBe(true);
|
|
});
|
|
});
|
|
|
|
it('rejects readyPromise on error', function() {
|
|
var baseUrl = '//tiledArcGisMapServer.invalid';
|
|
|
|
var provider = new ArcGisMapServerImageryProvider({
|
|
url : baseUrl
|
|
});
|
|
|
|
return provider.readyPromise.then(function () {
|
|
fail('should not resolve');
|
|
}).otherwise(function (e) {
|
|
expect(e.message).toContain(baseUrl);
|
|
expect(provider.ready).toBe(false);
|
|
});
|
|
});
|
|
|
|
it('supports tiled servers in web mercator projection', function() {
|
|
var baseUrl = '//tiledArcGisMapServer.invalid/';
|
|
|
|
stubJSONPCall(baseUrl, webMercatorResult);
|
|
|
|
var provider = new ArcGisMapServerImageryProvider({
|
|
url : baseUrl
|
|
});
|
|
|
|
expect(provider.url).toEqual(baseUrl);
|
|
|
|
return pollToPromise(function() {
|
|
return provider.ready;
|
|
}).then(function() {
|
|
expect(provider.tileWidth).toEqual(128);
|
|
expect(provider.tileHeight).toEqual(256);
|
|
expect(provider.maximumLevel).toEqual(2);
|
|
expect(provider.tilingScheme).toBeInstanceOf(WebMercatorTilingScheme);
|
|
expect(provider.credit).toBeDefined();
|
|
expect(provider.tileDiscardPolicy).toBeInstanceOf(DiscardMissingTileImagePolicy);
|
|
expect(provider.rectangle).toEqual(new WebMercatorTilingScheme().rectangle);
|
|
expect(provider.usingPrecachedTiles).toEqual(true);
|
|
expect(provider.hasAlphaChannel).toBeDefined();
|
|
|
|
Resource._Implementations.createImage = function(url, crossOrigin, deferred) {
|
|
if (/^blob:/.test(url)) {
|
|
// load blob url normally
|
|
Resource._DefaultImplementations.createImage(url, crossOrigin, deferred);
|
|
} else {
|
|
expect(url).toEqual(getAbsoluteUri(baseUrl + 'tile/0/0/0'));
|
|
|
|
// Just return any old image.
|
|
Resource._DefaultImplementations.createImage('Data/Images/Red16x16.png', crossOrigin, deferred);
|
|
}
|
|
};
|
|
|
|
Resource._Implementations.loadWithXhr = function(url, responseType, method, data, headers, deferred, overrideMimeType) {
|
|
expect(url).toEqual(getAbsoluteUri(baseUrl + 'tile/0/0/0'));
|
|
|
|
// Just return any old image.
|
|
Resource._DefaultImplementations.loadWithXhr('Data/Images/Red16x16.png', responseType, method, data, headers, deferred);
|
|
};
|
|
|
|
return provider.requestImage(0, 0, 0).then(function(image) {
|
|
expect(image).toBeInstanceOf(Image);
|
|
});
|
|
});
|
|
});
|
|
|
|
var geographicResult = {
|
|
'currentVersion' : 10.01,
|
|
'copyrightText' : 'Test copyright text',
|
|
'tileInfo' : {
|
|
'rows' : 128,
|
|
'cols' : 256,
|
|
'origin' : {
|
|
'x' : -180,
|
|
'y' : 90
|
|
},
|
|
'spatialReference' : {
|
|
'wkid' : 4326
|
|
},
|
|
'lods' : [{
|
|
'level' : 0,
|
|
'resolution' : 0.3515625,
|
|
'scale' : 147748799.285417
|
|
}, {
|
|
'level' : 1,
|
|
'resolution' : 0.17578125,
|
|
'scale' : 73874399.6427087
|
|
}, {
|
|
'level' : 2,
|
|
'resolution' : 0.087890625,
|
|
'scale' : 36937199.8213544
|
|
}]
|
|
}
|
|
};
|
|
|
|
it('supports tiled servers in geographic projection', function() {
|
|
var baseUrl = '//tiledArcGisMapServer.invalid/';
|
|
|
|
stubJSONPCall(baseUrl, geographicResult);
|
|
|
|
var provider = new ArcGisMapServerImageryProvider({
|
|
url : baseUrl
|
|
});
|
|
|
|
expect(provider.url).toEqual(baseUrl);
|
|
|
|
return pollToPromise(function() {
|
|
return provider.ready;
|
|
}).then(function() {
|
|
expect(provider.tileWidth).toEqual(128);
|
|
expect(provider.tileHeight).toEqual(256);
|
|
expect(provider.maximumLevel).toEqual(2);
|
|
expect(provider.tilingScheme).toBeInstanceOf(GeographicTilingScheme);
|
|
expect(provider.credit).toBeDefined();
|
|
expect(provider.tileDiscardPolicy).toBeInstanceOf(DiscardMissingTileImagePolicy);
|
|
expect(provider.rectangle).toEqual(new GeographicTilingScheme().rectangle);
|
|
expect(provider.usingPrecachedTiles).toEqual(true);
|
|
|
|
Resource._Implementations.createImage = function(url, crossOrigin, deferred) {
|
|
if (/^blob:/.test(url)) {
|
|
// load blob url normally
|
|
Resource._DefaultImplementations.createImage(url, crossOrigin, deferred);
|
|
} else {
|
|
expect(url).toEqual(getAbsoluteUri(baseUrl + 'tile/0/0/0'));
|
|
|
|
// Just return any old image.
|
|
Resource._DefaultImplementations.createImage('Data/Images/Red16x16.png', crossOrigin, deferred);
|
|
}
|
|
};
|
|
|
|
Resource._Implementations.loadWithXhr = function(url, responseType, method, data, headers, deferred, overrideMimeType) {
|
|
expect(url).toEqual(getAbsoluteUri(baseUrl + 'tile/0/0/0'));
|
|
|
|
// Just return any old image.
|
|
Resource._DefaultImplementations.loadWithXhr('Data/Images/Red16x16.png', responseType, method, data, headers, deferred);
|
|
};
|
|
|
|
return provider.requestImage(0, 0, 0).then(function(image) {
|
|
expect(image).toBeInstanceOf(Image);
|
|
});
|
|
});
|
|
});
|
|
|
|
it('supports non-tiled servers', function() {
|
|
var baseUrl = '//tiledArcGisMapServer.invalid/';
|
|
|
|
stubJSONPCall(baseUrl, {
|
|
'currentVersion' : 10.01,
|
|
'copyrightText' : 'Test copyright text'
|
|
});
|
|
|
|
var provider = new ArcGisMapServerImageryProvider({
|
|
url : baseUrl
|
|
});
|
|
|
|
expect(provider.url).toEqual(baseUrl);
|
|
|
|
return pollToPromise(function() {
|
|
return provider.ready;
|
|
}).then(function() {
|
|
expect(provider.tileWidth).toEqual(256);
|
|
expect(provider.tileHeight).toEqual(256);
|
|
expect(provider.maximumLevel).toBeUndefined();
|
|
expect(provider.tilingScheme).toBeInstanceOf(GeographicTilingScheme);
|
|
expect(provider.credit).toBeDefined();
|
|
expect(provider.tileDiscardPolicy).toBeUndefined();
|
|
expect(provider.rectangle).toEqual(new GeographicTilingScheme().rectangle);
|
|
expect(provider.usingPrecachedTiles).toEqual(false);
|
|
expect(provider.enablePickFeatures).toBe(true);
|
|
|
|
Resource._Implementations.createImage = function(url, crossOrigin, deferred) {
|
|
var uri = new Uri(url);
|
|
var params = queryToObject(uri.query);
|
|
|
|
var uriWithoutQuery = new Uri(uri);
|
|
uriWithoutQuery.query = '';
|
|
|
|
expect(uriWithoutQuery.toString()).toEqual(getAbsoluteUri(baseUrl + 'export'));
|
|
|
|
expect(params.f).toEqual('image');
|
|
expect(params.bboxSR).toEqual('4326');
|
|
expect(params.imageSR).toEqual('4326');
|
|
expect(params.format).toEqual('png');
|
|
expect(params.transparent).toEqual('true');
|
|
expect(params.size).toEqual('256,256');
|
|
|
|
// Just return any old image.
|
|
Resource._DefaultImplementations.createImage('Data/Images/Red16x16.png', crossOrigin, deferred);
|
|
};
|
|
|
|
return provider.requestImage(0, 0, 0).then(function(image) {
|
|
expect(image).toBeInstanceOf(Image);
|
|
});
|
|
});
|
|
});
|
|
|
|
it('supports non-tiled servers with various constructor parameters', function() {
|
|
var baseUrl = '//tiledArcGisMapServer.invalid/';
|
|
var token = '5e(u|2!7Y';
|
|
|
|
stubJSONPCall(baseUrl, {
|
|
'currentVersion' : 10.01,
|
|
'copyrightText' : 'Test copyright text'
|
|
}, undefined, token);
|
|
|
|
var provider = new ArcGisMapServerImageryProvider({
|
|
url : baseUrl,
|
|
token: token,
|
|
tileWidth: 128,
|
|
tileHeight: 512,
|
|
tilingScheme: new WebMercatorTilingScheme(),
|
|
rectangle: Rectangle.fromDegrees(1.0, 2.0, 3.0, 4.0),
|
|
layers: 'foo,bar',
|
|
enablePickFeatures: false
|
|
});
|
|
|
|
expect(provider.url).toEqual(baseUrl);
|
|
|
|
return pollToPromise(function() {
|
|
return provider.ready;
|
|
}).then(function() {
|
|
expect(provider.tileWidth).toEqual(128);
|
|
expect(provider.tileHeight).toEqual(512);
|
|
expect(provider.maximumLevel).toBeUndefined();
|
|
expect(provider.tilingScheme).toBeInstanceOf(WebMercatorTilingScheme);
|
|
expect(provider.credit).toBeDefined();
|
|
expect(provider.tileDiscardPolicy).toBeUndefined();
|
|
expect(provider.rectangle).toEqual(Rectangle.fromDegrees(1.0, 2.0, 3.0, 4.0));
|
|
expect(provider.usingPrecachedTiles).toBe(false);
|
|
expect(provider.enablePickFeatures).toBe(false);
|
|
expect(provider.layers).toEqual('foo,bar');
|
|
|
|
Resource._Implementations.createImage = function(url, crossOrigin, deferred) {
|
|
var uri = new Uri(url);
|
|
var params = queryToObject(uri.query);
|
|
|
|
var uriWithoutQuery = new Uri(uri);
|
|
uriWithoutQuery.query = '';
|
|
|
|
expect(uriWithoutQuery.toString()).toEqual(getAbsoluteUri(baseUrl + 'export'));
|
|
|
|
expect(params.f).toEqual('image');
|
|
expect(params.bboxSR).toEqual('3857');
|
|
expect(params.imageSR).toEqual('3857');
|
|
expect(params.format).toEqual('png');
|
|
expect(params.transparent).toEqual('true');
|
|
expect(params.size).toEqual('128,512');
|
|
expect(params.layers).toEqual('show:foo,bar');
|
|
expect(params.token).toEqual(token);
|
|
|
|
// Just return any old image.
|
|
Resource._DefaultImplementations.createImage('Data/Images/Red16x16.png', crossOrigin, deferred);
|
|
};
|
|
|
|
return provider.requestImage(0, 0, 0).then(function(image) {
|
|
expect(image).toBeInstanceOf(Image);
|
|
});
|
|
});
|
|
});
|
|
|
|
it('includes security token in requests if one is specified', function() {
|
|
var baseUrl = '//tiledArcGisMapServer.invalid/',
|
|
token = '5e(u|2!7Y';
|
|
|
|
stubJSONPCall(baseUrl, webMercatorResult, false, token);
|
|
|
|
var provider = new ArcGisMapServerImageryProvider({
|
|
url : baseUrl,
|
|
token : token
|
|
});
|
|
|
|
var expectedTileUrl = getAbsoluteUri(baseUrl + 'tile/0/0/0?' + objectToQuery({
|
|
token: token
|
|
}));
|
|
|
|
expect(provider.url).toEqual(baseUrl);
|
|
expect(provider.token).toEqual(token);
|
|
|
|
return pollToPromise(function() {
|
|
return provider.ready;
|
|
}).then(function() {
|
|
expect(provider.tileWidth).toEqual(128);
|
|
expect(provider.tileHeight).toEqual(256);
|
|
expect(provider.maximumLevel).toEqual(2);
|
|
expect(provider.tilingScheme).toBeInstanceOf(WebMercatorTilingScheme);
|
|
expect(provider.credit).toBeDefined();
|
|
expect(provider.tileDiscardPolicy).toBeInstanceOf(DiscardMissingTileImagePolicy);
|
|
expect(provider.rectangle).toEqual(new WebMercatorTilingScheme().rectangle);
|
|
expect(provider.usingPrecachedTiles).toEqual(true);
|
|
expect(provider.hasAlphaChannel).toBeDefined();
|
|
|
|
Resource._Implementations.createImage = function(url, crossOrigin, deferred) {
|
|
if (/^blob:/.test(url)) {
|
|
// load blob url normally
|
|
Resource._DefaultImplementations.createImage(url, crossOrigin, deferred);
|
|
} else {
|
|
expect(url).toEqual(expectedTileUrl);
|
|
|
|
// Just return any old image.
|
|
Resource._DefaultImplementations.createImage('Data/Images/Red16x16.png', crossOrigin, deferred);
|
|
}
|
|
};
|
|
|
|
Resource._Implementations.loadWithXhr = function(url, responseType, method, data, headers, deferred, overrideMimeType) {
|
|
expect(url).toEqual(expectedTileUrl);
|
|
|
|
// Just return any old image.
|
|
Resource._DefaultImplementations.loadWithXhr('Data/Images/Red16x16.png', responseType, method, data, headers, deferred);
|
|
};
|
|
|
|
return provider.requestImage(0, 0, 0).then(function(image) {
|
|
expect(image).toBeInstanceOf(Image);
|
|
});
|
|
});
|
|
});
|
|
|
|
it('raises error on unsupported WKID', function() {
|
|
var baseUrl = '//tiledArcGisMapServer.invalid/';
|
|
|
|
var unsupportedWKIDResult = {
|
|
'currentVersion' : 10.01,
|
|
'copyrightText' : 'Test copyright text',
|
|
'tileInfo' : {
|
|
'rows' : 128,
|
|
'cols' : 256,
|
|
'origin' : {
|
|
'x' : -180,
|
|
'y' : 90
|
|
},
|
|
'spatialReference' : {
|
|
'wkid' : 1234
|
|
},
|
|
'lods' : [{
|
|
'level' : 0,
|
|
'resolution' : 0.3515625,
|
|
'scale' : 147748799.285417
|
|
}, {
|
|
'level' : 1,
|
|
'resolution' : 0.17578125,
|
|
'scale' : 73874399.6427087
|
|
}, {
|
|
'level' : 2,
|
|
'resolution' : 0.087890625,
|
|
'scale' : 36937199.8213544
|
|
}]
|
|
}
|
|
};
|
|
|
|
stubJSONPCall(baseUrl, unsupportedWKIDResult);
|
|
|
|
var provider = new ArcGisMapServerImageryProvider({
|
|
url : baseUrl
|
|
});
|
|
|
|
expect(provider.url).toEqual(baseUrl);
|
|
|
|
var tries = 0;
|
|
provider.errorEvent.addEventListener(function(error) {
|
|
expect(error.message.indexOf('WKID') >= 0).toEqual(true);
|
|
++tries;
|
|
if (tries < 3) {
|
|
error.retry = true;
|
|
}
|
|
});
|
|
|
|
return pollToPromise(function() {
|
|
return provider.ready || tries >= 3;
|
|
}).then(function() {
|
|
expect(provider.ready).toEqual(false);
|
|
expect(tries).toEqual(3);
|
|
});
|
|
});
|
|
|
|
it('raises error on invalid URL', function() {
|
|
var baseUrl = '//tiledArcGisMapServer.invalid/';
|
|
|
|
var provider = new ArcGisMapServerImageryProvider({
|
|
url : baseUrl
|
|
});
|
|
|
|
expect(provider.url).toEqual(baseUrl);
|
|
|
|
var errorEventRaised = false;
|
|
provider.errorEvent.addEventListener(function(error) {
|
|
expect(error.message.indexOf(baseUrl) >= 0).toEqual(true);
|
|
errorEventRaised = true;
|
|
});
|
|
|
|
return pollToPromise(function() {
|
|
return provider.ready || errorEventRaised;
|
|
}).then(function() {
|
|
expect(provider.ready).toEqual(false);
|
|
expect(errorEventRaised).toEqual(true);
|
|
});
|
|
});
|
|
|
|
it('raises error event when image cannot be loaded', function() {
|
|
var baseUrl = '//tiledArcGisMapServer.invalid/';
|
|
|
|
stubJSONPCall(baseUrl, {
|
|
'currentVersion' : 10.01,
|
|
'copyrightText' : 'Test copyright text'
|
|
});
|
|
|
|
var provider = new ArcGisMapServerImageryProvider({
|
|
url : baseUrl
|
|
});
|
|
|
|
var layer = new ImageryLayer(provider);
|
|
|
|
var tries = 0;
|
|
provider.errorEvent.addEventListener(function(error) {
|
|
expect(error.timesRetried).toEqual(tries);
|
|
++tries;
|
|
if (tries < 3) {
|
|
error.retry = true;
|
|
}
|
|
setTimeout(function() {
|
|
RequestScheduler.update();
|
|
}, 1);
|
|
});
|
|
|
|
Resource._Implementations.createImage = function(url, crossOrigin, deferred) {
|
|
if (tries === 2) {
|
|
// Succeed after 2 tries
|
|
Resource._DefaultImplementations.createImage('Data/Images/Red16x16.png', crossOrigin, deferred);
|
|
} else {
|
|
// fail
|
|
setTimeout(function() {
|
|
deferred.reject();
|
|
}, 1);
|
|
}
|
|
};
|
|
|
|
return pollToPromise(function() {
|
|
return provider.ready;
|
|
}).then(function() {
|
|
var imagery = new Imagery(layer, 0, 0, 0);
|
|
imagery.addReference();
|
|
layer._requestImagery(imagery);
|
|
RequestScheduler.update();
|
|
|
|
return pollToPromise(function() {
|
|
return imagery.state === ImageryState.RECEIVED;
|
|
}).then(function() {
|
|
expect(imagery.image).toBeInstanceOf(Image);
|
|
expect(tries).toEqual(2);
|
|
imagery.releaseReference();
|
|
});
|
|
});
|
|
});
|
|
|
|
it('honors fullExtent of tiled server with web mercator projection', function() {
|
|
var baseUrl = '//tiledArcGisMapServer.invalid/';
|
|
|
|
var webMercatorFullExtentResult = {
|
|
'currentVersion' : 10.01,
|
|
'copyrightText' : 'Test copyright text',
|
|
'tileInfo' : {
|
|
'rows' : 128,
|
|
'cols' : 256,
|
|
'origin' : {
|
|
'x' : -20037508.342787,
|
|
'y' : 20037508.342787
|
|
},
|
|
'spatialReference' : {
|
|
'wkid' : 102100
|
|
},
|
|
'lods' : [{
|
|
'level' : 0,
|
|
'resolution' : 156543.033928,
|
|
'scale' : 591657527.591555
|
|
}, {
|
|
'level' : 1,
|
|
'resolution' : 78271.5169639999,
|
|
'scale' : 295828763.795777
|
|
}, {
|
|
'level' : 2,
|
|
'resolution' : 39135.7584820001,
|
|
'scale' : 147914381.897889
|
|
}]
|
|
},
|
|
fullExtent : {
|
|
'xmin' : 1.1148026611962173E7,
|
|
'ymin' : -6443518.758206591,
|
|
'xmax' : 1.8830976498143446E7,
|
|
'ymax' : -265936.19697360107,
|
|
'spatialReference' : {
|
|
'wkid' : 102100
|
|
}
|
|
}
|
|
};
|
|
|
|
stubJSONPCall(baseUrl, webMercatorFullExtentResult);
|
|
|
|
var provider = new ArcGisMapServerImageryProvider({
|
|
url : baseUrl
|
|
});
|
|
|
|
expect(provider.url).toEqual(baseUrl);
|
|
|
|
return pollToPromise(function() {
|
|
return provider.ready;
|
|
}).then(function() {
|
|
var projection = new WebMercatorProjection();
|
|
var sw = projection.unproject(new Cartesian2(1.1148026611962173E7, -6443518.758206591));
|
|
var ne = projection.unproject(new Cartesian2(1.8830976498143446E7, -265936.19697360107));
|
|
var rectangle = new Rectangle(sw.longitude, sw.latitude, ne.longitude, ne.latitude);
|
|
expect(provider.rectangle).toEqual(rectangle);
|
|
});
|
|
});
|
|
|
|
it('constrains extent to the tiling scheme\'s rectangle', function() {
|
|
var baseUrl = '//tiledArcGisMapServer.invalid/';
|
|
|
|
var webMercatorOutsideBoundsResult = {
|
|
'currentVersion' : 10.01,
|
|
'copyrightText' : 'Test copyright text',
|
|
'tileInfo' : {
|
|
'rows' : 128,
|
|
'cols' : 256,
|
|
'origin' : {
|
|
'x' : -20037508.342787,
|
|
'y' : 20037508.342787
|
|
},
|
|
'spatialReference' : {
|
|
'wkid' : 102100
|
|
},
|
|
'lods' : [{
|
|
'level' : 0,
|
|
'resolution' : 156543.033928,
|
|
'scale' : 591657527.591555
|
|
}, {
|
|
'level' : 1,
|
|
'resolution' : 78271.5169639999,
|
|
'scale' : 295828763.795777
|
|
}, {
|
|
'level' : 2,
|
|
'resolution' : 39135.7584820001,
|
|
'scale' : 147914381.897889
|
|
}]
|
|
},
|
|
fullExtent : {
|
|
'xmin' : -2.0037507067161843E7,
|
|
'ymin' : -1.4745615008589065E7,
|
|
'xmax' : 2.0037507067161843E7,
|
|
'ymax' : 3.0240971958386205E7,
|
|
'spatialReference' : {
|
|
'wkid' : 102100
|
|
}
|
|
}
|
|
};
|
|
|
|
stubJSONPCall(baseUrl, webMercatorOutsideBoundsResult);
|
|
|
|
var provider = new ArcGisMapServerImageryProvider({
|
|
url : baseUrl
|
|
});
|
|
|
|
expect(provider.url).toEqual(baseUrl);
|
|
|
|
return pollToPromise(function() {
|
|
return provider.ready;
|
|
}).then(function() {
|
|
expect(provider.rectangle.west >= -Math.PI).toBe(true);
|
|
expect(provider.rectangle.east <= Math.PI).toBe(true);
|
|
expect(provider.rectangle.south >= -WebMercatorProjection.MaximumLatitude).toBe(true);
|
|
expect(provider.rectangle.north <= WebMercatorProjection.MaximumLatitude).toBe(true);
|
|
});
|
|
});
|
|
|
|
it('honors fullExtent of tiled server with geographic projection', function() {
|
|
var baseUrl = '//tiledArcGisMapServer.invalid/';
|
|
|
|
var geographicFullExtentResult = {
|
|
'currentVersion' : 10.01,
|
|
'copyrightText' : 'Test copyright text',
|
|
'tileInfo' : {
|
|
'rows' : 128,
|
|
'cols' : 256,
|
|
'origin' : {
|
|
'x' : -20037508.342787,
|
|
'y' : 20037508.342787
|
|
},
|
|
'spatialReference' : {
|
|
'wkid' : 102100
|
|
},
|
|
'lods' : [{
|
|
'level' : 0,
|
|
'resolution' : 156543.033928,
|
|
'scale' : 591657527.591555
|
|
}, {
|
|
'level' : 1,
|
|
'resolution' : 78271.5169639999,
|
|
'scale' : 295828763.795777
|
|
}, {
|
|
'level' : 2,
|
|
'resolution' : 39135.7584820001,
|
|
'scale' : 147914381.897889
|
|
}]
|
|
},
|
|
fullExtent : {
|
|
'xmin' : -123.4,
|
|
'ymin' : -23.2,
|
|
'xmax' : 100.7,
|
|
'ymax' : 45.2,
|
|
'spatialReference' : {
|
|
'wkid' : 4326
|
|
}
|
|
}
|
|
};
|
|
|
|
stubJSONPCall(baseUrl, geographicFullExtentResult);
|
|
|
|
var provider = new ArcGisMapServerImageryProvider({
|
|
url : baseUrl
|
|
});
|
|
|
|
expect(provider.url).toEqual(baseUrl);
|
|
|
|
return pollToPromise(function() {
|
|
return provider.ready;
|
|
}).then(function() {
|
|
expect(provider.rectangle).toEqual(Rectangle.fromDegrees(-123.4, -23.2, 100.7, 45.2));
|
|
});
|
|
});
|
|
|
|
it('raises error if the spatialReference of the fullExtent is unknown', function() {
|
|
var baseUrl = '//tiledArcGisMapServer.invalid/';
|
|
|
|
var unknownSpatialReferenceResult = {
|
|
'currentVersion' : 10.01,
|
|
'copyrightText' : 'Test copyright text',
|
|
'tileInfo' : {
|
|
'rows' : 128,
|
|
'cols' : 256,
|
|
'origin' : {
|
|
'x' : -180,
|
|
'y' : 90
|
|
},
|
|
'spatialReference' : {
|
|
'wkid' : 1234
|
|
},
|
|
'lods' : [{
|
|
'level' : 0,
|
|
'resolution' : 0.3515625,
|
|
'scale' : 147748799.285417
|
|
}, {
|
|
'level' : 1,
|
|
'resolution' : 0.17578125,
|
|
'scale' : 73874399.6427087
|
|
}, {
|
|
'level' : 2,
|
|
'resolution' : 0.087890625,
|
|
'scale' : 36937199.8213544
|
|
}]
|
|
},
|
|
fullExtent : {
|
|
'xmin' : -123.4,
|
|
'ymin' : -23.2,
|
|
'xmax' : 100.7,
|
|
'ymax' : 45.2,
|
|
'spatialReference' : {
|
|
'wkid' : 1234
|
|
}
|
|
}
|
|
};
|
|
|
|
stubJSONPCall(baseUrl, unknownSpatialReferenceResult);
|
|
|
|
var provider = new ArcGisMapServerImageryProvider({
|
|
url : baseUrl
|
|
});
|
|
|
|
expect(provider.url).toEqual(baseUrl);
|
|
|
|
var tries = 0;
|
|
provider.errorEvent.addEventListener(function(error) {
|
|
expect(error.message.indexOf('WKID') >= 0).toEqual(true);
|
|
++tries;
|
|
if (tries < 3) {
|
|
error.retry = true;
|
|
}
|
|
});
|
|
|
|
return pollToPromise(function() {
|
|
return provider.ready || tries >= 3;
|
|
}).then(function() {
|
|
expect(provider.ready).toEqual(false);
|
|
expect(tries).toEqual(3);
|
|
});
|
|
});
|
|
|
|
describe('pickFeatures', function() {
|
|
it('works with WebMercator geometry', function() {
|
|
var provider = new ArcGisMapServerImageryProvider({
|
|
url : 'made/up/map/server',
|
|
usePreCachedTilesIfAvailable : false
|
|
});
|
|
|
|
Resource._Implementations.loadWithXhr = function(url, responseType, method, data, headers, deferred, overrideMimeType) {
|
|
expect(url).toContain('identify');
|
|
Resource._DefaultImplementations.loadWithXhr('Data/ArcGIS/identify-WebMercator.json', responseType, method, data, headers, deferred, overrideMimeType);
|
|
};
|
|
|
|
return pollToPromise(function() {
|
|
return provider.ready;
|
|
}).then(function() {
|
|
return provider.pickFeatures(0, 0, 0, 0.5, 0.5).then(function(pickResult) {
|
|
expect(pickResult.length).toBe(1);
|
|
|
|
var firstResult = pickResult[0];
|
|
expect(firstResult).toBeInstanceOf(ImageryLayerFeatureInfo);
|
|
expect(firstResult.description).toContain('Hummock Grasses');
|
|
expect(firstResult.position).toEqual(new WebMercatorProjection().unproject(new Cartesian3(1.481682457042425E7, -2710890.117898505)));
|
|
});
|
|
});
|
|
});
|
|
|
|
it('works with Geographic geometry', function() {
|
|
var provider = new ArcGisMapServerImageryProvider({
|
|
url : 'made/up/map/server',
|
|
usePreCachedTilesIfAvailable : false
|
|
});
|
|
|
|
Resource._Implementations.loadWithXhr = function(url, responseType, method, data, headers, deferred, overrideMimeType) {
|
|
expect(url).toContain('identify');
|
|
Resource._DefaultImplementations.loadWithXhr('Data/ArcGIS/identify-Geographic.json', responseType, method, data, headers, deferred, overrideMimeType);
|
|
};
|
|
|
|
return pollToPromise(function() {
|
|
return provider.ready;
|
|
}).then(function() {
|
|
return provider.pickFeatures(0, 0, 0, 0.5, 0.5).then(function(pickResult) {
|
|
expect(pickResult.length).toBe(1);
|
|
|
|
var firstResult = pickResult[0];
|
|
expect(firstResult).toBeInstanceOf(ImageryLayerFeatureInfo);
|
|
expect(firstResult.description).toContain('Hummock Grasses');
|
|
expect(firstResult.position).toEqual(Cartographic.fromDegrees(123.45, -34.2));
|
|
});
|
|
});
|
|
});
|
|
|
|
it('returns undefined if enablePickFeatures is false', function() {
|
|
var provider = new ArcGisMapServerImageryProvider({
|
|
url : 'made/up/map/server',
|
|
usePreCachedTilesIfAvailable : false,
|
|
enablePickFeatures : false
|
|
});
|
|
|
|
return pollToPromise(function() {
|
|
return provider.ready;
|
|
}).then(function() {
|
|
expect(provider.pickFeatures(0, 0, 0, 0.5, 0.5)).toBeUndefined();
|
|
});
|
|
});
|
|
|
|
it('returns undefined if enablePickFeatures is dynamically set to false', function() {
|
|
var provider = new ArcGisMapServerImageryProvider({
|
|
url : 'made/up/map/server',
|
|
usePreCachedTilesIfAvailable : false,
|
|
enablePickFeatures : true
|
|
});
|
|
|
|
provider.enablePickFeatures = false;
|
|
|
|
return pollToPromise(function() {
|
|
return provider.ready;
|
|
}).then(function() {
|
|
expect(provider.pickFeatures(0, 0, 0, 0.5, 0.5)).toBeUndefined();
|
|
});
|
|
});
|
|
|
|
it('does not return undefined if enablePickFeatures is dynamically set to true', function() {
|
|
var provider = new ArcGisMapServerImageryProvider({
|
|
url : 'made/up/map/server',
|
|
usePreCachedTilesIfAvailable : false,
|
|
enablePickFeatures : false
|
|
});
|
|
|
|
provider.enablePickFeatures = true;
|
|
|
|
return pollToPromise(function() {
|
|
return provider.ready;
|
|
}).then(function() {
|
|
expect(provider.pickFeatures(0, 0, 0, 0.5, 0.5)).not.toBeUndefined();
|
|
});
|
|
});
|
|
|
|
it('picks from individual layers', function() {
|
|
var provider = new ArcGisMapServerImageryProvider({
|
|
url : 'made/up/map/server',
|
|
usePreCachedTilesIfAvailable : false,
|
|
layers : 'someLayer,anotherLayerYay'
|
|
});
|
|
|
|
Resource._Implementations.loadWithXhr = function(url, responseType, method, data, headers, deferred, overrideMimeType) {
|
|
var uri = new Uri(url);
|
|
var query = queryToObject(uri.getQuery());
|
|
|
|
expect(query.layers).toContain('visible:someLayer,anotherLayerYay');
|
|
Resource._DefaultImplementations.loadWithXhr('Data/ArcGIS/identify-WebMercator.json', responseType, method, data, headers, deferred, overrideMimeType);
|
|
};
|
|
|
|
return pollToPromise(function() {
|
|
return provider.ready;
|
|
}).then(function() {
|
|
return provider.pickFeatures(0, 0, 0, 0.5, 0.5).then(function(pickResult) {
|
|
expect(pickResult.length).toBe(1);
|
|
});
|
|
});
|
|
});
|
|
});
|
|
});
|