259 lines
11 KiB
JavaScript
259 lines
11 KiB
JavaScript
defineSuite([
|
|
'Scene/IonImageryProvider',
|
|
'Core/Credit',
|
|
'Core/defaultValue',
|
|
'Core/IonResource',
|
|
'Core/RequestScheduler',
|
|
'Core/Resource',
|
|
'Core/RuntimeError',
|
|
'Scene/ArcGisMapServerImageryProvider',
|
|
'Scene/BingMapsImageryProvider',
|
|
'Scene/GoogleEarthEnterpriseMapsProvider',
|
|
'Scene/ImageryProvider',
|
|
'Scene/MapboxImageryProvider',
|
|
'Scene/SingleTileImageryProvider',
|
|
'Scene/UrlTemplateImageryProvider',
|
|
'Scene/WebMapServiceImageryProvider',
|
|
'Scene/WebMapTileServiceImageryProvider',
|
|
'ThirdParty/when'
|
|
], function(
|
|
IonImageryProvider,
|
|
Credit,
|
|
defaultValue,
|
|
IonResource,
|
|
RequestScheduler,
|
|
Resource,
|
|
RuntimeError,
|
|
ArcGisMapServerImageryProvider,
|
|
BingMapsImageryProvider,
|
|
GoogleEarthEnterpriseMapsProvider,
|
|
ImageryProvider,
|
|
MapboxImageryProvider,
|
|
SingleTileImageryProvider,
|
|
UrlTemplateImageryProvider,
|
|
WebMapServiceImageryProvider,
|
|
WebMapTileServiceImageryProvider,
|
|
when) {
|
|
'use strict';
|
|
|
|
function createTestProvider(endpointData) {
|
|
endpointData = defaultValue(endpointData, {
|
|
type: 'IMAGERY',
|
|
url: 'http://test.invalid/layer',
|
|
accessToken: 'not_really_a_refresh_token',
|
|
attributions: []
|
|
});
|
|
|
|
var assetId = 12335;
|
|
var options = { assetId: assetId };
|
|
var endpointResource = IonResource._createEndpointResource(assetId, options);
|
|
spyOn(IonResource, '_createEndpointResource').and.returnValue(endpointResource);
|
|
|
|
spyOn(endpointResource, 'fetchJson').and.returnValue(when.resolve(endpointData));
|
|
|
|
var provider = new IonImageryProvider(options);
|
|
|
|
expect(IonResource._createEndpointResource).toHaveBeenCalledWith(assetId, options);
|
|
return provider;
|
|
}
|
|
|
|
beforeEach(function() {
|
|
RequestScheduler.clearForSpecs();
|
|
});
|
|
|
|
it('conforms to ImageryProvider interface', function() {
|
|
expect(IonImageryProvider).toConformToInterface(ImageryProvider);
|
|
});
|
|
|
|
it('throws without asset ID', function() {
|
|
expect(function() {
|
|
return new IonImageryProvider({});
|
|
}).toThrowDeveloperError(ImageryProvider);
|
|
});
|
|
|
|
it('readyPromise rejects with non-imagery asset', function(done) {
|
|
var provider = createTestProvider({
|
|
type: '3DTILES',
|
|
url: 'http://test.invalid/layer',
|
|
accessToken: 'not_really_a_refresh_token',
|
|
attributions: []
|
|
});
|
|
|
|
return provider.readyPromise
|
|
.then(function() {
|
|
fail('should not be called');
|
|
})
|
|
.otherwise(function(error) {
|
|
expect(error).toBeInstanceOf(RuntimeError);
|
|
expect(provider.ready).toBe(false);
|
|
});
|
|
});
|
|
|
|
it('readyPromise rejects with unknown external asset type', function(done) {
|
|
var provider = createTestProvider({
|
|
type: 'IMAGERY',
|
|
externalType: 'TUBELCANE',
|
|
options: { url: 'http://test.invalid/layer' },
|
|
attributions: []
|
|
});
|
|
|
|
return provider.readyPromise
|
|
.then(function() {
|
|
fail('should not be called');
|
|
})
|
|
.otherwise(function(error) {
|
|
expect(error).toBeInstanceOf(RuntimeError);
|
|
expect(provider.ready).toBe(false);
|
|
});
|
|
});
|
|
|
|
it('readyPromise resolves when ready', function() {
|
|
var provider = createTestProvider();
|
|
return provider.readyPromise
|
|
.then(function() {
|
|
expect(provider.errorEvent).toBeDefined();
|
|
expect(provider.ready).toBe(true);
|
|
expect(provider._imageryProvider).toBeInstanceOf(UrlTemplateImageryProvider);
|
|
});
|
|
});
|
|
|
|
it('propagates called to underlying imagery provider resolves when ready', function() {
|
|
var provider = createTestProvider();
|
|
var internalProvider;
|
|
|
|
return provider.readyPromise
|
|
.then(function() {
|
|
internalProvider = provider._imageryProvider;
|
|
expect(provider.rectangle).toBe(internalProvider.rectangle);
|
|
expect(provider.tileWidth).toBe(internalProvider.tileWidth);
|
|
expect(provider.tileHeight).toBe(internalProvider.tileHeight);
|
|
expect(provider.maximumLevel).toBe(internalProvider.maximumLevel);
|
|
expect(provider.minimumLevel).toBe(internalProvider.minimumLevel);
|
|
expect(provider.tilingScheme).toBe(internalProvider.tilingScheme);
|
|
expect(provider.tileDiscardPolicy).toBe(internalProvider.tileDiscardPolicy);
|
|
expect(provider.credit).toBe(internalProvider.credit);
|
|
expect(provider.hasAlphaChannel).toBe(internalProvider.hasAlphaChannel);
|
|
|
|
var image = new Image();
|
|
var request = {};
|
|
spyOn(internalProvider, 'requestImage').and.returnValue(when.resolve(image));
|
|
return provider.requestImage(1, 2, 3, request).then(function(result) {
|
|
expect(internalProvider.requestImage).toHaveBeenCalledWith(1, 2, 3, request);
|
|
expect(result).toBe(image);
|
|
});
|
|
})
|
|
.then(function() {
|
|
var info = {};
|
|
spyOn(internalProvider, 'pickFeatures').and.returnValue(when.resolve(info));
|
|
return provider.pickFeatures(1, 2, 3, 4, 5).then(function(result) {
|
|
expect(internalProvider.pickFeatures).toHaveBeenCalledWith(1, 2, 3, 4, 5);
|
|
expect(result).toBe(info);
|
|
});
|
|
})
|
|
.then(function() {
|
|
var innerCredit = new Credit('Data provided');
|
|
spyOn(internalProvider, 'getTileCredits').and.returnValue([innerCredit]);
|
|
var credits = provider.getTileCredits(1, 2, 3);
|
|
expect(internalProvider.getTileCredits).toHaveBeenCalledWith(1, 2, 3);
|
|
expect(credits).toContain(innerCredit);
|
|
});
|
|
});
|
|
|
|
it('throws developer errors when not ready', function() {
|
|
var provider = createTestProvider();
|
|
provider._ready = false;
|
|
|
|
expect(function() { return provider.rectangle; }).toThrowDeveloperError();
|
|
expect(function() { return provider.tileWidth; }).toThrowDeveloperError();
|
|
expect(function() { return provider.tileHeight; }).toThrowDeveloperError();
|
|
expect(function() { return provider.maximumLevel; }).toThrowDeveloperError();
|
|
expect(function() { return provider.minimumLevel; }).toThrowDeveloperError();
|
|
expect(function() { return provider.tilingScheme; }).toThrowDeveloperError();
|
|
expect(function() { return provider.tileDiscardPolicy; }).toThrowDeveloperError();
|
|
expect(function() { return provider.credit; }).toThrowDeveloperError();
|
|
expect(function() { return provider.hasAlphaChannel; }).toThrowDeveloperError();
|
|
expect(function() { return provider.requestImage(1, 2, 3, {}); }).toThrowDeveloperError();
|
|
expect(function() { return provider.pickFeatures(1, 2, 3, 4, 5); }).toThrowDeveloperError();
|
|
expect(function() { return provider.getTileCredits(1, 2, 3); }).toThrowDeveloperError();
|
|
});
|
|
|
|
it('handles server-sent credits', function() {
|
|
var serverCredit = {html : '<a href="http://test.invalid/">Text</a>', collapsible : false};
|
|
var provider = createTestProvider({
|
|
type : 'IMAGERY',
|
|
url : 'http://test.invalid/layer',
|
|
accessToken : 'not_really_a_refresh_token',
|
|
attributions : [serverCredit]
|
|
});
|
|
|
|
return provider.readyPromise
|
|
.then(function() {
|
|
var credits = provider.getTileCredits(0, 0, 0);
|
|
var credit = credits[0];
|
|
expect(credit).toBeInstanceOf(Credit);
|
|
expect(credit.html).toEqual(serverCredit.html);
|
|
expect(credit.showOnScreen).toEqual(!serverCredit.collapsible);
|
|
});
|
|
});
|
|
|
|
function testExternalImagery(type, options, ImageryClass) {
|
|
var provider = createTestProvider({
|
|
type: 'IMAGERY',
|
|
externalType: type,
|
|
options: options,
|
|
attributions: []
|
|
});
|
|
expect(provider._imageryProvider).toBeInstanceOf(ImageryClass);
|
|
}
|
|
|
|
it('createImageryProvider works with ARCGIS_MAPSERVER', function() {
|
|
spyOn(Resource._Implementations, 'loadAndExecuteScript').and.callFake(function(url, name, deffered) {
|
|
deffered.resolve({ resourceSets: [{ resources: [{ imageUrl: '', imageUrlSubdomains: [], zoomMax: 0 }] }] });
|
|
});
|
|
return testExternalImagery('ARCGIS_MAPSERVER', { url: 'http://test.invalid' }, ArcGisMapServerImageryProvider);
|
|
});
|
|
|
|
it('createImageryProvider works with BING', function() {
|
|
spyOn(Resource._Implementations, 'loadAndExecuteScript').and.callFake(function(url, name, deffered) {
|
|
deffered.resolve({ resourceSets: [{ resources: [{ imageUrl: '', imageUrlSubdomains: [], zoomMax: 0 }] }] });
|
|
});
|
|
return testExternalImagery('BING', { url: 'http://test.invalid' }, BingMapsImageryProvider);
|
|
});
|
|
|
|
it('createImageryProvider works with GOOGLE_EARTH', function() {
|
|
spyOn(Resource._Implementations, 'loadWithXhr').and.callFake(function(url, responseType, method, data, headers, deferred, overrideMimeType) {
|
|
deferred.resolve(JSON.stringify({ layers: [{ id: 0, version: '' }] }));
|
|
});
|
|
|
|
return testExternalImagery('GOOGLE_EARTH', { url: 'http://test.invalid', channel: 0 }, GoogleEarthEnterpriseMapsProvider);
|
|
});
|
|
|
|
it('createImageryProvider works with MAPBOX', function() {
|
|
return testExternalImagery('MAPBOX', { url: 'http://test.invalid', mapId: 1 }, MapboxImageryProvider);
|
|
});
|
|
|
|
it('createImageryProvider works with SINGLE_TILE', function() {
|
|
spyOn(Resource._Implementations, 'createImage').and.callFake(function(url, crossOrigin, deferred) {
|
|
deferred.resolve({});
|
|
});
|
|
|
|
return testExternalImagery('SINGLE_TILE', { url: 'http://test.invalid' }, SingleTileImageryProvider);
|
|
});
|
|
|
|
it('createImageryProvider works with TMS', function() {
|
|
return testExternalImagery('TMS', { url: 'http://test.invalid' }, UrlTemplateImageryProvider);
|
|
});
|
|
|
|
it('createImageryProvider works with URL_TEMPLATE', function() {
|
|
return testExternalImagery('URL_TEMPLATE', { url: 'http://test.invalid' }, UrlTemplateImageryProvider);
|
|
});
|
|
|
|
it('createImageryProvider works with WMS', function() {
|
|
return testExternalImagery('WMS', { url: 'http://test.invalid', layers: [] }, WebMapServiceImageryProvider);
|
|
});
|
|
|
|
it('createImageryProvider works with WMTS', function() {
|
|
return testExternalImagery('WMTS', { url: 'http://test.invalid', layer: '', style: '', tileMatrixSetID: 1 }, WebMapTileServiceImageryProvider);
|
|
});
|
|
});
|