mirror of
https://github.com/element-hq/element-web.git
synced 2024-12-14 15:12:13 +03:00
224 lines
8.2 KiB
TypeScript
224 lines
8.2 KiB
TypeScript
/*
|
|
Copyright 2021 The Matrix.org Foundation C.I.C.
|
|
|
|
Licensed under the Apache License, Version 2.0 (the "License");
|
|
you may not use this file except in compliance with the License.
|
|
You may obtain a copy of the License at
|
|
|
|
http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
Unless required by applicable law or agreed to in writing, software
|
|
distributed under the License is distributed on an "AS IS" BASIS,
|
|
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
See the License for the specific language governing permissions and
|
|
limitations under the License.
|
|
*/
|
|
|
|
import {
|
|
Anonymity,
|
|
getRedactedCurrentLocation,
|
|
IAnonymousEvent,
|
|
IPseudonymousEvent,
|
|
IRoomEvent,
|
|
PosthogAnalytics,
|
|
} from '../src/PosthogAnalytics';
|
|
|
|
import SdkConfig from '../src/SdkConfig';
|
|
|
|
class FakePosthog {
|
|
public capture;
|
|
public init;
|
|
public identify;
|
|
public reset;
|
|
public register;
|
|
|
|
constructor() {
|
|
this.capture = jest.fn();
|
|
this.init = jest.fn();
|
|
this.identify = jest.fn();
|
|
this.reset = jest.fn();
|
|
this.register = jest.fn();
|
|
}
|
|
}
|
|
|
|
export interface ITestEvent extends IAnonymousEvent {
|
|
key: "jest_test_event";
|
|
properties: {
|
|
foo: string;
|
|
};
|
|
}
|
|
|
|
export interface ITestPseudonymousEvent extends IPseudonymousEvent {
|
|
key: "jest_test_pseudo_event";
|
|
properties: {
|
|
foo: string;
|
|
};
|
|
}
|
|
|
|
export interface ITestRoomEvent extends IRoomEvent {
|
|
key: "jest_test_room_event";
|
|
properties: {
|
|
foo: string;
|
|
};
|
|
}
|
|
|
|
describe("PosthogAnalytics", () => {
|
|
let fakePosthog: FakePosthog;
|
|
const shaHashes = {
|
|
"42": "73475cb40a568e8da8a045ced110137e159f890ac4da883b6b17dc651b3a8049",
|
|
"some": "a6b46dd0d1ae5e86cbc8f37e75ceeb6760230c1ca4ffbcb0c97b96dd7d9c464b",
|
|
"pii": "bd75b3e080945674c0351f75e0db33d1e90986fa07b318ea7edf776f5eef38d4",
|
|
"foo": "2c26b46b68ffc68ff99b453c1d30413413422d706483bfa0f98a5e886266e7ae",
|
|
};
|
|
|
|
beforeEach(() => {
|
|
fakePosthog = new FakePosthog();
|
|
|
|
window.crypto = {
|
|
subtle: {
|
|
digest: async (_, encodedMessage) => {
|
|
const message = new TextDecoder().decode(encodedMessage);
|
|
const hexHash = shaHashes[message];
|
|
const bytes = [];
|
|
for (let c = 0; c < hexHash.length; c += 2) {
|
|
bytes.push(parseInt(hexHash.substr(c, 2), 16));
|
|
}
|
|
return bytes;
|
|
},
|
|
},
|
|
};
|
|
});
|
|
|
|
afterEach(() => {
|
|
window.crypto = null;
|
|
});
|
|
|
|
describe("Initialisation", () => {
|
|
it("Should not be enabled without config being set", () => {
|
|
jest.spyOn(SdkConfig, "get").mockReturnValue({});
|
|
const analytics = new PosthogAnalytics(fakePosthog);
|
|
expect(analytics.isEnabled()).toBe(false);
|
|
});
|
|
|
|
it("Should be enabled if config is set", () => {
|
|
jest.spyOn(SdkConfig, "get").mockReturnValue({
|
|
posthog: {
|
|
projectApiKey: "foo",
|
|
apiHost: "bar",
|
|
},
|
|
});
|
|
const analytics = new PosthogAnalytics(fakePosthog);
|
|
analytics.setAnonymity(Anonymity.Pseudonymous);
|
|
expect(analytics.isEnabled()).toBe(true);
|
|
});
|
|
});
|
|
|
|
describe("Tracking", () => {
|
|
let analytics: PosthogAnalytics;
|
|
|
|
beforeEach(() => {
|
|
jest.spyOn(SdkConfig, "get").mockReturnValue({
|
|
posthog: {
|
|
projectApiKey: "foo",
|
|
apiHost: "bar",
|
|
},
|
|
});
|
|
|
|
analytics = new PosthogAnalytics(fakePosthog);
|
|
});
|
|
|
|
it("Should pass trackAnonymousEvent() to posthog", async () => {
|
|
analytics.setAnonymity(Anonymity.Pseudonymous);
|
|
await analytics.trackAnonymousEvent<ITestEvent>("jest_test_event", {
|
|
foo: "bar",
|
|
});
|
|
expect(fakePosthog.capture.mock.calls[0][0]).toBe("jest_test_event");
|
|
expect(fakePosthog.capture.mock.calls[0][1]["foo"]).toEqual("bar");
|
|
});
|
|
|
|
it("Should pass trackPseudonymousEvent() to posthog", async () => {
|
|
analytics.setAnonymity(Anonymity.Pseudonymous);
|
|
await analytics.trackPseudonymousEvent<ITestEvent>("jest_test_pseudo_event", {
|
|
foo: "bar",
|
|
});
|
|
expect(fakePosthog.capture.mock.calls[0][0]).toBe("jest_test_pseudo_event");
|
|
expect(fakePosthog.capture.mock.calls[0][1]["foo"]).toEqual("bar");
|
|
});
|
|
|
|
it("Should not track pseudonymous messages if anonymous", async () => {
|
|
analytics.setAnonymity(Anonymity.Anonymous);
|
|
await analytics.trackPseudonymousEvent<ITestEvent>("jest_test_event", {
|
|
foo: "bar",
|
|
});
|
|
expect(fakePosthog.capture.mock.calls.length).toBe(0);
|
|
});
|
|
|
|
it("Should not track any events if disabled", async () => {
|
|
analytics.setAnonymity(Anonymity.Disabled);
|
|
await analytics.trackPseudonymousEvent<ITestEvent>("jest_test_event", {
|
|
foo: "bar",
|
|
});
|
|
await analytics.trackAnonymousEvent<ITestEvent>("jest_test_event", {
|
|
foo: "bar",
|
|
});
|
|
await analytics.trackPageView(200);
|
|
expect(fakePosthog.capture.mock.calls.length).toBe(0);
|
|
});
|
|
|
|
it("Should pseudonymise a location of a known screen", async () => {
|
|
const location = await getRedactedCurrentLocation(
|
|
"https://foo.bar", "#/register/some/pii", "/", Anonymity.Pseudonymous);
|
|
expect(location).toBe("https://foo.bar/#/register/<redacted>");
|
|
});
|
|
|
|
it("Should anonymise a location of a known screen", async () => {
|
|
const location = await getRedactedCurrentLocation(
|
|
"https://foo.bar", "#/register/some/pii", "/", Anonymity.Anonymous);
|
|
expect(location).toBe("https://foo.bar/#/register/<redacted>");
|
|
});
|
|
|
|
it("Should pseudonymise a location of an unknown screen", async () => {
|
|
const location = await getRedactedCurrentLocation(
|
|
"https://foo.bar", "#/not_a_screen_name/some/pii", "/", Anonymity.Pseudonymous);
|
|
expect(location).toBe("https://foo.bar/#/<redacted_screen_name>/<redacted>");
|
|
});
|
|
|
|
it("Should anonymise a location of an unknown screen", async () => {
|
|
const location = await getRedactedCurrentLocation(
|
|
"https://foo.bar", "#/not_a_screen_name/some/pii", "/", Anonymity.Anonymous);
|
|
expect(location).toBe("https://foo.bar/#/<redacted_screen_name>/<redacted>");
|
|
});
|
|
|
|
it("Should handle an empty hash", async () => {
|
|
const location = await getRedactedCurrentLocation(
|
|
"https://foo.bar", "", "/", Anonymity.Anonymous);
|
|
expect(location).toBe("https://foo.bar/");
|
|
});
|
|
|
|
it("Should identify the user to posthog if pseudonymous", async () => {
|
|
analytics.setAnonymity(Anonymity.Pseudonymous);
|
|
class FakeClient {
|
|
getAccountDataFromServer = jest.fn().mockResolvedValue(null);
|
|
setAccountData = jest.fn().mockResolvedValue({});
|
|
}
|
|
await analytics.identifyUser(new FakeClient(), () => "analytics_id" );
|
|
expect(fakePosthog.identify.mock.calls[0][0]).toBe("analytics_id");
|
|
});
|
|
|
|
it("Should not identify the user to posthog if anonymous", async () => {
|
|
analytics.setAnonymity(Anonymity.Anonymous);
|
|
await analytics.identifyUser(null);
|
|
expect(fakePosthog.identify.mock.calls.length).toBe(0);
|
|
});
|
|
|
|
it("Should identify using the server's analytics id if present", async () => {
|
|
analytics.setAnonymity(Anonymity.Pseudonymous);
|
|
class FakeClient {
|
|
getAccountDataFromServer = jest.fn().mockResolvedValue({ id: "existing_analytics_id" });
|
|
setAccountData = jest.fn().mockResolvedValue({});
|
|
}
|
|
await analytics.identifyUser(new FakeClient(), () => "new_analytics_id" );
|
|
expect(fakePosthog.identify.mock.calls[0][0]).toBe("existing_analytics_id");
|
|
});
|
|
});
|
|
});
|