@panoramax/web-viewer 3.0.2-develop-a8ea8e60

package/tests/utils/Exif.test.js

@@ -0,0 +1,124 @@
+import * as Exif from "../../src/utils/Exif";
+
+describe("getExifFloat", () => {
+	it.each([
+		[undefined, undefined],
+		[null, undefined],
+		["", undefined],
+		["   ", undefined],
+		[1, 1],
+		[1.4, 1.4],
+		["1", 1],
+		["-1.4", -1.4],
+		["-104/10", -10.4],
+		["-104.12/-12.12", 8.590759075907592],
+	])("works with %s", (input, expected) => {
+		expect(Exif.getExifFloat(input)).toBe(expected);
+	});
+});
+
+describe("getGPSPrecision", () => {
+	it.each([
+		[undefined, "unknown"],
+		[0.4, "ideal"],
+		[0.9, "excellent"],
+		[2.9, "good"],
+		[6.9, "moderate"],
+		[9.9, "fair"],
+		[20, "poor"],
+		["9/10", "excellent"],
+		["99/10", "fair"],
+	])("handles GPSHPos %s > %s", (input, expected) => {
+		const p = { properties: { exif: { "Exif.GPSInfo.GPSHPositioningError": input, "Exif.GPSInfo.GPSDOP": input } } };
+		expect(Exif.getGPSPrecision(p)).toBe(expected);
+	});
+
+	it.each([
+		[undefined, "unknown"],
+		[0.9, "ideal"],
+		[1.9, "excellent"],
+		[4.9, "good"],
+		[9.9, "moderate"],
+		[19.9, "fair"],
+		[20, "poor"],
+		["1/1", "excellent"],
+		["15/10", "excellent"],
+	])("handles GPSDOP %s > %s", (input, expected) => {
+		const p = { properties: { exif: { "Exif.GPSInfo.GPSDOP": input } } };
+		expect(Exif.getGPSPrecision(p)).toBe(expected);
+	});
+});
+
+describe("getSphereCorrection", () => {
+	it("works with API props", () => {
+		const p = { properties: {
+			"view:azimuth": 50,
+			"pers:yaw": 42,
+			"pers:pitch": -30,
+			"pers:roll": 72.2
+		} };
+		expect(Exif.getSphereCorrection(p)).toMatchSnapshot();
+	});
+
+	it("works with exif tags", () => {
+		const p = { properties: {
+			exif: {
+				"Xmp.Camera.Pitch": "-30/1",
+				"Xmp.GPano.PoseRollDegrees": 72.2,
+				"Exif.MpfInfo.MPFYawAngle": 42,
+			},
+			"view:azimuth": 50,
+		} };
+		expect(Exif.getSphereCorrection(p)).toMatchSnapshot();
+	});
+});
+
+describe("getCroppedPanoData", () => {
+	it("works with API props", () => {
+		const p = { properties: {
+			"pers:interior_orientation": {
+				"sensor_array_dimensions": [15872,7936],
+				"visible_area": [0,2538,0,2792]
+			}
+		} };
+		expect(Exif.getCroppedPanoData(p)).toMatchSnapshot();
+	});
+
+	it("works with exif tags", () => {
+		const p = { properties: {
+			exif: {
+				"Xmp.GPano.CroppedAreaImageHeightPixels": "2606",
+				"Xmp.GPano.CroppedAreaImageWidthPixels": "15872",
+				"Xmp.GPano.CroppedAreaLeftPixels": "0",
+				"Xmp.GPano.CroppedAreaTopPixels": "2538",
+				"Xmp.GPano.FullPanoHeightPixels": "7936",
+				"Xmp.GPano.FullPanoWidthPixels": "15872",
+			},
+		} };
+		expect(Exif.getCroppedPanoData(p)).toMatchSnapshot();
+	});
+
+	it("works with API props and unneeded", () => {
+		const p = { properties: {
+			"pers:interior_orientation": {
+				"sensor_array_dimensions": [15872,7936],
+				"visible_area": [0,0,0,0]
+			}
+		} };
+		expect(Exif.getCroppedPanoData(p)).toMatchSnapshot();
+	});
+
+	it("works with exif tags and unneeded", () => {
+		const p = { properties: {
+			exif: {
+				"Xmp.GPano.CroppedAreaImageHeightPixels": "7936",
+				"Xmp.GPano.CroppedAreaImageWidthPixels": "15872",
+				"Xmp.GPano.CroppedAreaLeftPixels": "0",
+				"Xmp.GPano.CroppedAreaTopPixels": "0",
+				"Xmp.GPano.FullPanoHeightPixels": "7936",
+				"Xmp.GPano.FullPanoWidthPixels": "15872",
+			},
+		} };
+		expect(Exif.getCroppedPanoData(p)).toMatchSnapshot();
+	});
+});

package/tests/utils/I18n.test.js

@@ -0,0 +1,28 @@
+import { getTranslations } from "../../src/utils/I18n";
+
+describe("getTranslations", () => {
+	it("works with default lang", () => {
+		const res = getTranslations("en");
+		expect(res.map.loading).toBe("Loading…");
+	});
+
+	it("works with existing lang", () => {
+		const res = getTranslations("fr");
+		expect(res.map.loading).toBe("Chargement…");
+	});
+
+	it("fallbacks to English if lang not found", () => {
+		const res = getTranslations("xn");
+		expect(res.map.loading).toBe("Loading…");
+	});
+
+	it("fallbacks to English if lang is undefined", () => {
+		const res = getTranslations();
+		expect(res.map.loading).toBe("Loading…");
+	});
+
+	it("works when primary lang code exists", () => {
+		const res = getTranslations("fr_FR");
+		expect(res.map.loading).toBe("Chargement…");
+	});
+});

package/tests/utils/Map.test.js

@@ -0,0 +1,105 @@
+import * as Map from "../../src/utils/Map";
+import GEOCODER_NOMINATIM from "../data/Map_geocoder_nominatim.json";
+import GEOCODER_BAN from "../data/Map_geocoder_ban.json";
+
+
+jest.mock("maplibre-gl", () => ({
+	addProtocol: jest.fn(),
+	Popup: function() {
+		return {
+			on: jest.fn(),
+		};
+	},
+	LngLat: function() {
+		return { lng: -1.7, lat: 47.8 };
+	},
+	LngLatBounds: function() {
+		return { sw: { lng: -1.7, lat: 47.8 }, ne: { lng: -1.7, lat: 47.8 } };
+	},
+}));
+
+
+describe("getThumbGif", () => {
+	it("works", () => {
+		const lang = { loading: "Loading..." };
+		const res = Map.getThumbGif(lang);
+		expect(res).toBeDefined();
+		expect(res.tagName).toBe("IMG");
+		expect(res.alt).toBe(lang.loading);
+		expect(res.title).toBe(lang.loading);
+	});
+});
+
+describe("getUserLayerId", () => {
+	it("works with default tiles", () => {
+		expect(Map.getUserLayerId("geovisio", "pictures")).toBe("geovisio_pictures");
+	});
+
+	it("works with specific user tiles", () => {
+		expect(Map.getUserLayerId("toto", "pictures")).toBe("geovisio_toto_pictures");
+	});
+});
+
+describe("getUserSourceId", () => {
+	it("works with default tiles", () => {
+		expect(Map.getUserSourceId("geovisio")).toBe("geovisio");
+	});
+
+	it("works with specific user tiles", () => {
+		expect(Map.getUserSourceId("toto")).toBe("geovisio_toto");
+	});
+});
+
+describe("geocoderParamsToURLString", () => {
+	it("works", () => {
+		const p = { bla: "blorg", you: 1 };
+		const r = Map.geocoderParamsToURLString(p);
+		expect(r).toEqual("bla=blorg&you=1");
+	});
+
+	it("handles special characters", () => {
+		const p = { bbox: "12,14,-45,78" };
+		const r = Map.geocoderParamsToURLString(p);
+		expect(r).toEqual("bbox=12%2C14%2C-45%2C78");
+	});
+
+	it("filters nulls", () => {
+		const p = { val1: undefined, val2: null, val3: 0 };
+		const r = Map.geocoderParamsToURLString(p);
+		expect(r).toEqual("val3=0");
+	});
+});
+
+describe("forwardGeocodingNominatim", () => {
+	it("works", () => {
+		// Mock API search
+		global.fetch = jest.fn(() => Promise.resolve({
+			json: () => GEOCODER_NOMINATIM
+		}));
+
+		// Search config
+		const cfg = { query: "bla", limit: 5, bbox: "17.7,-45.2,17.8,-45.1" };
+
+		return Map.forwardGeocodingNominatim(cfg).then(res => {
+			expect(global.fetch.mock.calls).toEqual([["https://nominatim.openstreetmap.org/search?q=bla&limit=5&viewbox=17.7%2C-45.2%2C17.8%2C-45.1&format=geojson&polygon_geojson=1&addressdetails=1"]]);
+			expect(res).toMatchSnapshot();
+		});
+	});
+});
+
+describe("forwardGeocodingBAN", () => {
+	it("works", () => {
+		// Mock API search
+		global.fetch = jest.fn(() => Promise.resolve({
+			json: () => GEOCODER_BAN
+		}));
+
+		// Search config
+		const cfg = { query: "bla", limit: 5, proximity: "17.7,-45.2" };
+
+		return Map.forwardGeocodingBAN(cfg).then(res => {
+			expect(global.fetch.mock.calls).toEqual([["https://api-adresse.data.gouv.fr/search/?q=bla&limit=5&lat=17.7&lon=-45.2"]]);
+			expect(res).toMatchSnapshot();
+		});
+	});
+});

package/tests/utils/Utils.test.js

@@ -0,0 +1,300 @@
+import * as Utils from "../../src/utils/Utils";
+
+jest.mock("../../src/utils/Map", () => ({
+	COLORS_HEX: {
+		SELECTED: 0x0000ff,
+	}
+}));
+
+describe("getDistance", () => {
+	it("works", () => {
+		const p1 = [1,1];
+		const p2 = [2,2];
+		const res = Utils.getDistance(p1, p2);
+		expect(res).toBe(Math.sqrt(2));
+	});
+});
+
+describe("sortPicturesInDirection", () => {
+	it("works with next/prev links", () => {
+		const sort = Utils.sortPicturesInDirection([0,0]);
+		let res = sort({rel: "prev"}, {rel: "next"});
+		expect(res).toBe(0);
+		res = sort({rel: "prev"}, {rel: "related"});
+		expect(res).toBe(-1);
+		res = sort({rel: "related"}, {rel: "next"});
+		expect(res).toBe(1);
+	});
+
+	it("works with related at different dates", () => {
+		const sort = Utils.sortPicturesInDirection([0,0]);
+		let res = sort(
+			{rel: "related", date: "2023-01-01"},
+			{rel: "related", date: "2022-01-01"}
+		);
+		expect(res).toBe(-1); // Most recent goes first
+		res = sort(
+			{rel: "related", date: "2022-01-01"},
+			{rel: "related", date: "2023-01-01"}
+		);
+		expect(res).toBe(1);
+	});
+
+	it("works with related at same date", () => {
+		const sort = Utils.sortPicturesInDirection([0,0]);
+		let res = sort(
+			{rel: "related", date: "2023-01-01", geometry: {coordinates: [0.1,0.1]}},
+			{rel: "related", date: "2023-01-01", geometry: {coordinates: [0.5,0.5]}}
+		);
+		expect(res).toBeLessThan(0); // Nearest goes first
+		res = sort(
+			{rel: "related", date: "2023-01-01", geometry: {coordinates: [0.5,0.5]}},
+			{rel: "related", date: "2023-01-01", geometry: {coordinates: [0.1,0.1]}}
+		);
+		expect(res).toBeGreaterThan(0);
+		res = sort(
+			{rel: "related", date: "2023-01-01", geometry: {coordinates: [0.1,0.1]}},
+			{rel: "related", date: "2023-01-01", geometry: {coordinates: [0.1,0.1]}}
+		);
+		expect(res).toBe(0);
+	});
+});
+
+describe("getAzimuth", () => {
+	it("works with 0 + NE", () => {
+		const pointDepart = [0, 0];
+		const pointArrivee = [1, 1];
+		const azimuth = Utils.getAzimuth(pointDepart, pointArrivee);
+		expect(azimuth).toBe(45);
+	});
+
+	it("works with 0 + SE", () => {
+		const pointDepart = [0, 0];
+		const pointArrivee = [1, -1];
+		const azimuth = Utils.getAzimuth(pointDepart, pointArrivee);
+		expect(azimuth).toBe(135);
+	});
+
+	it("works with 0 + N", () => {
+		const pointDepart = [0, 0];
+		const pointArrivee = [0, 1];
+		const azimuth = Utils.getAzimuth(pointDepart, pointArrivee);
+		expect(azimuth).toBe(0);
+	});
+
+	it("works with 0 + S", () => {
+		const pointDepart = [0, 0];
+		const pointArrivee = [0, -1];
+		const azimuth = Utils.getAzimuth(pointDepart, pointArrivee);
+		expect(azimuth).toBe(180);
+	});
+});
+
+describe("getRelativeHeading", () => {
+	it("should throw an error if no picture selected", () => {
+		expect(() => Utils.getRelativeHeading()).toThrow("No picture selected");
+	});
+
+	it("should calculate relative heading correctly", () => {
+		const pictureMetadata = {
+			properties: { "view:azimuth": 30 },
+			sequence: { prevPic: "prevPictureId", nextPic: "nextPictureId" },
+			links: [
+				{ nodeId: "prevPictureId", gps: [0, 0] },
+				{ nodeId: "nextPictureId", gps: [2, 2] }
+			],
+			gps: [1, 1]
+		};
+			
+		expect(Utils.getRelativeHeading(pictureMetadata)).toBe(-15);
+	});
+
+	it("works looking behind", () => {
+		const pictureMetadata = {
+			properties: { "view:azimuth": 226 },
+			sequence: { prevPic: "prevPictureId", nextPic: "nextPictureId" },
+			links: [
+				{ nodeId: "prevPictureId", gps: [0, 0] },
+				{ nodeId: "nextPictureId", gps: [2, 2] }
+			],
+			gps: [1, 1]
+		};
+			
+		expect(Utils.getRelativeHeading(pictureMetadata)).toBe(-179);
+	});
+
+	it("works with distorted path", () => {
+		const pictureMetadata = {
+			properties: { "view:azimuth": 100 },
+			sequence: { prevPic: "prevPictureId", nextPic: "nextPictureId" },
+			links: [
+				{ nodeId: "prevPictureId", gps: [0, 0] },
+				{ nodeId: "nextPictureId", gps: [2, 1] }
+			],
+			gps: [1, 0]
+		};
+			
+		expect(Utils.getRelativeHeading(pictureMetadata)).toBe(10);
+	});
+
+	it("works without previous link", () => {
+		const pictureMetadata = {
+			properties: { "view:azimuth": 100 },
+			sequence: { nextPic: "nextPictureId" },
+			links: [
+				{ nodeId: "nextPictureId", gps: [2, 1] }
+			],
+			gps: [1, 1]
+		};
+			
+		expect(Utils.getRelativeHeading(pictureMetadata)).toBe(10);
+	});
+
+	it("should handle missing prevPic or nextPic", () => {
+		const metadataWithoutPrevNext = {
+			properties: { "view:azimuth": 30 },
+			gps: [0, 0]
+		};
+		expect(Utils.getRelativeHeading(metadataWithoutPrevNext)).toBe(0);
+	});
+});
+
+describe("getSimplifiedAngle", () => {
+	it("returns \"N\"", () => {
+		expect(Utils.getSimplifiedAngle([0, 0], [0, 1])).toBe("N");
+	});
+
+	it("returns \"ENE\"", () => {
+		expect(Utils.getSimplifiedAngle([0, 0], [1, 1])).toBe("ENE");
+	});
+
+	it("returns \"ESE\"", () => {
+		expect(Utils.getSimplifiedAngle([0, 0], [1, -1])).toBe("ESE");
+	});
+
+	it("returns \"S\"", () => {
+		expect(Utils.getSimplifiedAngle([0, 0], [0, -1])).toBe("S");
+	});
+
+	it("returns \"WNW\"", () => {
+		expect(Utils.getSimplifiedAngle([0, 0], [-1, 1])).toBe("WNW");
+	});
+
+	it("returns \"WSW\"", () => {
+		expect(Utils.getSimplifiedAngle([0, 0], [-1, -1])).toBe("WSW");
+	});
+});
+
+describe("positionToXYZ", () => {
+	it("works with xy", () => {
+		const r = Utils.positionToXYZ({ pitch: 10, yaw: -5 });
+		expect(r).toEqual({ x: -286.4788975654116, y: 572.9577951308232 });
+	});
+
+	it("works with xyz", () => {
+		const r = Utils.positionToXYZ({ pitch: 10, yaw: -5 }, 15);
+		expect(r).toEqual({ x: -286.4788975654116, y: 572.9577951308232, z: 15 });
+	});
+});
+
+describe("xyzToPosition", () => {
+	it("works with xyz", () => {
+		const r = Utils.xyzToPosition(-286.4788975654116, 572.9577951308232, 15);
+		expect(r).toEqual({ pitch: 10, yaw: -5, zoom: 15 });
+	});
+});
+
+describe("getNodeCaption", () => {
+	it("works with date", () => {
+		const m = { properties: { datetime: "2022-02-01T12:15:36Z" } };
+		global.Date = jest.fn(() => ({ toLocaleDateString: () => "February 2 2022" }));
+		const res = Utils.getNodeCaption(m, { gvs: { metadata_general_license_link: "" }});
+		expect(res).toMatchSnapshot();
+	});
+
+	it("works with date+tz", () => {
+		const m = { properties: { datetimetz: "2022-02-01T12:15:36-03:00" } };
+		global.Date = jest.fn(() => ({ toLocaleDateString: () => "February 2 2022" }));
+		const res = Utils.getNodeCaption(m, { gvs: { metadata_general_license_link: "" }});
+		expect(res).toMatchSnapshot();
+	});
+
+	it("works with producer", () => {
+		const m = { providers: [ { name: "PanierAvide", roles: ["producer", "licensor"] } ] };
+		const res = Utils.getNodeCaption(m, { gvs: { metadata_general_license_link: "" }});
+		expect(res).toMatchSnapshot();
+	});
+
+	it("works with date + producer", () => {
+		const m = { properties: { datetime: "2022-02-01T12:15:36Z" }, providers: [ { name: "PanierAvide", roles: ["producer", "licensor"] } ] };
+		global.Date = jest.fn(() => ({ toLocaleDateString: () => "February 2 2022" }));
+		const res = Utils.getNodeCaption(m, { gvs: { metadata_general_license_link: "" }});
+		expect(res).toMatchSnapshot();
+	});
+
+	it("works with date + 2 producers", () => {
+		const m = {
+			properties: { datetime: "2022-02-01T12:15:36Z" },
+			providers: [
+				{ name: "GeoVisio Corp.", roles: ["producer", "licensor"] },
+				{ name: "PanierAvide", roles: ["producer"] },
+			]
+		};
+		global.Date = jest.fn(() => ({ toLocaleDateString: () => "February 2 2022" }));
+		const res = Utils.getNodeCaption(m, { gvs: { metadata_general_license_link: "" }});
+		expect(res).toMatchSnapshot();
+	});
+});
+
+describe("getCookie", () => {
+    it("should return the value of the specified cookie", () => {
+        jest.spyOn(document, "cookie", "get").mockReturnValueOnce("session=abc123");
+        expect(Utils.getCookie("session")).toBe("abc123");
+    });
+
+    it("should return null if the cookie is not found", () => {
+        jest.spyOn(document, "cookie", "get").mockReturnValueOnce("session=abc123");
+        expect(Utils.getCookie("user_id")).toBeUndefined();
+    });
+
+    it("should return the correct value when multiple cookies are set", () => {
+        jest.spyOn(document, "cookie", "get").mockReturnValueOnce("session=abc123; user_id=789; user_name=John");
+        expect(Utils.getCookie("user_id")).toBe("789");
+    });
+
+    it("should return null if cookie with the specified name has no value", () => {
+        jest.spyOn(document, "cookie", "get").mockReturnValueOnce("session=; user_id=789");
+        expect(Utils.getCookie("session")).toBe("");
+    });
+
+    it("should return the correct value when the cookie contains =", () => {
+        jest.spyOn(document, "cookie", "get").mockReturnValueOnce("custom_cookie=abc=123");
+        expect(Utils.getCookie("custom_cookie")).toBe("abc=123");
+    });
+});
+
+describe("getUserAccount", () => {
+    it("should return an object with user id and name when all cookies are present", () => {
+        jest.spyOn(document, "cookie", "get").mockReturnValue("session=abc123; user_id=789; user_name=John");
+        expect(Utils.getUserAccount()).toEqual({ id: "789", name: "John" });
+    });
+
+    it("should return null if session cookie is missing", () => {
+        jest.spyOn(document, "cookie", "get").mockReturnValue("user_id=789; user_name=John");
+        expect(Utils.getUserAccount()).toBeNull();
+    });
+
+    it("should return null if user_id cookie is missing", () => {
+        jest.spyOn(document, "cookie", "get").mockReturnValue("session=abc123; user_name=John");
+        expect(Utils.getUserAccount()).toBeNull();
+    });
+
+    it("should return null if user_name cookie is missing", () => {
+        jest.spyOn(document, "cookie", "get").mockReturnValue("session=abc123; user_id=789");
+        expect(Utils.getUserAccount()).toBeNull();
+    });
+
+    it("should return null if all cookies are missing", () => {
+        expect(Utils.getUserAccount()).toBeNull();
+    });
+});

package/tests/utils/Widgets.test.js

@@ -0,0 +1,107 @@
+import { faChevronDown } from "@fortawesome/free-solid-svg-icons/faChevronDown";
+import * as Widgets from "../../src/utils/Widgets";
+
+describe("createButton", () => {
+	it("works", () => {
+		const child = document.createElement("span");
+		const btn = Widgets.createButton("mybtn", child, "blabla", ["gvs-blabla"]);
+		expect(btn.className).toBe("gvs-btn gvs-widget-bg gvs-blabla");
+		expect(btn.id).toBe("mybtn");
+		expect(btn.children[0]).toBe(child);
+		expect(btn.title).toBe("blabla");
+	});
+
+	it("works without options", () => {
+		const child = document.createElement("span");
+		const btn = Widgets.createButton("mybtn");
+		expect(btn.className).toBe("gvs-btn gvs-widget-bg");
+		expect(btn.id).toBe("mybtn");
+		expect(btn.children.length).toBe(0);
+		expect(btn.title).toBe("");
+	});
+});
+
+describe("createExpandableButton", () => {
+	it("works with large container", () => {
+		const container = { _viewer: { isWidthSmall: () => false } };
+		const btn = Widgets.createExpandableButton("mybtn", faChevronDown, "blabla", container, ["gvs-blabla"]);
+		expect(btn.className).toBe("gvs-btn gvs-widget-bg gvs-btn-expandable gvs-blabla");
+		expect(btn.innerHTML).toMatchSnapshot();
+		expect(btn.id).toBe("mybtn");
+	});
+
+	it("works with small container", () => {
+		const container = { _viewer: { isWidthSmall: () => true } };
+		const btn = Widgets.createExpandableButton("mybtn", faChevronDown, "blabla", container, ["gvs-blabla"]);
+		expect(btn.className).toBe("gvs-btn gvs-widget-bg gvs-btn-expandable gvs-blabla");
+		expect(btn.innerHTML).toMatchSnapshot();
+		expect(btn.id).toBe("mybtn");
+	});
+});
+
+describe("createSearchBar", () => {
+	it("works", () => {
+		const container = { _t: {} };
+		const btn = Widgets.createSearchBar("mysrch", "no res", jest.fn(), jest.fn(), container);
+		expect(btn.className).toBe("gvs-widget-bg gvs-search-bar");
+		expect(btn.innerHTML).toMatchSnapshot();
+		expect(btn.id).toBe("mysrch");
+	});
+});
+
+describe("createPanel", () => {
+	it("works", () => {
+		const btn = document.createElement("button");
+		btn.id = "btngvs";
+		btn.addEventListener = jest.fn();
+		const child = document.createElement("span");
+		const pnl = Widgets.createPanel({}, btn, [child], ["gvs-blabla"]);
+		expect(pnl.id).toBe("btngvs-panel");
+		expect(pnl.className).toBe("gvs-panel gvs-widget-bg gvs-hidden gvs-blabla");
+		expect(pnl.innerHTML).toMatchSnapshot();
+		expect(btn.addEventListener.mock.calls).toMatchSnapshot();
+	});
+});
+
+describe("createGroup", () => {
+	it("works", () => {
+		const container = { _corners: { "main-top-left": document.createElement("div") } };
+		const child = document.createElement("span");
+		const grp = Widgets.createGroup("grp", "main-top-left", container, [child], ["gvs-blabla"]);
+		expect(grp.className).toBe("gvs-group gvs-blabla");
+		expect(grp.innerHTML).toMatchSnapshot();
+		expect(grp.id).toBe("grp");
+		expect(container._corners["main-top-left"].children[0]).toBe(grp);
+	});
+});
+
+describe("enableButton", () => {
+	it("works", () => {
+		const btn = document.createElement("button");
+		btn.setAttribute("disabled", "");
+		Widgets.enableButton(btn);
+		expect(btn.getAttribute("disabled")).toBeNull();
+	});
+});
+
+describe("disableButton", () => {
+	it("works", () => {
+		const btn = document.createElement("button");
+		Widgets.disableButton(btn);
+		expect(btn.getAttribute("disabled")).toBe("");
+	});
+});
+
+describe("fa", () => {
+	it("works", () => {
+		const res = Widgets.fa(faChevronDown);
+		expect(res).toMatchSnapshot();
+	});
+});
+
+describe("fat", () => {
+	it("works", () => {
+		const res = Widgets.fat(faChevronDown);
+		expect(res).toMatchSnapshot();
+	});
+});