refactor(device-trust-toasts): [Auth/PM-11225] Refactor Toasts from Auth Services (#13665)

Refactor toast calls out of auth services. Toasts are now triggered by an observable emission that gets picked up by an observable pipeline in a new `DeviceTrustToastService` (libs/angular). That observable pipeline is then subscribed by by consuming the `AppComponent` for each client.

libs/angular/src/auth/services/device-trust-toast.service.abstraction.ts

@@ -0,0 +1,9 @@
+import { Observable } from "rxjs";
+
+export abstract class DeviceTrustToastService {
+  /**
+   * An observable pipeline that observes any cross-application toast messages
+   * that need to be shown as part of the trusted device encryption (TDE) process.
+   */
+  abstract setupListeners$: Observable<void>;
+}

libs/angular/src/auth/services/device-trust-toast.service.implementation.ts

@@ -0,0 +1,44 @@
+import { merge, Observable, tap } from "rxjs";
+
+import { AuthRequestServiceAbstraction } from "@bitwarden/auth/common";
+import { DeviceTrustServiceAbstraction } from "@bitwarden/common/auth/abstractions/device-trust.service.abstraction";
+import { I18nService } from "@bitwarden/common/platform/abstractions/i18n.service";
+import { ToastService } from "@bitwarden/components";
+
+import { DeviceTrustToastService as DeviceTrustToastServiceAbstraction } from "./device-trust-toast.service.abstraction";
+
+export class DeviceTrustToastService implements DeviceTrustToastServiceAbstraction {
+  private adminLoginApproved$: Observable<void>;
+  private deviceTrusted$: Observable<void>;
+
+  setupListeners$: Observable<void>;
+
+  constructor(
+    private authRequestService: AuthRequestServiceAbstraction,
+    private deviceTrustService: DeviceTrustServiceAbstraction,
+    private i18nService: I18nService,
+    private toastService: ToastService,
+  ) {
+    this.adminLoginApproved$ = this.authRequestService.adminLoginApproved$.pipe(
+      tap(() => {
+        this.toastService.showToast({
+          variant: "success",
+          title: "",
+          message: this.i18nService.t("loginApproved"),
+        });
+      }),
+    );
+
+    this.deviceTrusted$ = this.deviceTrustService.deviceTrusted$.pipe(
+      tap(() => {
+        this.toastService.showToast({
+          variant: "success",
+          title: "",
+          message: this.i18nService.t("deviceTrusted"),
+        });
+      }),
+    );
+
+    this.setupListeners$ = merge(this.adminLoginApproved$, this.deviceTrusted$);
+  }
+}

libs/angular/src/auth/services/device-trust-toast.service.spec.ts

@@ -0,0 +1,167 @@
+import { mock, MockProxy } from "jest-mock-extended";
+import { EMPTY, of } from "rxjs";
+
+import { AuthRequestServiceAbstraction } from "@bitwarden/auth/common";
+import { DeviceTrustServiceAbstraction } from "@bitwarden/common/auth/abstractions/device-trust.service.abstraction";
+import { I18nService } from "@bitwarden/common/platform/abstractions/i18n.service";
+import { ToastService } from "@bitwarden/components";
+
+import { DeviceTrustToastService as DeviceTrustToastServiceAbstraction } from "./device-trust-toast.service.abstraction";
+import { DeviceTrustToastService } from "./device-trust-toast.service.implementation";
+
+describe("DeviceTrustToastService", () => {
+  let authRequestService: MockProxy<AuthRequestServiceAbstraction>;
+  let deviceTrustService: MockProxy<DeviceTrustServiceAbstraction>;
+  let i18nService: MockProxy<I18nService>;
+  let toastService: MockProxy<ToastService>;
+
+  let sut: DeviceTrustToastServiceAbstraction;
+
+  beforeEach(() => {
+    authRequestService = mock<AuthRequestServiceAbstraction>();
+    deviceTrustService = mock<DeviceTrustServiceAbstraction>();
+    i18nService = mock<I18nService>();
+    toastService = mock<ToastService>();
+
+    i18nService.t.mockImplementation((key: string) => key); // just return the key that was given
+  });
+
+  const initService = () => {
+    return new DeviceTrustToastService(
+      authRequestService,
+      deviceTrustService,
+      i18nService,
+      toastService,
+    );
+  };
+
+  const loginApprovalToastOptions = {
+    variant: "success",
+    title: "",
+    message: "loginApproved",
+  };
+
+  const deviceTrustedToastOptions = {
+    variant: "success",
+    title: "",
+    message: "deviceTrusted",
+  };
+
+  describe("setupListeners$", () => {
+    describe("given adminLoginApproved$ emits and deviceTrusted$ emits", () => {
+      beforeEach(() => {
+        // Arrange
+        authRequestService.adminLoginApproved$ = of(undefined);
+        deviceTrustService.deviceTrusted$ = of(undefined);
+        sut = initService();
+      });
+
+      it("should trigger a toast for login approval", (done) => {
+        // Act
+        sut.setupListeners$.subscribe({
+          complete: () => {
+            expect(toastService.showToast).toHaveBeenCalledWith(loginApprovalToastOptions); // Assert
+            done();
+          },
+        });
+      });
+
+      it("should trigger a toast for device trust", (done) => {
+        // Act
+        sut.setupListeners$.subscribe({
+          complete: () => {
+            expect(toastService.showToast).toHaveBeenCalledWith(deviceTrustedToastOptions); // Assert
+            done();
+          },
+        });
+      });
+    });
+
+    describe("given adminLoginApproved$ emits and deviceTrusted$ does not emit", () => {
+      beforeEach(() => {
+        // Arrange
+        authRequestService.adminLoginApproved$ = of(undefined);
+        deviceTrustService.deviceTrusted$ = EMPTY;
+        sut = initService();
+      });
+
+      it("should trigger a toast for login approval", (done) => {
+        // Act
+        sut.setupListeners$.subscribe({
+          complete: () => {
+            expect(toastService.showToast).toHaveBeenCalledWith(loginApprovalToastOptions); // Assert
+            done();
+          },
+        });
+      });
+
+      it("should NOT trigger a toast for device trust", (done) => {
+        // Act
+        sut.setupListeners$.subscribe({
+          complete: () => {
+            expect(toastService.showToast).not.toHaveBeenCalledWith(deviceTrustedToastOptions); // Assert
+            done();
+          },
+        });
+      });
+    });
+
+    describe("given adminLoginApproved$ does not emit and deviceTrusted$ emits", () => {
+      beforeEach(() => {
+        // Arrange
+        authRequestService.adminLoginApproved$ = EMPTY;
+        deviceTrustService.deviceTrusted$ = of(undefined);
+        sut = initService();
+      });
+
+      it("should NOT trigger a toast for login approval", (done) => {
+        // Act
+        sut.setupListeners$.subscribe({
+          complete: () => {
+            expect(toastService.showToast).not.toHaveBeenCalledWith(loginApprovalToastOptions); // Assert
+            done();
+          },
+        });
+      });
+
+      it("should trigger a toast for device trust", (done) => {
+        // Act
+        sut.setupListeners$.subscribe({
+          complete: () => {
+            expect(toastService.showToast).toHaveBeenCalledWith(deviceTrustedToastOptions); // Assert
+            done();
+          },
+        });
+      });
+    });
+
+    describe("given adminLoginApproved$ does not emit and deviceTrusted$ does not emit", () => {
+      beforeEach(() => {
+        // Arrange
+        authRequestService.adminLoginApproved$ = EMPTY;
+        deviceTrustService.deviceTrusted$ = EMPTY;
+        sut = initService();
+      });
+
+      it("should NOT trigger a toast for login approval", (done) => {
+        // Act
+        sut.setupListeners$.subscribe({
+          complete: () => {
+            expect(toastService.showToast).not.toHaveBeenCalledWith(loginApprovalToastOptions); // Assert
+            done();
+          },
+        });
+      });
+
+      it("should NOT trigger a toast for device trust", (done) => {
+        // Act
+        sut.setupListeners$.subscribe({
+          complete: () => {
+            expect(toastService.showToast).not.toHaveBeenCalledWith(deviceTrustedToastOptions); // Assert
+            done();
+          },
+        });
+      });
+    });
+  });
+});

libs/angular/src/services/jslib-services.module.ts

@@ -317,6 +317,8 @@ import {
   IndividualVaultExportServiceAbstraction,
 } from "@bitwarden/vault-export-core";
 
+import { DeviceTrustToastService as DeviceTrustToastServiceAbstraction } from "../auth/services/device-trust-toast.service.abstraction";
+import { DeviceTrustToastService } from "../auth/services/device-trust-toast.service.implementation";
 import { FormValidationErrorsService as FormValidationErrorsServiceAbstraction } from "../platform/abstractions/form-validation-errors.service";
 import { ViewCacheService } from "../platform/abstractions/view-cache.service";
 import { FormValidationErrorsService } from "../platform/services/form-validation-errors.service";
@@ -1463,6 +1465,16 @@ const safeProviders: SafeProvider[] = [
     useClass: DefaultTaskService,
     deps: [StateProvider, ApiServiceAbstraction, OrganizationServiceAbstraction, ConfigService],
   }),
+  safeProvider({
+    provide: DeviceTrustToastServiceAbstraction,
+    useClass: DeviceTrustToastService,
+    deps: [
+      AuthRequestServiceAbstraction,
+      DeviceTrustServiceAbstraction,
+      I18nServiceAbstraction,
+      ToastService,
+    ],
+  }),
 ];
 
 @NgModule({