import { Ion } from "../../Source/Cesium.js";
|
import { IonResource } from "../../Source/Cesium.js";
|
import { RequestErrorEvent } from "../../Source/Cesium.js";
|
import { Resource } from "../../Source/Cesium.js";
|
import { RuntimeError } from "../../Source/Cesium.js";
|
import { when } from "../../Source/Cesium.js";
|
|
describe("Core/IonResource", function () {
|
var assetId = 123890213;
|
var endpoint = {
|
type: "3DTILES",
|
url: "https://assets.cesium.com/" + assetId + "/tileset.json",
|
accessToken: "not_really_a_refresh_token",
|
attributions: [],
|
};
|
|
it("constructs with expected values", function () {
|
spyOn(Resource, "call").and.callThrough();
|
|
var endpointResource = IonResource._createEndpointResource(assetId);
|
var resource = new IonResource(endpoint, endpointResource);
|
expect(resource).toBeInstanceOf(Resource);
|
expect(resource._ionEndpoint).toEqual(endpoint);
|
expect(Resource.call).toHaveBeenCalledWith(resource, {
|
url: endpoint.url,
|
retryCallback: resource.retryCallback,
|
retryAttempts: 1,
|
});
|
});
|
|
it("clone works", function () {
|
var endpointResource = IonResource._createEndpointResource(assetId);
|
var resource = new IonResource(endpoint, endpointResource);
|
var cloned = resource.clone();
|
expect(cloned).not.toBe(resource);
|
expect(cloned._ionRoot).toBe(resource);
|
cloned._ionRoot = undefined;
|
expect(cloned.retryCallback).toBe(resource.retryCallback);
|
expect(cloned.headers.Authorization).toBe(resource.headers.Authorization);
|
expect(cloned).toEqual(resource);
|
});
|
|
it("create creates the expected resource", function () {
|
var endpointResource = IonResource._createEndpointResource(assetId);
|
var resource = new IonResource(endpoint, endpointResource);
|
expect(resource.getUrlComponent()).toEqual(endpoint.url);
|
expect(resource._ionEndpoint).toBe(endpoint);
|
expect(resource._ionEndpointResource).toEqual(endpointResource);
|
expect(resource.retryCallback).toBeDefined();
|
expect(resource.retryAttempts).toBe(1);
|
});
|
|
it("fromAssetId calls constructor for non-external endpoint with expected parameters", function () {
|
var tilesAssetId = 123890213;
|
var tilesEndpoint = {
|
type: "3DTILES",
|
url: "https://assets.cesium.com/" + tilesAssetId + "/tileset.json",
|
accessToken: "not_really_a_refresh_token",
|
attributions: [],
|
};
|
|
var options = {};
|
var resourceEndpoint = IonResource._createEndpointResource(
|
tilesAssetId,
|
options
|
);
|
spyOn(IonResource, "_createEndpointResource").and.returnValue(
|
resourceEndpoint
|
);
|
spyOn(resourceEndpoint, "fetchJson").and.returnValue(
|
when.resolve(tilesEndpoint)
|
);
|
|
return IonResource.fromAssetId(tilesAssetId, options).then(function (
|
resource
|
) {
|
expect(IonResource._createEndpointResource).toHaveBeenCalledWith(
|
tilesAssetId,
|
options
|
);
|
expect(resourceEndpoint.fetchJson).toHaveBeenCalled();
|
expect(resource._ionEndpointResource).toEqual(resourceEndpoint);
|
expect(resource._ionEndpoint).toEqual(tilesEndpoint);
|
});
|
});
|
|
function testNonImageryExternalResource(externalEndpoint) {
|
var resourceEndpoint = IonResource._createEndpointResource(123890213);
|
spyOn(IonResource, "_createEndpointResource").and.returnValue(
|
resourceEndpoint
|
);
|
spyOn(resourceEndpoint, "fetchJson").and.returnValue(
|
when.resolve(externalEndpoint)
|
);
|
|
return IonResource.fromAssetId(123890213).then(function (resource) {
|
expect(resource.url).toEqual(externalEndpoint.options.url);
|
expect(resource.headers.Authorization).toBeUndefined();
|
expect(resource.retryCallback).toBeUndefined();
|
});
|
}
|
|
it("fromAssetId returns basic Resource for external 3D tilesets", function () {
|
return testNonImageryExternalResource({
|
type: "3DTILES",
|
externalType: "3DTILES",
|
options: { url: "http://test.invalid/tileset.json" },
|
attributions: [],
|
});
|
});
|
|
it("fromAssetId returns basic Resource for external 3D tilesets", function () {
|
return testNonImageryExternalResource({
|
type: "TERRAIN",
|
externalType: "STK_TERRAIN_SERVER",
|
options: { url: "http://test.invalid/world" },
|
attributions: [],
|
});
|
});
|
|
it("fromAssetId rejects for external imagery", function () {
|
return testNonImageryExternalResource({
|
type: "IMAGERY",
|
externalType: "URL_TEMPLATE",
|
url: "http://test.invalid/world",
|
attributions: [],
|
})
|
.then(fail)
|
.otherwise(function (e) {
|
expect(e).toBeInstanceOf(RuntimeError);
|
});
|
});
|
|
it("createEndpointResource creates expected values with default parameters", function () {
|
var assetId = 2348234;
|
var resource = IonResource._createEndpointResource(assetId);
|
expect(resource.url).toBe(
|
Ion.defaultServer.url +
|
"v1/assets/" +
|
assetId +
|
"/endpoint?access_token=" +
|
Ion.defaultAccessToken
|
);
|
});
|
|
it("createEndpointResource creates expected values with overridden options", function () {
|
var serverUrl = "https://api.cesium.test/";
|
var accessToken = "not_a_token";
|
|
var assetId = 2348234;
|
var resource = IonResource._createEndpointResource(assetId, {
|
server: serverUrl,
|
accessToken: accessToken,
|
});
|
expect(resource.url).toBe(
|
serverUrl +
|
"v1/assets/" +
|
assetId +
|
"/endpoint?access_token=" +
|
accessToken
|
);
|
});
|
|
it("createEndpointResource creates expected values with overridden defaults", function () {
|
var defaultServer = Ion.defaultServer;
|
var defaultAccessToken = Ion.defaultAccessToken;
|
|
Ion.defaultServer = new Resource({ url: "https://api.cesium.test/" });
|
Ion.defaultAccessToken = "not_a_token";
|
|
var assetId = 2348234;
|
var resource = IonResource._createEndpointResource(assetId);
|
expect(resource.url).toBe(
|
Ion.defaultServer.url +
|
"v1/assets/" +
|
assetId +
|
"/endpoint?access_token=" +
|
Ion.defaultAccessToken
|
);
|
|
Ion.defaultServer = defaultServer;
|
Ion.defaultAccessToken = defaultAccessToken;
|
});
|
|
it("Calls base _makeRequest with expected options when resource no Authorization header is defined", function () {
|
var originalOptions = {};
|
var expectedOptions = {
|
headers: {
|
Authorization: "Bearer " + endpoint.accessToken,
|
},
|
};
|
|
var _makeRequest = spyOn(Resource.prototype, "_makeRequest");
|
var endpointResource = IonResource._createEndpointResource(assetId);
|
var resource = new IonResource(endpoint, endpointResource);
|
resource._makeRequest(originalOptions);
|
expect(_makeRequest).toHaveBeenCalledWith(expectedOptions);
|
});
|
|
it("Calls base _makeRequest with expected options when resource Authorization header is already defined", function () {
|
var originalOptions = {};
|
var expectedOptions = {
|
headers: {
|
Authorization: "Bearer " + endpoint.accessToken,
|
},
|
};
|
|
var _makeRequest = spyOn(Resource.prototype, "_makeRequest");
|
var endpointResource = IonResource._createEndpointResource(assetId);
|
var resource = new IonResource(endpoint, endpointResource);
|
resource.headers.Authorization = "Not valid";
|
resource._makeRequest(originalOptions);
|
expect(_makeRequest).toHaveBeenCalledWith(expectedOptions);
|
});
|
|
it("Calls base _makeRequest with no changes for external assets", function () {
|
var externalEndpoint = {
|
type: "3DTILES",
|
externalType: "3DTILES",
|
options: { url: "http://test.invalid/tileset.json" },
|
attributions: [],
|
};
|
var options = {};
|
|
var _makeRequest = spyOn(Resource.prototype, "_makeRequest");
|
var endpointResource = IonResource._createEndpointResource(assetId);
|
var resource = new IonResource(externalEndpoint, endpointResource);
|
resource._makeRequest(options);
|
expect(_makeRequest.calls.argsFor(0)[0]).toBe(options);
|
});
|
|
it("Calls base _makeRequest with no changes for ion assets with external urls", function () {
|
var originalOptions = {};
|
var expectedOptions = {};
|
|
var _makeRequest = spyOn(Resource.prototype, "_makeRequest");
|
var endpointResource = IonResource._createEndpointResource(assetId);
|
var resource = new IonResource(endpoint, endpointResource);
|
resource.url = "http://test.invalid";
|
resource._makeRequest(originalOptions);
|
expect(_makeRequest).toHaveBeenCalledWith(expectedOptions);
|
});
|
|
it("Calls base fetchImage with preferBlob for ion assets", function () {
|
var fetchImage = spyOn(Resource.prototype, "fetchImage");
|
var endpointResource = IonResource._createEndpointResource(assetId);
|
var resource = new IonResource(endpoint, endpointResource);
|
resource.fetchImage();
|
expect(fetchImage).toHaveBeenCalledWith({
|
preferBlob: true,
|
});
|
});
|
|
it("Calls base fetchImage with no changes for external assets", function () {
|
var externalEndpoint = {
|
type: "3DTILES",
|
externalType: "3DTILES",
|
options: { url: "http://test.invalid/tileset.json" },
|
attributions: [],
|
};
|
|
var fetchImage = spyOn(Resource.prototype, "fetchImage");
|
var endpointResource = IonResource._createEndpointResource(assetId);
|
var resource = new IonResource(externalEndpoint, endpointResource);
|
resource.fetchImage({
|
preferBlob: false,
|
});
|
expect(fetchImage).toHaveBeenCalledWith({
|
preferBlob: false,
|
});
|
});
|
|
describe("retryCallback", function () {
|
var endpointResource;
|
var resource;
|
var retryCallback;
|
|
beforeEach(function () {
|
endpointResource = new Resource({
|
url: "https://api.test.invalid",
|
access_token: "not_the_token",
|
});
|
resource = new IonResource(endpoint, endpointResource);
|
retryCallback = resource.retryCallback;
|
});
|
|
it("returns false when error is undefined", function () {
|
return retryCallback(resource, undefined).then(function (result) {
|
expect(result).toBe(false);
|
});
|
});
|
|
it("returns false when error is non-401", function () {
|
var error = new RequestErrorEvent(404);
|
return retryCallback(resource, error).then(function (result) {
|
expect(result).toBe(false);
|
});
|
});
|
|
it("returns false when error is event with non-Image target", function () {
|
var event = { target: {} };
|
return retryCallback(resource, event).then(function (result) {
|
expect(result).toBe(false);
|
});
|
});
|
|
function testCallback(resource, event) {
|
var deferred = when.defer();
|
spyOn(endpointResource, "fetchJson").and.returnValue(deferred.promise);
|
|
var newEndpoint = {
|
type: "3DTILES",
|
url: "https://assets.cesium.com/" + assetId,
|
accessToken: "not_not_really_a_refresh_token",
|
};
|
|
var promise = retryCallback(resource, event);
|
var resultPromise = promise.then(function (result) {
|
expect(result).toBe(true);
|
expect(resource._ionEndpoint).toBe(newEndpoint);
|
});
|
|
expect(endpointResource.fetchJson).toHaveBeenCalledWith();
|
|
//A second retry should re-use the same pending promise
|
var promise2 = retryCallback(resource, event);
|
expect(promise._pendingPromise).toBe(promise2._pendingPromise);
|
|
deferred.resolve(newEndpoint);
|
|
return resultPromise;
|
}
|
|
it("works when error is a 401", function () {
|
var error = new RequestErrorEvent(401);
|
return testCallback(resource, error);
|
});
|
|
it("works when error is event with Image target", function () {
|
var event = { target: new Image() };
|
return testCallback(resource, event);
|
});
|
|
it("works with derived resource and sets root access_token", function () {
|
var derived = resource.getDerivedResource("1");
|
var error = new RequestErrorEvent(401);
|
return testCallback(derived, error).then(function () {
|
expect(derived._ionEndpoint).toBe(resource._ionEndpoint);
|
expect(derived.headers.Authorization).toEqual(
|
resource.headers.Authorization
|
);
|
});
|
});
|
});
|
});
|
