@panoramax/web-viewer 3.2.3-develop-dfee2adc → 3.2.3-develop-357c83ca

package/tests/components/core/Basic.test.js

@@ -103,7 +103,7 @@ describe("addEventListener", () => {
 		expect(listener).toHaveBeenCalledTimes(1);
 	});
 
-	it("should wait for map to be available", () => {
+	it("should wait for sub-component to be available", () => {
 		const listener = jest.fn();
 		global.setTimeout = jest.fn();
 		basic.getSubComponentsNames = () => ["loader", "api", "map"];
@@ -112,15 +112,6 @@ describe("addEventListener", () => {
 		expect(global.setTimeout).toHaveBeenCalled();
 	});
 
-	it("should add event listener with once option for map", () => {
-		const listener = jest.fn();
-		basic.getSubComponentsNames = () => ["loader", "api", "map"];
-		basic.map = { on: jest.fn(), once: jest.fn() };
-		basic.addEventListener("map:move", listener, { once: true });
-		expect(basic.map.on).toHaveBeenCalledTimes(0);
-		expect(basic.map.once).toHaveBeenCalledWith("move", listener);
-	});
-
 	it("adds listener to basic if no sub-component matches prefix", () => {
 		const listener = jest.fn();
 		basic.addEventListener("unknown:event", listener);

package/tests/components/ui/Map.test.js

@@ -20,6 +20,20 @@ const createParent = () => ({
 });
 
 
+describe("_postLoad", () => {
+	it("send ready event", async () => {
+		const p = createParent();
+		const c = document.createElement("div");
+		const m = new Map(p, c);
+		const listener = jest.fn();
+		m.addEventListener("ready", listener, { once: true });
+
+		await m._postLoad();
+		
+		expect(listener).toHaveBeenCalledTimes(1);
+	});
+});
+
 describe("reloadVectorTiles", () => {
 	it("works", () => {
 		const p = createParent();
@@ -188,3 +202,43 @@ describe("reloadLayersStyles", () => {
 		expect(m.setPaintProperty.mock.calls).toMatchSnapshot();
 	});
 });
+
+describe("addEventListener", () => {
+	let map;
+	beforeEach(() => {
+		const p = createParent();
+		const c = document.createElement("div");
+		map = new Map(p, c);
+	});
+	
+	it("should add an event listener", () => {
+		const listener = jest.fn();
+		map.addEventListener("ready", listener);
+		map.fire("ready");
+		expect(listener).toHaveBeenCalled();
+	});
+	
+	it("should add an event listener that only fires once", () => {
+		const listener = jest.fn();
+		map.addEventListener("ready", listener, { once: true });
+		map.fire("ready");
+		map.fire("ready");
+		expect(listener).toHaveBeenCalledTimes(1);
+	});
+	
+	it("should not add an event listener if options.once is false", () => {
+		const listener = jest.fn();
+		map.addEventListener("ready", listener, { once: false });
+		map.fire("ready");
+		map.fire("ready");
+		expect(listener).toHaveBeenCalledTimes(2);
+	});
+	
+	it("should default options.once to false if not provided", () => {
+		const listener = jest.fn();
+		map.addEventListener("ready", listener);
+		map.fire("ready");
+		map.fire("ready");
+		expect(listener).toHaveBeenCalledTimes(2);
+	});
+});

package/tests/utils/API.test.js

@@ -34,30 +34,28 @@ const LANDING_NO_PREVIEW = {
 
 describe("constructor", () => {
 	// Mock landing fetch
-	global.fetch = jest.fn(() => Promise.resolve({
-		json: () => Promise.resolve(VALID_LANDING)
-	}));
+	global.fetch = () => Promise.resolve({
+		json: () => new Promise(resolve => setTimeout(() => resolve(VALID_LANDING), 50))
+	});
 
 	it("works with valid endpoint", () => {
-		const api = new API(ENDPOINT, { skipReadLanding: true });
+		const api = new API(ENDPOINT);
 		expect(api._endpoint).toBe(ENDPOINT);
 	});
 
 	it("works with relative path", () => {
-		const api = new API("/api", { skipReadLanding: true });
+		const api = new API("/api");
 		expect(api._endpoint).toBe("http://localhost/api");
 	});
 
 	it("handles tiles overrides", () => {
-		// Mock landing fetch
-		global.fetch = jest.fn(() => Promise.resolve({
-			json: () => Promise.resolve(VALID_LANDING)
-		}));
-
+		const listener = jest.fn();
 		const api = new API(ENDPOINT, { tiles: "https://my.custom.tiles/" });
+		api.addEventListener("ready", listener);
 		return api.onceReady().then(() => {
 			expect(api._endpoint).toBe(ENDPOINT);
 			expect(api._endpoints.tiles).toBe("https://my.custom.tiles/");
+			expect(listener).toHaveBeenCalled();
 		});
 	});
 
@@ -69,8 +67,23 @@ describe("constructor", () => {
 		expect(() => new API()).toThrow("endpoint parameter is empty or not a valid string");
 	});
 
+	it("fails on fetch failure", async () => {
+		// Mock landing fetch
+		global.fetch = () => Promise.resolve({
+			json: () => new Promise((resolve, reject) => setTimeout(() => reject(new Error("brok")), 50))
+		});
+		
+		const listener = jest.fn();
+		const api = new API(ENDPOINT);
+		api.addEventListener("broken", listener);
+		return api.onceReady().catch(e => {
+			expect(e).toEqual("Viewer failed to communicate with API");
+			expect(listener.mock.calls).toMatchSnapshot();
+		});
+	});
+
 	it("accepts fetch options", () => {
-		const api = new API("/api", { skipReadLanding: true, fetch: { bla: "bla" } });
+		const api = new API("/api", { fetch: { bla: "bla" } });
 		expect(api._getFetchOptions()).toEqual({ bla: "bla" });
 	});
 });
@@ -793,84 +806,84 @@ describe("sendReport", () => {
 	});
 
 	it("throws an error if API is not ready", () => {
-        api.isReady = () => false;
-        expect(() => api.sendReport({})).toThrow("API is not ready to use");
-    });
-
-    it("throws an error if report endpoint is not available", () => {
-        api._endpoints.report = null;
-        expect(() => api.sendReport({})).toThrow("Report sending is not available");
-    });
-
-    it("sends a report successfully", async () => {
-        // Mock fetch response
-        const mockResponse = {
-            status: 200,
-            json: jest.fn().mockResolvedValue({ id: "bla" })
-        };
-        global.fetch = jest.fn().mockResolvedValue(mockResponse);
-
-        const data = {
+		api.isReady = () => false;
+		expect(() => api.sendReport({})).toThrow("API is not ready to use");
+	});
+
+	it("throws an error if report endpoint is not available", () => {
+		api._endpoints.report = null;
+		expect(() => api.sendReport({})).toThrow("Report sending is not available");
+	});
+
+	it("sends a report successfully", async () => {
+		// Mock fetch response
+		const mockResponse = {
+			status: 200,
+			json: jest.fn().mockResolvedValue({ id: "bla" })
+		};
+		global.fetch = jest.fn().mockResolvedValue(mockResponse);
+
+		const data = {
 			issue: "blur_missing",
 			picture_id: "bla1",
 			sequence_id: "bla2",
 		};
 
-        const response = await api.sendReport(data);
+		const response = await api.sendReport(data);
         
-        expect(fetch).toHaveBeenCalledWith(ENDPOINT+"/reports", {
-            method: "POST",
-            body: JSON.stringify(data),
-            headers: { "Content-Type": "application/json" }
-        });
-        expect(response).toEqual({ id: "bla" });
-    });
-
-    it("handles API errors and rejects with message", async () => {
-        // Mock fetch response with an error
-        const mockResponse = {
-            status: 400,
-            text: jest.fn().mockResolvedValue(JSON.stringify({ message: "Error occurred" }))
-        };
-        global.fetch = jest.fn().mockResolvedValue(mockResponse);
-
-        const data = {
+		expect(fetch).toHaveBeenCalledWith(ENDPOINT+"/reports", {
+			method: "POST",
+			body: JSON.stringify(data),
+			headers: { "Content-Type": "application/json" }
+		});
+		expect(response).toEqual({ id: "bla" });
+	});
+
+	it("handles API errors and rejects with message", async () => {
+		// Mock fetch response with an error
+		const mockResponse = {
+			status: 400,
+			text: jest.fn().mockResolvedValue(JSON.stringify({ message: "Error occurred" }))
+		};
+		global.fetch = jest.fn().mockResolvedValue(mockResponse);
+
+		const data = {
 			issue: "blur_missing",
 			picture_id: "bla1",
 			sequence_id: "bla2",
 		};
 
-        await expect(api.sendReport(data)).rejects.toEqual("Error occurred");
+		await expect(api.sendReport(data)).rejects.toEqual("Error occurred");
 
-        expect(fetch).toHaveBeenCalledWith(ENDPOINT+"/reports", {
-            method: "POST",
-            body: JSON.stringify(data),
-            headers: { "Content-Type": "application/json" }
-        });
-    });
+		expect(fetch).toHaveBeenCalledWith(ENDPOINT+"/reports", {
+			method: "POST",
+			body: JSON.stringify(data),
+			headers: { "Content-Type": "application/json" }
+		});
+	});
 
-    it("handles API errors and rejects with text if no message in JSON", async () => {
-        // Mock fetch response with an error and no "message" key
-        const mockResponse = {
-            status: 400,
-            text: jest.fn().mockResolvedValue("Some error text")
-        };
-        global.fetch = jest.fn().mockResolvedValue(mockResponse);
+	it("handles API errors and rejects with text if no message in JSON", async () => {
+		// Mock fetch response with an error and no "message" key
+		const mockResponse = {
+			status: 400,
+			text: jest.fn().mockResolvedValue("Some error text")
+		};
+		global.fetch = jest.fn().mockResolvedValue(mockResponse);
 
-        const data = {
+		const data = {
 			issue: "blur_missing",
 			picture_id: "bla1",
 			sequence_id: "bla2",
 		};
 
-        await expect(api.sendReport(data)).rejects.toEqual("Some error text");
+		await expect(api.sendReport(data)).rejects.toEqual("Some error text");
 
-        expect(fetch).toHaveBeenCalledWith(ENDPOINT+"/reports", {
-            method: "POST",
-            body: JSON.stringify(data),
-            headers: { "Content-Type": "application/json" }
-        });
-    });
+		expect(fetch).toHaveBeenCalledWith(ENDPOINT+"/reports", {
+			method: "POST",
+			body: JSON.stringify(data),
+			headers: { "Content-Type": "application/json" }
+		});
+	});
 });
 
 describe("isValidHttpUrl", () => {

package/tests/utils/__snapshots__/API.test.js.snap

@@ -135,3 +135,13 @@ No direct access to pictures metadata.
 API doesn't offer a 'data' (application/json) endpoint in its links
 No way for viewer to access sequences."
 `;
+
+exports[`constructor fails on fetch failure 1`] = `
+Array [
+  Array [
+    CustomEvent {
+      "isTrusted": false,
+    },
+  ],
+]
+`;