mirror of
https://github.com/mapillary/mapillary-js.git
synced 2026-01-18 13:56:53 +00:00
880 lines
31 KiB
TypeScript
880 lines
31 KiB
TypeScript
import {empty as observableEmpty, Observable} from "rxjs";
|
|
|
|
import {catchError, retry} from "rxjs/operators";
|
|
|
|
import * as falcor from "falcor";
|
|
|
|
import {
|
|
APIv3,
|
|
ICoreNode,
|
|
IFillNode,
|
|
IFullNode,
|
|
ISequence,
|
|
ModelCreator,
|
|
} from "../../src/API";
|
|
|
|
describe("APIv3.ctor", () => {
|
|
it("should create an API v3", () => {
|
|
let apiV3: APIv3 = new APIv3("clientId", null);
|
|
|
|
expect(apiV3).toBeDefined();
|
|
});
|
|
});
|
|
|
|
describe("APIv3.imageByKeyFill$", () => {
|
|
it("should call model correctly", (done: Function) => {
|
|
let promise: any = {
|
|
then: (resolve: (result: any) => void, reject: (error: Error) => void): void => {
|
|
resolve({ json: { imageByKey: {} } });
|
|
},
|
|
};
|
|
|
|
let model: falcor.Model = new falcor.Model();
|
|
let modelSpy: jasmine.Spy = spyOn(model, "get");
|
|
modelSpy.and.returnValue(promise);
|
|
|
|
let creator: ModelCreator = new ModelCreator();
|
|
let creatorSpy: jasmine.Spy = spyOn(creator, "createModel");
|
|
creatorSpy.and.returnValue(model);
|
|
|
|
let apiV3: APIv3 = new APIv3("clientId", undefined, creator);
|
|
|
|
let key: string = "key";
|
|
|
|
apiV3.imageByKeyFill$([key])
|
|
.subscribe(
|
|
(result: { [key: string]: IFillNode}): void => {
|
|
expect(result).toBeDefined();
|
|
|
|
expect(modelSpy.calls.count()).toBe(1);
|
|
expect(modelSpy.calls.first().args.length).toBe(1);
|
|
expect(modelSpy.calls.first().args[0][0]).toBe("imageByKey");
|
|
expect(modelSpy.calls.first().args[0][1].length).toBe(1);
|
|
expect(modelSpy.calls.first().args[0][1][0]).toBe(key);
|
|
|
|
done();
|
|
});
|
|
});
|
|
|
|
it("should throw when result is undefined", (done: Function) => {
|
|
let promise: any = {
|
|
then: (resolve: (result: any) => void, reject: (error: Error) => void): void => {
|
|
resolve(undefined);
|
|
},
|
|
};
|
|
|
|
let model: falcor.Model = new falcor.Model();
|
|
let modelSpy: jasmine.Spy = spyOn(model, "get");
|
|
modelSpy.and.returnValue(promise);
|
|
|
|
let creator: ModelCreator = new ModelCreator();
|
|
let creatorSpy: jasmine.Spy = spyOn(creator, "createModel");
|
|
creatorSpy.and.returnValue(model);
|
|
|
|
let apiV3: APIv3 = new APIv3("clientId", undefined, creator);
|
|
|
|
let key: string = "key";
|
|
|
|
apiV3.imageByKeyFill$([key]).pipe(
|
|
catchError(
|
|
(err: Error): Observable<{}> => {
|
|
expect(err).toBeDefined();
|
|
expect(err instanceof Error).toBe(true);
|
|
|
|
return observableEmpty();
|
|
}))
|
|
.subscribe(
|
|
undefined,
|
|
undefined,
|
|
(): void => { done(); });
|
|
});
|
|
|
|
it("should invalidate model correctly when error is thrown", (done: Function) => {
|
|
let model: falcor.Model = new falcor.Model();
|
|
|
|
let promise: any = {
|
|
then: (resolve: (result: any) => void, reject: (error: Error) => void): void => {
|
|
reject(new Error());
|
|
},
|
|
};
|
|
|
|
let invalidateSpy: jasmine.Spy = spyOn(model, "invalidate");
|
|
invalidateSpy.and.stub();
|
|
|
|
spyOn(model, "get").and.returnValue(promise);
|
|
|
|
let creator: ModelCreator = new ModelCreator();
|
|
let creatorSpy: jasmine.Spy = spyOn(creator, "createModel");
|
|
creatorSpy.and.returnValue(model);
|
|
|
|
let apiV3: APIv3 = new APIv3("clientId", undefined, creator);
|
|
|
|
let key: string = "key";
|
|
|
|
apiV3.imageByKeyFill$([key])
|
|
.subscribe(
|
|
(result: { [key: string]: IFillNode}): void => { return; },
|
|
(error: Error): void => {
|
|
expect(invalidateSpy.calls.count()).toBe(1);
|
|
expect(invalidateSpy.calls.first().args.length).toBe(1);
|
|
expect(invalidateSpy.calls.first().args[0][0]).toBe("imageByKey");
|
|
expect(invalidateSpy.calls.first().args[0][1].length).toBe(1);
|
|
expect(invalidateSpy.calls.first().args[0][1][0]).toBe(key);
|
|
|
|
done();
|
|
},
|
|
);
|
|
});
|
|
|
|
it("should invalidate model for every error on retry", (done: Function) => {
|
|
let model: falcor.Model = new falcor.Model();
|
|
|
|
let promise: any = {
|
|
then: (resolve: (result: any) => void, reject: (error: Error) => void): void => {
|
|
reject(new Error());
|
|
},
|
|
};
|
|
|
|
let invalidateSpy: jasmine.Spy = spyOn(model, "invalidate");
|
|
invalidateSpy.and.stub();
|
|
|
|
spyOn(model, "get").and.returnValue(promise);
|
|
|
|
let creator: ModelCreator = new ModelCreator();
|
|
let creatorSpy: jasmine.Spy = spyOn(creator, "createModel");
|
|
creatorSpy.and.returnValue(model);
|
|
|
|
let apiV3: APIv3 = new APIv3("clientId", undefined, creator);
|
|
|
|
let key: string = "key";
|
|
|
|
apiV3.imageByKeyFill$([key]).pipe(
|
|
retry(5))
|
|
.subscribe(
|
|
(result: { [key: string]: IFillNode}): void => { return; },
|
|
(error: Error): void => {
|
|
expect(invalidateSpy.calls.count()).toBe(6);
|
|
expect(invalidateSpy.calls.first().args.length).toBe(1);
|
|
expect(invalidateSpy.calls.first().args[0][0]).toBe("imageByKey");
|
|
expect(invalidateSpy.calls.first().args[0][1].length).toBe(1);
|
|
expect(invalidateSpy.calls.first().args[0][1][0]).toBe(key);
|
|
|
|
done();
|
|
},
|
|
);
|
|
});
|
|
});
|
|
|
|
describe("APIv3.imageByKeyFull$", () => {
|
|
it("should call model correctly", (done: Function) => {
|
|
let model: falcor.Model = new falcor.Model();
|
|
|
|
let promise: any = {
|
|
then: (resolve: (result: any) => void, reject: (error: Error) => void): void => {
|
|
resolve({ json: { imageByKey: {} } });
|
|
},
|
|
};
|
|
|
|
let spy: jasmine.Spy = spyOn(model, "get");
|
|
spy.and.returnValue(promise);
|
|
|
|
let creator: ModelCreator = new ModelCreator();
|
|
let creatorSpy: jasmine.Spy = spyOn(creator, "createModel");
|
|
creatorSpy.and.returnValue(model);
|
|
|
|
let apiV3: APIv3 = new APIv3("clientId", undefined, creator);
|
|
|
|
let key: string = "key";
|
|
|
|
apiV3.imageByKeyFull$([key])
|
|
.subscribe(
|
|
(result: { [key: string]: IFillNode}): void => {
|
|
expect(result).toBeDefined();
|
|
|
|
expect(spy.calls.count()).toBe(1);
|
|
expect(spy.calls.first().args.length).toBe(1);
|
|
expect(spy.calls.first().args[0][0]).toBe("imageByKey");
|
|
expect(spy.calls.first().args[0][1].length).toBe(1);
|
|
expect(spy.calls.first().args[0][1][0]).toBe(key);
|
|
|
|
done();
|
|
});
|
|
});
|
|
|
|
it("should throw when result is undefined", (done: Function) => {
|
|
let promise: any = {
|
|
then: (resolve: (result: any) => void, reject: (error: Error) => void): void => {
|
|
resolve(undefined);
|
|
},
|
|
};
|
|
|
|
let model: falcor.Model = new falcor.Model();
|
|
let modelSpy: jasmine.Spy = spyOn(model, "get");
|
|
modelSpy.and.returnValue(promise);
|
|
|
|
let creator: ModelCreator = new ModelCreator();
|
|
let creatorSpy: jasmine.Spy = spyOn(creator, "createModel");
|
|
creatorSpy.and.returnValue(model);
|
|
|
|
let apiV3: APIv3 = new APIv3("clientId", undefined, creator);
|
|
|
|
let key: string = "key";
|
|
|
|
apiV3.imageByKeyFull$([key]).pipe(
|
|
catchError(
|
|
(err: Error): Observable<{}> => {
|
|
expect(err).toBeDefined();
|
|
expect(err instanceof Error).toBe(true);
|
|
|
|
return observableEmpty();
|
|
}))
|
|
.subscribe(
|
|
undefined,
|
|
undefined,
|
|
(): void => { done(); });
|
|
});
|
|
|
|
it("should invalidate model correctly when error is thrown", (done: Function) => {
|
|
let model: falcor.Model = new falcor.Model();
|
|
|
|
let promise: any = {
|
|
then: (resolve: (result: any) => void, reject: (error: Error) => void): void => {
|
|
reject(new Error());
|
|
},
|
|
};
|
|
|
|
let invalidateSpy: jasmine.Spy = spyOn(model, "invalidate");
|
|
invalidateSpy.and.stub();
|
|
|
|
spyOn(model, "get").and.returnValue(promise);
|
|
|
|
let creator: ModelCreator = new ModelCreator();
|
|
let creatorSpy: jasmine.Spy = spyOn(creator, "createModel");
|
|
creatorSpy.and.returnValue(model);
|
|
|
|
let apiV3: APIv3 = new APIv3("clientId", undefined, creator);
|
|
|
|
let key: string = "key";
|
|
|
|
apiV3.imageByKeyFull$([key])
|
|
.subscribe(
|
|
(result: { [key: string]: IFillNode}): void => { return; },
|
|
(error: Error): void => {
|
|
expect(invalidateSpy.calls.count()).toBe(1);
|
|
expect(invalidateSpy.calls.first().args.length).toBe(1);
|
|
expect(invalidateSpy.calls.first().args[0][0]).toBe("imageByKey");
|
|
expect(invalidateSpy.calls.first().args[0][1].length).toBe(1);
|
|
expect(invalidateSpy.calls.first().args[0][1][0]).toBe(key);
|
|
|
|
done();
|
|
},
|
|
);
|
|
});
|
|
});
|
|
|
|
describe("APIv3.imageCloseTo$", () => {
|
|
it("should call model correctly", (done: Function) => {
|
|
let model: falcor.Model = new falcor.Model();
|
|
|
|
let promise: any = {
|
|
then: (resolve: (result: any) => void, reject: (error: Error) => void): void => {
|
|
resolve({ json: { imageCloseTo: { "0:0": null } } });
|
|
},
|
|
};
|
|
|
|
let spy: jasmine.Spy = spyOn(model, "get");
|
|
spy.and.returnValue(promise);
|
|
|
|
let creator: ModelCreator = new ModelCreator();
|
|
let creatorSpy: jasmine.Spy = spyOn(creator, "createModel");
|
|
creatorSpy.and.returnValue(model);
|
|
|
|
let apiV3: APIv3 = new APIv3("clientId", undefined, creator);
|
|
|
|
let lat: number = 0;
|
|
let lon: number = 0;
|
|
|
|
apiV3.imageCloseTo$(lat, lon)
|
|
.subscribe(
|
|
(result: IFullNode): void => {
|
|
expect(result).toBeDefined();
|
|
|
|
expect(spy.calls.count()).toBe(1);
|
|
expect(spy.calls.first().args.length).toBe(1);
|
|
expect(spy.calls.first().args[0][0]).toBe("imageCloseTo");
|
|
expect(spy.calls.first().args[0][1].length).toBe(1);
|
|
expect(spy.calls.first().args[0][1][0]).toBe("0:0");
|
|
|
|
done();
|
|
});
|
|
});
|
|
|
|
it("should invalidate model correctly when error is thrown", (done: Function) => {
|
|
let model: falcor.Model = new falcor.Model();
|
|
|
|
let promise: any = {
|
|
then: (resolve: (result: any) => void, reject: (error: Error) => void): void => {
|
|
reject(new Error());
|
|
},
|
|
};
|
|
|
|
let invalidateSpy: jasmine.Spy = spyOn(model, "invalidate");
|
|
invalidateSpy.and.stub();
|
|
|
|
spyOn(model, "get").and.returnValue(promise);
|
|
|
|
let creator: ModelCreator = new ModelCreator();
|
|
let creatorSpy: jasmine.Spy = spyOn(creator, "createModel");
|
|
creatorSpy.and.returnValue(model);
|
|
|
|
let apiV3: APIv3 = new APIv3("clientId", undefined, creator);
|
|
|
|
let lat: number = 0;
|
|
let lon: number = 0;
|
|
|
|
apiV3.imageCloseTo$(lat, lon)
|
|
.subscribe(
|
|
(result: IFullNode): void => { return; },
|
|
(error: Error): void => {
|
|
expect(invalidateSpy.calls.count()).toBe(1);
|
|
expect(invalidateSpy.calls.first().args.length).toBe(1);
|
|
expect(invalidateSpy.calls.first().args[0][0]).toBe("imageCloseTo");
|
|
expect(invalidateSpy.calls.first().args[0][1].length).toBe(1);
|
|
expect(invalidateSpy.calls.first().args[0][1][0]).toBe("0:0");
|
|
|
|
done();
|
|
},
|
|
);
|
|
});
|
|
});
|
|
|
|
describe("APIv3.imagesByH$", () => {
|
|
it("should call model correctly", (done: Function) => {
|
|
let model: falcor.Model = new falcor.Model();
|
|
|
|
let promise: any = {
|
|
then: (resolve: (result: any) => void, reject: (error: Error) => void): void => {
|
|
resolve({ json: { imagesByH: {} } });
|
|
},
|
|
};
|
|
|
|
let spy: jasmine.Spy = spyOn(model, "get");
|
|
spy.and.returnValue(promise);
|
|
|
|
let creator: ModelCreator = new ModelCreator();
|
|
let creatorSpy: jasmine.Spy = spyOn(creator, "createModel");
|
|
creatorSpy.and.returnValue(model);
|
|
|
|
let apiV3: APIv3 = new APIv3("clientId", undefined, creator);
|
|
|
|
let h: string = "h";
|
|
|
|
apiV3.imagesByH$([h])
|
|
.subscribe(
|
|
(result: { [key: string]: { [index: string]: ICoreNode } }): void => {
|
|
expect(result).toBeDefined();
|
|
|
|
expect(spy.calls.count()).toBe(1);
|
|
expect(spy.calls.first().args.length).toBe(1);
|
|
expect(spy.calls.first().args[0][0]).toBe("imagesByH");
|
|
expect(spy.calls.first().args[0][1].length).toBe(1);
|
|
expect(spy.calls.first().args[0][1][0]).toBe(h);
|
|
|
|
done();
|
|
});
|
|
});
|
|
|
|
it("should invalidate model correctly when error is thrown", (done: Function) => {
|
|
let model: falcor.Model = new falcor.Model();
|
|
|
|
let promise: any = {
|
|
then: (resolve: (result: any) => void, reject: (error: Error) => void): void => {
|
|
reject(new Error());
|
|
},
|
|
};
|
|
|
|
let invalidateSpy: jasmine.Spy = spyOn(model, "invalidate");
|
|
invalidateSpy.and.stub();
|
|
|
|
spyOn(model, "get").and.returnValue(promise);
|
|
|
|
let creator: ModelCreator = new ModelCreator();
|
|
let creatorSpy: jasmine.Spy = spyOn(creator, "createModel");
|
|
creatorSpy.and.returnValue(model);
|
|
|
|
let apiV3: APIv3 = new APIv3("clientId", undefined, creator);
|
|
|
|
let h: string = "h";
|
|
|
|
apiV3.imagesByH$([h])
|
|
.subscribe(
|
|
(result: { [key: string]: { [index: string]: ICoreNode } }): void => { return; },
|
|
(error: Error): void => {
|
|
expect(invalidateSpy.calls.count()).toBe(1);
|
|
expect(invalidateSpy.calls.first().args.length).toBe(1);
|
|
expect(invalidateSpy.calls.first().args[0][0]).toBe("imagesByH");
|
|
expect(invalidateSpy.calls.first().args[0][1].length).toBe(1);
|
|
expect(invalidateSpy.calls.first().args[0][1][0]).toBe(h);
|
|
|
|
done();
|
|
},
|
|
);
|
|
});
|
|
|
|
it("should handle undefined response", (done: Function) => {
|
|
let model: falcor.Model = new falcor.Model();
|
|
|
|
let promise: any = {
|
|
then: (resolve: (result: any) => void, reject: (error: Error) => void): void => {
|
|
resolve(undefined);
|
|
},
|
|
};
|
|
|
|
let spy: jasmine.Spy = spyOn(model, "get");
|
|
spy.and.returnValue(promise);
|
|
|
|
let creator: ModelCreator = new ModelCreator();
|
|
let creatorSpy: jasmine.Spy = spyOn(creator, "createModel");
|
|
creatorSpy.and.returnValue(model);
|
|
|
|
let apiV3: APIv3 = new APIv3("clientId", undefined, creator);
|
|
|
|
let h: string = "h";
|
|
|
|
apiV3.imagesByH$([h])
|
|
.subscribe(
|
|
(result: { [key: string]: { [index: string]: ICoreNode } }): void => {
|
|
expect(result).toBeDefined();
|
|
expect(result[h]).toBeDefined();
|
|
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("APIv3.sequenceByKey$", () => {
|
|
it("should call model correctly", (done: Function) => {
|
|
spyOn(console, "warn").and.stub();
|
|
|
|
let model: falcor.Model = new falcor.Model();
|
|
|
|
let promise: any = {
|
|
then: (resolve: (result: any) => void, reject: (error: Error) => void): void => {
|
|
resolve({ json: { sequenceByKey: {} } });
|
|
},
|
|
};
|
|
|
|
let spy: jasmine.Spy = spyOn(model, "get");
|
|
spy.and.returnValue(promise);
|
|
|
|
let creator: ModelCreator = new ModelCreator();
|
|
let creatorSpy: jasmine.Spy = spyOn(creator, "createModel");
|
|
creatorSpy.and.returnValue(model);
|
|
|
|
let apiV3: APIv3 = new APIv3("clientId", undefined, creator);
|
|
|
|
let skey: string = "skey";
|
|
|
|
apiV3.sequenceByKey$([skey])
|
|
.subscribe(
|
|
(result: { [key: string]: ISequence }): void => {
|
|
expect(result).toBeDefined();
|
|
|
|
expect(spy.calls.count()).toBe(1);
|
|
expect(spy.calls.first().args.length).toBe(1);
|
|
expect(spy.calls.first().args[0][0]).toBe("sequenceByKey");
|
|
expect(spy.calls.first().args[0][1].length).toBe(1);
|
|
expect(spy.calls.first().args[0][1][0]).toBe(skey);
|
|
|
|
done();
|
|
});
|
|
});
|
|
|
|
it("should invalidate model correctly when error is thrown", (done: Function) => {
|
|
let model: falcor.Model = new falcor.Model();
|
|
|
|
let promise: any = {
|
|
then: (resolve: (result: any) => void, reject: (error: Error) => void): void => {
|
|
reject(new Error());
|
|
},
|
|
};
|
|
|
|
let invalidateSpy: jasmine.Spy = spyOn(model, "invalidate");
|
|
invalidateSpy.and.stub();
|
|
|
|
spyOn(model, "get").and.returnValue(promise);
|
|
|
|
let creator: ModelCreator = new ModelCreator();
|
|
let creatorSpy: jasmine.Spy = spyOn(creator, "createModel");
|
|
creatorSpy.and.returnValue(model);
|
|
|
|
let apiV3: APIv3 = new APIv3("clientId", undefined, creator);
|
|
|
|
let skey: string = "skey";
|
|
|
|
apiV3.sequenceByKey$([skey])
|
|
.subscribe(
|
|
(result: { [key: string]: ISequence }): void => { return; },
|
|
(error: Error): void => {
|
|
expect(invalidateSpy.calls.count()).toBe(1);
|
|
expect(invalidateSpy.calls.first().args.length).toBe(1);
|
|
expect(invalidateSpy.calls.first().args[0][0]).toBe("sequenceByKey");
|
|
expect(invalidateSpy.calls.first().args[0][1].length).toBe(1);
|
|
expect(invalidateSpy.calls.first().args[0][1][0]).toBe(skey);
|
|
|
|
done();
|
|
},
|
|
);
|
|
});
|
|
|
|
it("should call model correctly", (done: Function) => {
|
|
spyOn(console, "warn").and.stub();
|
|
|
|
let skey: string = "skey";
|
|
let nkey: string = "nkey";
|
|
|
|
let model: falcor.Model = new falcor.Model();
|
|
|
|
let promise: any = {
|
|
then: (resolve: (result: any) => void, reject: (error: Error) => void): void => {
|
|
resolve({ json: { sequenceByKey: { skey: { key: skey, keys: [nkey] } } } });
|
|
},
|
|
};
|
|
|
|
let spy: jasmine.Spy = spyOn(model, "get");
|
|
spy.and.returnValue(promise);
|
|
|
|
let creator: ModelCreator = new ModelCreator();
|
|
let creatorSpy: jasmine.Spy = spyOn(creator, "createModel");
|
|
creatorSpy.and.returnValue(model);
|
|
|
|
let apiV3: APIv3 = new APIv3("clientId", undefined, creator);
|
|
|
|
apiV3.sequenceByKey$([skey])
|
|
.subscribe(
|
|
(result: { [key: string]: ISequence }): void => {
|
|
expect(result).toBeDefined();
|
|
expect(result[skey]).toBeDefined();
|
|
expect(result[skey].key).toBe(skey);
|
|
expect(result[skey].keys.length).toBe(1);
|
|
expect(result[skey].keys[0]).toBe(nkey);
|
|
|
|
done();
|
|
});
|
|
});
|
|
|
|
it("should create empty sequence if return value is not defined", (done: Function) => {
|
|
spyOn(console, "warn").and.stub();
|
|
|
|
let model: falcor.Model = new falcor.Model();
|
|
|
|
let promise: any = {
|
|
then: (resolve: (result: any) => void, reject: (error: Error) => void): void => {
|
|
resolve(undefined);
|
|
},
|
|
};
|
|
|
|
let spy: jasmine.Spy = spyOn(model, "get");
|
|
spy.and.returnValue(promise);
|
|
|
|
let creator: ModelCreator = new ModelCreator();
|
|
let creatorSpy: jasmine.Spy = spyOn(creator, "createModel");
|
|
creatorSpy.and.returnValue(model);
|
|
|
|
let apiV3: APIv3 = new APIv3("clientId", undefined, creator);
|
|
|
|
let skey: string = "skey";
|
|
|
|
apiV3.sequenceByKey$([skey])
|
|
.subscribe(
|
|
(result: { [key: string]: ISequence }): void => {
|
|
expect(result).toBeDefined();
|
|
expect(result[skey]).toBeDefined();
|
|
expect(result[skey].key).toBe(skey);
|
|
expect(result[skey].keys.length).toBe(0);
|
|
|
|
done();
|
|
});
|
|
});
|
|
|
|
it("should populate empty sequence if missing", (done: Function) => {
|
|
spyOn(console, "warn").and.stub();
|
|
|
|
let model: falcor.Model = new falcor.Model();
|
|
|
|
let promise: any = {
|
|
then: (resolve: (result: any) => void, reject: (error: Error) => void): void => {
|
|
resolve({ json: { sequenceByKey: {} } });
|
|
},
|
|
};
|
|
|
|
let spy: jasmine.Spy = spyOn(model, "get");
|
|
spy.and.returnValue(promise);
|
|
|
|
let creator: ModelCreator = new ModelCreator();
|
|
let creatorSpy: jasmine.Spy = spyOn(creator, "createModel");
|
|
creatorSpy.and.returnValue(model);
|
|
|
|
let apiV3: APIv3 = new APIv3("clientId", undefined, creator);
|
|
|
|
let skey: string = "skey";
|
|
|
|
apiV3.sequenceByKey$([skey])
|
|
.subscribe(
|
|
(result: { [key: string]: ISequence }): void => {
|
|
expect(result).toBeDefined();
|
|
expect(result[skey]).toBeDefined();
|
|
expect(result[skey].key).toBe(skey);
|
|
expect(result[skey].keys.length).toBe(0);
|
|
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("APIv3.imageViewAdd$", () => {
|
|
it("should call model correctly", (done: Function) => {
|
|
let model: falcor.Model = new falcor.Model();
|
|
|
|
let promise: any = {
|
|
then: (resolve: (result: any) => void, reject: (error: Error) => void): void => {
|
|
resolve(undefined);
|
|
},
|
|
};
|
|
|
|
let spy: jasmine.Spy = spyOn(model, "call");
|
|
spy.and.returnValue(promise);
|
|
|
|
let creator: ModelCreator = new ModelCreator();
|
|
let creatorSpy: jasmine.Spy = spyOn(creator, "createModel");
|
|
creatorSpy.and.returnValue(model);
|
|
|
|
let apiV3: APIv3 = new APIv3("clientId", undefined, creator);
|
|
|
|
let key: string = "key";
|
|
|
|
apiV3.imageViewAdd$([key])
|
|
.subscribe(
|
|
(): void => {
|
|
expect(spy.calls.count()).toBe(1);
|
|
expect(spy.calls.first().args.length).toBe(2);
|
|
expect(spy.calls.first().args[0].length).toBe(1);
|
|
expect(spy.calls.first().args[0][0]).toBe("imageViewAdd");
|
|
expect(spy.calls.first().args[1][0].length).toBe(1);
|
|
expect(spy.calls.first().args[1][0][0]).toBe(key);
|
|
|
|
done();
|
|
});
|
|
});
|
|
|
|
it("should invalidate model correctly when error is thrown", (done: Function) => {
|
|
let model: falcor.Model = new falcor.Model();
|
|
|
|
let promise: any = {
|
|
then: (resolve: (result: any) => void, reject: (error: Error) => void): void => {
|
|
reject(new Error());
|
|
},
|
|
};
|
|
|
|
let invalidateSpy: jasmine.Spy = spyOn(model, "invalidate");
|
|
invalidateSpy.and.stub();
|
|
|
|
spyOn(model, "call").and.returnValue(promise);
|
|
|
|
let creator: ModelCreator = new ModelCreator();
|
|
let creatorSpy: jasmine.Spy = spyOn(creator, "createModel");
|
|
creatorSpy.and.returnValue(model);
|
|
|
|
let apiV3: APIv3 = new APIv3("clientId", undefined, creator);
|
|
|
|
let key: string = "key";
|
|
|
|
apiV3.imageViewAdd$([key])
|
|
.subscribe(
|
|
(): void => { return; },
|
|
(error: Error): void => {
|
|
expect(invalidateSpy.calls.count()).toBe(1);
|
|
expect(invalidateSpy.calls.first().args.length).toBe(2);
|
|
expect(invalidateSpy.calls.first().args[0].length).toBe(1);
|
|
expect(invalidateSpy.calls.first().args[0][0]).toBe("imageViewAdd");
|
|
expect(invalidateSpy.calls.first().args[1][0].length).toBe(1);
|
|
expect(invalidateSpy.calls.first().args[1][0][0]).toBe(key);
|
|
|
|
done();
|
|
},
|
|
);
|
|
});
|
|
});
|
|
|
|
describe("APIv3.sequenceViewAdd$", () => {
|
|
it("should call model correctly", (done: Function) => {
|
|
let model: falcor.Model = new falcor.Model();
|
|
|
|
let promise: any = {
|
|
then: (resolve: (result: any) => void, reject: (error: Error) => void): void => {
|
|
resolve(undefined);
|
|
},
|
|
};
|
|
|
|
let spy: jasmine.Spy = spyOn(model, "call");
|
|
spy.and.returnValue(promise);
|
|
|
|
let creator: ModelCreator = new ModelCreator();
|
|
let creatorSpy: jasmine.Spy = spyOn(creator, "createModel");
|
|
creatorSpy.and.returnValue(model);
|
|
|
|
let apiV3: APIv3 = new APIv3("clientId", undefined, creator);
|
|
|
|
let skey: string = "skey";
|
|
|
|
apiV3.sequenceViewAdd$([skey])
|
|
.subscribe(
|
|
(): void => {
|
|
expect(spy.calls.count()).toBe(1);
|
|
expect(spy.calls.first().args.length).toBe(2);
|
|
expect(spy.calls.first().args[0].length).toBe(1);
|
|
expect(spy.calls.first().args[0][0]).toBe("sequenceViewAdd");
|
|
expect(spy.calls.first().args[1][0].length).toBe(1);
|
|
expect(spy.calls.first().args[1][0][0]).toBe(skey);
|
|
|
|
done();
|
|
});
|
|
});
|
|
|
|
it("should invalidate model correctly when error is thrown", (done: Function) => {
|
|
let model: falcor.Model = new falcor.Model();
|
|
|
|
let promise: any = {
|
|
then: (resolve: (result: any) => void, reject: (error: Error) => void): void => {
|
|
reject(new Error());
|
|
},
|
|
};
|
|
|
|
let invalidateSpy: jasmine.Spy = spyOn(model, "invalidate");
|
|
invalidateSpy.and.stub();
|
|
|
|
spyOn(model, "call").and.returnValue(promise);
|
|
|
|
let creator: ModelCreator = new ModelCreator();
|
|
let creatorSpy: jasmine.Spy = spyOn(creator, "createModel");
|
|
creatorSpy.and.returnValue(model);
|
|
|
|
let apiV3: APIv3 = new APIv3("clientId", undefined, creator);
|
|
|
|
let skey: string = "skey";
|
|
|
|
apiV3.sequenceViewAdd$([skey])
|
|
.subscribe(
|
|
(): void => { return; },
|
|
(error: Error): void => {
|
|
expect(invalidateSpy.calls.count()).toBe(1);
|
|
expect(invalidateSpy.calls.first().args.length).toBe(2);
|
|
expect(invalidateSpy.calls.first().args[0].length).toBe(1);
|
|
expect(invalidateSpy.calls.first().args[0][0]).toBe("sequenceViewAdd");
|
|
expect(invalidateSpy.calls.first().args[1][0].length).toBe(1);
|
|
expect(invalidateSpy.calls.first().args[1][0][0]).toBe(skey);
|
|
|
|
done();
|
|
},
|
|
);
|
|
});
|
|
});
|
|
|
|
describe("APIv3.invalidateImageByKey", () => {
|
|
it("should call model correctly", () => {
|
|
let model: falcor.Model = new falcor.Model();
|
|
|
|
let spy: jasmine.Spy = spyOn(model, "invalidate");
|
|
|
|
let creator: ModelCreator = new ModelCreator();
|
|
let creatorSpy: jasmine.Spy = spyOn(creator, "createModel");
|
|
creatorSpy.and.returnValue(model);
|
|
|
|
let apiV3: APIv3 = new APIv3("clientId", undefined, creator);
|
|
|
|
let key: string = "key";
|
|
|
|
apiV3.invalidateImageByKey([key]);
|
|
|
|
expect(spy.calls.count()).toBe(1);
|
|
expect(spy.calls.first().args[0].length).toBe(2);
|
|
expect(spy.calls.first().args[0][0]).toBe("imageByKey");
|
|
expect(spy.calls.first().args[0][1].length).toBe(1);
|
|
expect(spy.calls.first().args[0][1][0]).toBe(key);
|
|
});
|
|
});
|
|
|
|
describe("APIv3.invalidateImagesByH", () => {
|
|
it("should call model correctly", () => {
|
|
let model: falcor.Model = new falcor.Model();
|
|
|
|
let spy: jasmine.Spy = spyOn(model, "invalidate");
|
|
|
|
let creator: ModelCreator = new ModelCreator();
|
|
let creatorSpy: jasmine.Spy = spyOn(creator, "createModel");
|
|
creatorSpy.and.returnValue(model);
|
|
|
|
let apiV3: APIv3 = new APIv3("clientId", undefined, creator);
|
|
|
|
let h: string = "h";
|
|
|
|
apiV3.invalidateImagesByH([h]);
|
|
|
|
expect(spy.calls.count()).toBe(1);
|
|
expect(spy.calls.first().args[0].length).toBe(2);
|
|
expect(spy.calls.first().args[0][0]).toBe("imagesByH");
|
|
expect(spy.calls.first().args[0][1].length).toBe(1);
|
|
expect(spy.calls.first().args[0][1][0]).toBe(h);
|
|
});
|
|
});
|
|
|
|
describe("APIv3.invalidateSequenceByKey", () => {
|
|
it("should call model correctly", () => {
|
|
let model: falcor.Model = new falcor.Model();
|
|
|
|
let spy: jasmine.Spy = spyOn(model, "invalidate");
|
|
|
|
let creator: ModelCreator = new ModelCreator();
|
|
let creatorSpy: jasmine.Spy = spyOn(creator, "createModel");
|
|
creatorSpy.and.returnValue(model);
|
|
|
|
let apiV3: APIv3 = new APIv3("clientId", undefined, creator);
|
|
|
|
let sKey: string = "sKey";
|
|
|
|
apiV3.invalidateSequenceByKey([sKey]);
|
|
|
|
expect(spy.calls.count()).toBe(1);
|
|
expect(spy.calls.first().args[0].length).toBe(2);
|
|
expect(spy.calls.first().args[0][0]).toBe("sequenceByKey");
|
|
expect(spy.calls.first().args[0][1].length).toBe(1);
|
|
expect(spy.calls.first().args[0][1][0]).toBe(sKey);
|
|
});
|
|
});
|
|
|
|
describe("APIv3.setToken", () => {
|
|
it("should invalidate old model and create a new with token", () => {
|
|
let model: falcor.Model = new falcor.Model();
|
|
|
|
let modelSpy: jasmine.Spy = spyOn(model, "invalidate");
|
|
|
|
let creator: ModelCreator = new ModelCreator();
|
|
let creatorSpy: jasmine.Spy = spyOn(creator, "createModel");
|
|
creatorSpy.and.returnValue(model);
|
|
|
|
let apiV3: APIv3 = new APIv3("clientId", undefined, creator);
|
|
|
|
apiV3.setToken("token");
|
|
|
|
expect(modelSpy.calls.count()).toBe(1);
|
|
|
|
expect(creatorSpy.calls.count()).toBe(2);
|
|
expect(creatorSpy.calls.first().args.length).toBe(2);
|
|
expect(creatorSpy.calls.first().args[0]).toBe("clientId");
|
|
expect(creatorSpy.calls.first().args[1]).toBeUndefined();
|
|
expect(creatorSpy.calls.mostRecent().args.length).toBe(2);
|
|
expect(creatorSpy.calls.mostRecent().args[0]).toBe("clientId");
|
|
expect(creatorSpy.calls.mostRecent().args[1]).toBe("token");
|
|
});
|
|
});
|