From 06028c35bc9f0927e3f9067d7678c6376e525b4e Mon Sep 17 00:00:00 2001 From: Justin Baur <19896123+justindbaur@users.noreply.github.com> Date: Thu, 18 Jan 2024 13:06:54 -0500 Subject: [PATCH] Fully Test EnvironmentService (#7589) Co-authored-by: Matt Gibson --- .../services/environment.service.spec.ts | 531 ++++++++++++++++++ 1 file changed, 531 insertions(+) create mode 100644 libs/common/src/platform/services/environment.service.spec.ts diff --git a/libs/common/src/platform/services/environment.service.spec.ts b/libs/common/src/platform/services/environment.service.spec.ts new file mode 100644 index 0000000000..96457f7638 --- /dev/null +++ b/libs/common/src/platform/services/environment.service.spec.ts @@ -0,0 +1,531 @@ +import { mock } from "jest-mock-extended"; +import { firstValueFrom, timeout } from "rxjs"; + +import { awaitAsync } from "../../../spec"; +import { FakeStorageService } from "../../../spec/fake-storage.service"; +import { EnvironmentUrls } from "../../auth/models/domain/environment-urls"; +import { UserId } from "../../types/guid"; +import { Region } from "../abstractions/environment.service"; +import { StateFactory } from "../factories/state-factory"; +import { Account } from "../models/domain/account"; +import { GlobalState } from "../models/domain/global-state"; + +import { EnvironmentService } from "./environment.service"; +import { StateService } from "./state.service"; + +// There are a few main states EnvironmentService could be in when first used +// 1. Not initialized, no active user. Hopefully not to likely but possible +// 2. Not initialized, with active user. Not likely +// 3. Initialized, no active user. +// 4. Initialized, with active user. +describe("EnvironmentService", () => { + let diskStorageService: FakeStorageService; + let memoryStorageService: FakeStorageService; + let stateService: StateService; + + let sut: EnvironmentService; + + const testUser = "testUser1" as UserId; + + // START: CAN CHANGE - When implementing new storage locations, the following code can change. But not tests + beforeEach(async () => { + diskStorageService = new FakeStorageService(); + memoryStorageService = new FakeStorageService(); + stateService = new StateService( + diskStorageService, + null, + memoryStorageService as any, + mock(), + new StateFactory(GlobalState, Account), + mock(), + false, + ); + + sut = new EnvironmentService(stateService); + }); + + const switchUser = async (userId: UserId) => { + await stateService.setActiveUser(userId); + await awaitAsync(); + }; + + const setGlobalData = (region: Region, environmentUrls: EnvironmentUrls) => { + diskStorageService.internalUpdateStore({ + ...diskStorageService.internalStore, + global: { + region: region, + environmentUrls: environmentUrls, + }, + }); + }; + + const getGlobalData = () => { + const storage = diskStorageService.internalStore as { + global?: { region?: Region; environmentUrls?: EnvironmentUrls }; + }; + return { + region: storage?.global?.region, + urls: storage?.global?.environmentUrls, + }; + }; + + const setUserData = ( + region: Region, + environmentUrls: EnvironmentUrls, + userId: UserId = testUser, + ) => { + const data = { ...diskStorageService.internalStore }; + const userData = { + settings: { + region: region, + environmentUrls: environmentUrls, + }, + }; + data[userId] = userData; + + diskStorageService.internalUpdateStore(data); + }; + // END: CAN CHANGE + + const initialize = async (options: { switchUser: boolean }) => { + // This emulates the way EnvironmentService is initialized in each of our clients + await stateService.init(); + await sut.setUrlsFromStorage(); + sut.initialized = true; + + if (options.switchUser) { + await switchUser(testUser); + } + }; + + const REGION_SETUP = [ + { + region: Region.US, + expectedUrls: { + webVault: "https://vault.bitwarden.com", + identity: "https://identity.bitwarden.com", + api: "https://api.bitwarden.com", + icons: "https://icons.bitwarden.net", + notifications: "https://notifications.bitwarden.com", + events: "https://events.bitwarden.com", + scim: "https://scim.bitwarden.com/v2", + send: "https://send.bitwarden.com/#", + }, + }, + { + region: Region.EU, + expectedUrls: { + webVault: "https://vault.bitwarden.eu", + identity: "https://identity.bitwarden.eu", + api: "https://api.bitwarden.eu", + icons: "https://icons.bitwarden.eu", + notifications: "https://notifications.bitwarden.eu", + events: "https://events.bitwarden.eu", + scim: "https://scim.bitwarden.eu/v2", + send: "https://vault.bitwarden.eu/#/send/", + }, + }, + ]; + + describe("with user", () => { + it.each(REGION_SETUP)( + "sets correct urls for each region %s", + async ({ region, expectedUrls }) => { + setUserData(region, new EnvironmentUrls()); + + await initialize({ switchUser: true }); + + expect(sut.hasBaseUrl()).toBe(false); + expect(sut.getWebVaultUrl()).toBe(expectedUrls.webVault); + expect(sut.getIdentityUrl()).toBe(expectedUrls.identity); + expect(sut.getApiUrl()).toBe(expectedUrls.api); + expect(sut.getIconsUrl()).toBe(expectedUrls.icons); + expect(sut.getNotificationsUrl()).toBe(expectedUrls.notifications); + expect(sut.getEventsUrl()).toBe(expectedUrls.events); + expect(sut.getScimUrl()).toBe(expectedUrls.scim); + expect(sut.getSendUrl()).toBe(expectedUrls.send); + expect(sut.getKeyConnectorUrl()).toBe(null); + expect(sut.isCloud()).toBe(true); + expect(sut.getUrls()).toEqual({ + base: null, + cloudWebVault: undefined, + webVault: expectedUrls.webVault, + identity: expectedUrls.identity, + api: expectedUrls.api, + icons: expectedUrls.icons, + notifications: expectedUrls.notifications, + events: expectedUrls.events, + scim: expectedUrls.scim.replace("/v2", ""), + keyConnector: null, + }); + }, + ); + + it("returns user data", async () => { + const globalEnvironmentUrls = new EnvironmentUrls(); + globalEnvironmentUrls.base = "https://global-url.example.com"; + setGlobalData(Region.SelfHosted, globalEnvironmentUrls); + + const userEnvironmentUrls = new EnvironmentUrls(); + userEnvironmentUrls.base = "https://user-url.example.com"; + setUserData(Region.SelfHosted, userEnvironmentUrls); + + await initialize({ switchUser: true }); + + expect(sut.getWebVaultUrl()).toBe("https://user-url.example.com"); + expect(sut.getIdentityUrl()).toBe("https://user-url.example.com/identity"); + expect(sut.getApiUrl()).toBe("https://user-url.example.com/api"); + expect(sut.getIconsUrl()).toBe("https://user-url.example.com/icons"); + expect(sut.getNotificationsUrl()).toBe("https://user-url.example.com/notifications"); + expect(sut.getEventsUrl()).toBe("https://user-url.example.com/events"); + expect(sut.getScimUrl()).toBe("https://user-url.example.com/scim/v2"); + expect(sut.getSendUrl()).toBe("https://user-url.example.com/#/send/"); + expect(sut.isCloud()).toBe(false); + expect(sut.getUrls()).toEqual({ + base: "https://user-url.example.com", + api: null, + cloudWebVault: undefined, + events: null, + icons: null, + identity: null, + keyConnector: null, + notifications: null, + scim: null, + webVault: null, + }); + }); + }); + + describe("without user", () => { + it.each(REGION_SETUP)("gets default urls %s", async ({ region, expectedUrls }) => { + setGlobalData(region, new EnvironmentUrls()); + + await initialize({ switchUser: false }); + + expect(sut.hasBaseUrl()).toBe(false); + expect(sut.getWebVaultUrl()).toBe(expectedUrls.webVault); + expect(sut.getIdentityUrl()).toBe(expectedUrls.identity); + expect(sut.getApiUrl()).toBe(expectedUrls.api); + expect(sut.getIconsUrl()).toBe(expectedUrls.icons); + expect(sut.getNotificationsUrl()).toBe(expectedUrls.notifications); + expect(sut.getEventsUrl()).toBe(expectedUrls.events); + expect(sut.getScimUrl()).toBe(expectedUrls.scim); + expect(sut.getSendUrl()).toBe(expectedUrls.send); + expect(sut.getKeyConnectorUrl()).toBe(null); + expect(sut.isCloud()).toBe(true); + expect(sut.getUrls()).toEqual({ + base: null, + cloudWebVault: undefined, + webVault: expectedUrls.webVault, + identity: expectedUrls.identity, + api: expectedUrls.api, + icons: expectedUrls.icons, + notifications: expectedUrls.notifications, + events: expectedUrls.events, + scim: expectedUrls.scim.replace("/v2", ""), + keyConnector: null, + }); + }); + + it("gets global data", async () => { + const globalEnvironmentUrls = new EnvironmentUrls(); + globalEnvironmentUrls.base = "https://global-url.example.com"; + globalEnvironmentUrls.keyConnector = "https://global-key-connector.example.com"; + setGlobalData(Region.SelfHosted, globalEnvironmentUrls); + + const userEnvironmentUrls = new EnvironmentUrls(); + userEnvironmentUrls.base = "https://user-url.example.com"; + userEnvironmentUrls.keyConnector = "https://user-key-connector.example.com"; + setUserData(Region.SelfHosted, userEnvironmentUrls); + + await initialize({ switchUser: false }); + + expect(sut.getWebVaultUrl()).toBe("https://global-url.example.com"); + expect(sut.getIdentityUrl()).toBe("https://global-url.example.com/identity"); + expect(sut.getApiUrl()).toBe("https://global-url.example.com/api"); + expect(sut.getIconsUrl()).toBe("https://global-url.example.com/icons"); + expect(sut.getNotificationsUrl()).toBe("https://global-url.example.com/notifications"); + expect(sut.getEventsUrl()).toBe("https://global-url.example.com/events"); + expect(sut.getScimUrl()).toBe("https://global-url.example.com/scim/v2"); + expect(sut.getSendUrl()).toBe("https://global-url.example.com/#/send/"); + expect(sut.getKeyConnectorUrl()).toBe("https://global-key-connector.example.com"); + expect(sut.isCloud()).toBe(false); + expect(sut.getUrls()).toEqual({ + api: null, + base: "https://global-url.example.com", + cloudWebVault: undefined, + webVault: null, + events: null, + icons: null, + identity: null, + keyConnector: "https://global-key-connector.example.com", + notifications: null, + scim: null, + }); + }); + }); + + it("returns US defaults when not initialized", async () => { + setGlobalData(Region.EU, new EnvironmentUrls()); + setUserData(Region.EU, new EnvironmentUrls()); + + expect(sut.initialized).toBe(false); + + expect(sut.hasBaseUrl()).toBe(false); + expect(sut.getWebVaultUrl()).toBe("https://vault.bitwarden.com"); + expect(sut.getIdentityUrl()).toBe("https://identity.bitwarden.com"); + expect(sut.getApiUrl()).toBe("https://api.bitwarden.com"); + expect(sut.getIconsUrl()).toBe("https://icons.bitwarden.net"); + expect(sut.getNotificationsUrl()).toBe("https://notifications.bitwarden.com"); + expect(sut.getEventsUrl()).toBe("https://events.bitwarden.com"); + expect(sut.getScimUrl()).toBe("https://scim.bitwarden.com/v2"); + expect(sut.getKeyConnectorUrl()).toBe(undefined); + expect(sut.isCloud()).toBe(true); + }); + + describe("setUrls", () => { + it("set just a base url", async () => { + await initialize({ switchUser: true }); + + await sut.setUrls({ + base: "base.example.com", + }); + + const globalData = getGlobalData(); + expect(globalData.region).toBe("Self-hosted"); + expect(globalData.urls).toEqual({ + base: "https://base.example.com", + api: null, + identity: null, + webVault: null, + icons: null, + notifications: null, + events: null, + keyConnector: null, + }); + }); + + it("sets all urls", async () => { + await initialize({ switchUser: true }); + + expect(sut.getScimUrl()).toBe("https://scim.bitwarden.com/v2"); + + await sut.setUrls({ + base: "base.example.com", + api: "api.example.com", + identity: "identity.example.com", + webVault: "vault.example.com", + icons: "icons.example.com", + notifications: "notifications.example.com", + scim: "scim.example.com", + }); + + const globalData = getGlobalData(); + expect(globalData.region).toBe("Self-hosted"); + expect(globalData.urls).toEqual({ + base: "https://base.example.com", + api: "https://api.example.com", + identity: "https://identity.example.com", + webVault: "https://vault.example.com", + icons: "https://icons.example.com", + notifications: "https://notifications.example.com", + events: null, + keyConnector: null, + }); + expect(sut.getScimUrl()).toBe("https://scim.example.com/v2"); + }); + }); + + describe("setRegion", () => { + it("sets the region on the global object even if there is a user.", async () => { + setGlobalData(Region.EU, new EnvironmentUrls()); + setUserData(Region.EU, new EnvironmentUrls()); + + await initialize({ switchUser: true }); + + await sut.setRegion(Region.US); + + const globalData = getGlobalData(); + expect(globalData.region).toBe(Region.US); + }); + }); + + describe("getHost", () => { + it.each([ + { region: Region.US, expectedHost: "bitwarden.com" }, + { region: Region.EU, expectedHost: "bitwarden.eu" }, + ])("gets it from user data if there is an active user", async ({ region, expectedHost }) => { + setGlobalData(Region.US, new EnvironmentUrls()); + setUserData(region, new EnvironmentUrls()); + + await initialize({ switchUser: true }); + + const host = await sut.getHost(); + expect(host).toBe(expectedHost); + }); + + it.each([ + { region: Region.US, expectedHost: "bitwarden.com" }, + { region: Region.EU, expectedHost: "bitwarden.eu" }, + ])("gets it from global data if there is no active user", async ({ region, expectedHost }) => { + setGlobalData(region, new EnvironmentUrls()); + setUserData(Region.US, new EnvironmentUrls()); + + await initialize({ switchUser: false }); + + const host = await sut.getHost(); + expect(host).toBe(expectedHost); + }); + + it.each([ + { region: Region.US, expectedHost: "bitwarden.com" }, + { region: Region.EU, expectedHost: "bitwarden.eu" }, + ])( + "gets it from global state if there is no active user even if a user id is passed in.", + async ({ region, expectedHost }) => { + setGlobalData(region, new EnvironmentUrls()); + setUserData(Region.US, new EnvironmentUrls()); + + await initialize({ switchUser: false }); + + const host = await sut.getHost(testUser); + expect(host).toBe(expectedHost); + }, + ); + + it.each([ + { region: Region.US, expectedHost: "bitwarden.com" }, + { region: Region.EU, expectedHost: "bitwarden.eu" }, + ])( + "gets it from the passed in userId if there is any active user: %s", + async ({ region, expectedHost }) => { + const otherUser = "testUser2" as UserId; + + setGlobalData(Region.US, new EnvironmentUrls()); + setUserData(Region.US, new EnvironmentUrls()); + setUserData(region, new EnvironmentUrls(), otherUser); + + await initialize({ switchUser: true }); + + const host = await sut.getHost(otherUser); + expect(host).toBe(expectedHost); + }, + ); + + it("gets it from base url saved in self host config", async () => { + const globalSelfHostUrls = new EnvironmentUrls(); + globalSelfHostUrls.base = "https://base.example.com"; + setGlobalData(Region.SelfHosted, globalSelfHostUrls); + setUserData(Region.EU, new EnvironmentUrls()); + + await initialize({ switchUser: false }); + + const host = await sut.getHost(); + expect(host).toBe("base.example.com"); + }); + + it("gets it from webVault url saved in self host config", async () => { + const globalSelfHostUrls = new EnvironmentUrls(); + globalSelfHostUrls.webVault = "https://vault.example.com"; + globalSelfHostUrls.base = "https://base.example.com"; + setGlobalData(Region.SelfHosted, globalSelfHostUrls); + setUserData(Region.EU, new EnvironmentUrls()); + + await initialize({ switchUser: false }); + + const host = await sut.getHost(); + expect(host).toBe("vault.example.com"); + }); + + it("gets it from saved self host config from passed in user when there is an active user", async () => { + const otherUser = "testUser2" as UserId; + setGlobalData(Region.US, new EnvironmentUrls()); + setUserData(Region.EU, new EnvironmentUrls()); + + const selfHostUserUrls = new EnvironmentUrls(); + selfHostUserUrls.base = "https://base.example.com"; + setUserData(Region.SelfHosted, selfHostUserUrls, otherUser); + + await initialize({ switchUser: true }); + + const host = await sut.getHost(otherUser); + expect(host).toBe("base.example.com"); + }); + }); + + describe("setUrlsFromStorage", () => { + it("will set the global data to Region US if no existing data", async () => { + await sut.setUrlsFromStorage(); + + expect(sut.getWebVaultUrl()).toBe("https://vault.bitwarden.com"); + + const globalData = getGlobalData(); + expect(globalData.region).toBe(Region.US); + }); + + it("will set the urls to whatever is in global", async () => { + setGlobalData(Region.EU, new EnvironmentUrls()); + + await sut.setUrlsFromStorage(); + + expect(sut.getWebVaultUrl()).toBe("https://vault.bitwarden.eu"); + }); + + it("recovers from previous bug", async () => { + const buggedEnvironmentUrls = new EnvironmentUrls(); + buggedEnvironmentUrls.base = "https://vault.bitwarden.com"; + buggedEnvironmentUrls.notifications = null; + setGlobalData(null, buggedEnvironmentUrls); + + const urlEmission = firstValueFrom(sut.urls.pipe(timeout(100))); + + await sut.setUrlsFromStorage(); + + await urlEmission; + + const globalData = getGlobalData(); + expect(globalData.region).toBe(Region.US); + expect(globalData.urls).toEqual({ + base: null, + api: null, + identity: null, + events: null, + icons: null, + notifications: null, + keyConnector: null, + webVault: null, + }); + }); + + it("will get urls from signed in user", async () => { + await stateService.init(); + await switchUser(testUser); + + const userUrls = new EnvironmentUrls(); + userUrls.base = "base.example.com"; + setUserData(Region.SelfHosted, userUrls); + + await sut.setUrlsFromStorage(); + + expect(sut.getWebVaultUrl()).toBe("base.example.com"); + }); + }); + + describe("getCloudWebVaultUrl", () => { + it("no extra initialization, returns US vault", () => { + expect(sut.getCloudWebVaultUrl()).toBe("https://vault.bitwarden.com"); + }); + + it.each([ + { region: Region.US, expectedVault: "https://vault.bitwarden.com" }, + { region: Region.EU, expectedVault: "https://vault.bitwarden.eu" }, + { region: Region.SelfHosted, expectedVault: "https://vault.bitwarden.com" }, + ])( + "no extra initialization, returns expected host for each region %s", + ({ region, expectedVault }) => { + expect(sut.setCloudWebVaultUrl(region)); + expect(sut.getCloudWebVaultUrl()).toBe(expectedVault); + }, + ); + }); +});