element-web/test/utils/beacon/geolocation-test.ts

230 lines
8.1 KiB
TypeScript
Raw Normal View History

/*
Copyright 2024 New Vector Ltd.
Copyright 2022 The Matrix.org Foundation C.I.C.
SPDX-License-Identifier: AGPL-3.0-only OR GPL-3.0-only
Please see LICENSE files in the repository root for full details.
*/
import { logger } from "matrix-js-sdk/src/logger";
import { Mocked } from "jest-mock";
import {
GenericPosition,
GeolocationError,
getGeoUri,
mapGeolocationError,
mapGeolocationPositionToTimedGeo,
watchPosition,
} from "../../../src/utils/beacon";
import { getCurrentPosition } from "../../../src/utils/beacon/geolocation";
2022-12-12 12:24:14 +01:00
import { makeGeolocationPosition, mockGeolocation, getMockGeolocationPositionError } from "../../test-utils";
2022-12-12 12:24:14 +01:00
describe("geolocation utilities", () => {
let geolocation: Mocked<Geolocation>;
const defaultPosition = makeGeolocationPosition({});
// 14.03.2022 16:15
const now = 1647270879403;
beforeEach(() => {
geolocation = mockGeolocation();
2022-12-12 12:24:14 +01:00
jest.spyOn(Date, "now").mockReturnValue(now);
});
afterEach(() => {
2022-12-12 12:24:14 +01:00
jest.spyOn(Date, "now").mockRestore();
jest.spyOn(logger, "error").mockRestore();
});
2022-12-12 12:24:14 +01:00
describe("getGeoUri", () => {
it("Renders a URI with only lat and lon", () => {
const pos: GenericPosition = {
latitude: 43.2,
longitude: 12.4,
altitude: undefined,
accuracy: undefined,
timestamp: 12334,
};
expect(getGeoUri(pos)).toEqual("geo:43.2,12.4");
});
it("Nulls in location are not shown in URI", () => {
const pos: GenericPosition = {
latitude: 43.2,
longitude: 12.4,
timestamp: 12334,
};
expect(getGeoUri(pos)).toEqual("geo:43.2,12.4");
});
it("Renders a URI with 3 coords", () => {
const pos: GenericPosition = {
latitude: 43.2,
longitude: 12.4,
altitude: 332.54,
accuracy: undefined,
timestamp: 12334,
};
expect(getGeoUri(pos)).toEqual("geo:43.2,12.4,332.54");
});
it("Renders a URI with accuracy", () => {
const pos: GenericPosition = {
latitude: 43.2,
longitude: 12.4,
altitude: undefined,
accuracy: 21,
timestamp: 12334,
};
expect(getGeoUri(pos)).toEqual("geo:43.2,12.4;u=21");
});
it("Renders a URI with accuracy and altitude", () => {
const pos = {
latitude: 43.2,
longitude: 12.4,
altitude: 12.3,
accuracy: 21,
timestamp: 12334,
};
expect(getGeoUri(pos)).toEqual("geo:43.2,12.4,12.3;u=21");
});
});
2022-12-12 12:24:14 +01:00
describe("mapGeolocationError", () => {
beforeEach(() => {
// suppress expected errors from test log
2022-12-12 12:24:14 +01:00
jest.spyOn(logger, "error").mockImplementation(() => {});
});
2022-12-12 12:24:14 +01:00
it("returns default for other error", () => {
const error = new Error("oh no..");
expect(mapGeolocationError(error)).toEqual(GeolocationError.Default);
});
2022-12-12 12:24:14 +01:00
it("returns unavailable for unavailable error", () => {
const error = new Error(GeolocationError.Unavailable);
expect(mapGeolocationError(error)).toEqual(GeolocationError.Unavailable);
});
2022-12-12 12:24:14 +01:00
it("maps geo error permissiondenied correctly", () => {
const error = getMockGeolocationPositionError(1, "message");
expect(mapGeolocationError(error)).toEqual(GeolocationError.PermissionDenied);
});
2022-12-12 12:24:14 +01:00
it("maps geo position unavailable error correctly", () => {
const error = getMockGeolocationPositionError(2, "message");
expect(mapGeolocationError(error)).toEqual(GeolocationError.PositionUnavailable);
});
2022-12-12 12:24:14 +01:00
it("maps geo timeout error correctly", () => {
const error = getMockGeolocationPositionError(3, "message");
expect(mapGeolocationError(error)).toEqual(GeolocationError.Timeout);
});
});
2022-12-12 12:24:14 +01:00
describe("mapGeolocationPositionToTimedGeo()", () => {
it("maps geolocation position correctly", () => {
expect(mapGeolocationPositionToTimedGeo(defaultPosition)).toEqual({
2022-12-12 12:24:14 +01:00
timestamp: now,
geoUri: "geo:54.001927,-8.253491;u=1",
});
});
});
2022-12-12 12:24:14 +01:00
describe("watchPosition()", () => {
it("throws with unavailable error when geolocation is not available", () => {
// suppress expected errors from test log
2022-12-12 12:24:14 +01:00
jest.spyOn(logger, "error").mockImplementation(() => {});
// remove the mock we added
// @ts-ignore illegal assignment to readonly property
navigator.geolocation = undefined;
const positionHandler = jest.fn();
const errorHandler = jest.fn();
expect(() => watchPosition(positionHandler, errorHandler)).toThrow(GeolocationError.Unavailable);
});
2022-12-12 12:24:14 +01:00
it("sets up position handler with correct options", () => {
const positionHandler = jest.fn();
const errorHandler = jest.fn();
watchPosition(positionHandler, errorHandler);
const [, , options] = geolocation.watchPosition.mock.calls[0];
expect(options).toEqual({
maximumAge: 60000,
timeout: 10000,
});
});
2022-12-12 12:24:14 +01:00
it("returns clearWatch function", () => {
const watchId = 1;
geolocation.watchPosition.mockReturnValue(watchId);
const positionHandler = jest.fn();
const errorHandler = jest.fn();
const clearWatch = watchPosition(positionHandler, errorHandler);
clearWatch();
expect(geolocation.clearWatch).toHaveBeenCalledWith(watchId);
});
2022-12-12 12:24:14 +01:00
it("calls position handler with position", () => {
const positionHandler = jest.fn();
const errorHandler = jest.fn();
watchPosition(positionHandler, errorHandler);
expect(positionHandler).toHaveBeenCalledWith(defaultPosition);
});
2022-12-12 12:24:14 +01:00
it("maps geolocation position error and calls error handler", () => {
// suppress expected errors from test log
2022-12-12 12:24:14 +01:00
jest.spyOn(logger, "error").mockImplementation(() => {});
geolocation.watchPosition.mockImplementation((_callback, error) => {
error!(getMockGeolocationPositionError(1, "message"));
return -1;
});
const positionHandler = jest.fn();
const errorHandler = jest.fn();
watchPosition(positionHandler, errorHandler);
expect(errorHandler).toHaveBeenCalledWith(GeolocationError.PermissionDenied);
});
});
2022-12-12 12:24:14 +01:00
describe("getCurrentPosition()", () => {
it("throws with unavailable error when geolocation is not available", async () => {
// suppress expected errors from test log
2022-12-12 12:24:14 +01:00
jest.spyOn(logger, "error").mockImplementation(() => {});
// remove the mock we added
// @ts-ignore illegal assignment to readonly property
navigator.geolocation = undefined;
await expect(() => getCurrentPosition()).rejects.toThrow(GeolocationError.Unavailable);
});
2022-12-12 12:24:14 +01:00
it("throws with geolocation error when geolocation.getCurrentPosition fails", async () => {
// suppress expected errors from test log
2022-12-12 12:24:14 +01:00
jest.spyOn(logger, "error").mockImplementation(() => {});
2022-12-12 12:24:14 +01:00
const timeoutError = getMockGeolocationPositionError(3, "message");
geolocation.getCurrentPosition.mockImplementation((callback, error) => error!(timeoutError));
await expect(() => getCurrentPosition()).rejects.toThrow(GeolocationError.Timeout);
});
2022-12-12 12:24:14 +01:00
it("resolves with current location", async () => {
geolocation.getCurrentPosition.mockImplementation((callback, error) => callback(defaultPosition));
const result = await getCurrentPosition();
expect(result).toEqual(defaultPosition);
});
});
});