[PM-5363] PinService State Providers (#8244)

* move pinKeyEncryptedUserKey

* move pinKeyEncryptedUserKeyEphemeral

* remove comments, move docs

* cleanup

* use UserKeyDefinition

* refactor methods

* add migration

* fix browser dependency

* add tests for migration

* rename to pinService

* move state to PinService

* add PinService dep to CryptoService

* move protectedPin to state provider

* update service deps

* renaming

* move decryptUserKeyWithPin to pinService

* update service injection

* move more methods our of crypto service

* remove CryptoService dep from PinService and update service injection

* remove cryptoService reference

* add method to FakeMasterPasswordService

* fix circular dependency

* fix desktop service injection

* update browser dependencies

* add protectedPin to migrations

* move storePinKey to pinService

* update and clarify documentation

* more jsdoc updates

* update import paths

* refactor isPinLockSet method

* update state definitions

* initialize service before injecting into other services

* initialize service before injecting into other services (bw.ts)

* update clearOn and do additional cleanup

* clarify docs and naming

* assign abstract & private methods, add clarity to decryptAndMigrateOldPinKeyEncryptedMasterKey() method

* derived state (attempt)

* fix typos

* use accountService to get active user email

* use constant userId

* add derived state

* add get and clear for oldPinKeyEncryptedMasterKey

* require userId

* move pinProtected

* add clear methods

* remove pinProtected from account.ts and replace methods

* add methods to create and store pinKeyEncryptedUserKey

* add pinProtected/oldPinKeyEncrypterMasterKey to migration

* update migration tests

* update migration rollback tests

* update to systemService and decryptAndMigrate... method

* remove old test

* increase length of state definition name to meet test requirements

* rename 'TRANSIENT' to 'EPHEMERAL' for consistency

* fix tests for login strategies, vault-export, and fake MP service

* more updates to login-strategy tests

* write new tests for core pinKeyEncrypterUserKey methods and isPinSet

* write new tests for pinProtected and oldPinKeyEncryptedMasterKey methods

* minor test reformatting

* update test for decryptUserKeyWithPin()

* fix bug with oldPinKeyEncryptedMasterKey

* fix tests for vault-timeout-settings.service

* fix bitwarden-password-protected-importer test

* fix login strategy tests and auth-request.service test

* update pinService tests

* fix crypto service tests

* add jsdoc

* fix test file import

* update jsdocs for decryptAndMigrateOldPinKeyEncryptedMasterKey()

* update error messages and jsdocs

* add null checks, move userId retrievals

* update migration tests

* update stateService calls to require userId

* update test for decryptUserKeyWithPin()

* update oldPinKeyEncryptedMasterKey migration tests

* more test updates

* fix factory import

* update tests for isPinSet() and createProtectedPin()

* add test for makePinKey()

* add test for createPinKeyEncryptedUserKey()

* add tests for getPinLockType()

* consolidate userId verification tests

* add tests for storePinKeyEncryptedUserKey()

* fix service dep

* get email based on userId

* use MasterPasswordService instead of internal

* rename protectedPin to userKeyEncryptedPin

* rename to pinKeyEncryptedUserKeyPersistent

* update method params

* fix CryptoService tests

* jsdoc update

* use EncString for userKeyEncryptedPin

* remove comment

* use cryptoFunctionService.compareFast()

* update tests

* cleanup, remove comments

* resolve merge conflict

* fix DI of MasterPasswordService

* more DI fixes

libs/common/src/services/vault-timeout/vault-timeout-settings.service.spec.ts

@@ -2,10 +2,14 @@ import { mock, MockProxy } from "jest-mock-extended";
 import { BehaviorSubject, firstValueFrom, map, of } from "rxjs";
 
 import {
+  PinServiceAbstraction,
   FakeUserDecryptionOptions as UserDecryptionOptions,
   UserDecryptionOptionsServiceAbstraction,
 } from "@bitwarden/auth/common";
+import { Utils } from "@bitwarden/common/platform/misc/utils";
+import { UserId } from "@bitwarden/common/types/guid";
 
+import { FakeAccountService, mockAccountServiceWith } from "../../../spec";
 import { PolicyService } from "../../admin-console/abstractions/policy/policy.service.abstraction";
 import { Policy } from "../../admin-console/models/domain/policy";
 import { TokenService } from "../../auth/abstractions/token.service";
@@ -13,11 +17,12 @@ import { VaultTimeoutAction } from "../../enums/vault-timeout-action.enum";
 import { CryptoService } from "../../platform/abstractions/crypto.service";
 import { StateService } from "../../platform/abstractions/state.service";
 import { BiometricStateService } from "../../platform/biometrics/biometric-state.service";
-import { EncString } from "../../platform/models/domain/enc-string";
 
 import { VaultTimeoutSettingsService } from "./vault-timeout-settings.service";
 
 describe("VaultTimeoutSettingsService", () => {
+  let accountService: FakeAccountService;
+  let pinService: MockProxy<PinServiceAbstraction>;
   let userDecryptionOptionsService: MockProxy<UserDecryptionOptionsServiceAbstraction>;
   let cryptoService: MockProxy<CryptoService>;
   let tokenService: MockProxy<TokenService>;
@@ -28,7 +33,11 @@ describe("VaultTimeoutSettingsService", () => {
 
   let userDecryptionOptionsSubject: BehaviorSubject<UserDecryptionOptions>;
 
+  const mockUserId = Utils.newGuid() as UserId;
+
   beforeEach(() => {
+    accountService = mockAccountServiceWith(mockUserId);
+    pinService = mock<PinServiceAbstraction>();
     userDecryptionOptionsService = mock<UserDecryptionOptionsServiceAbstraction>();
     cryptoService = mock<CryptoService>();
     tokenService = mock<TokenService>();
@@ -45,6 +54,8 @@ describe("VaultTimeoutSettingsService", () => {
     );
 
     service = new VaultTimeoutSettingsService(
+      accountService,
+      pinService,
       userDecryptionOptionsService,
       cryptoService,
       tokenService,
@@ -75,16 +86,8 @@ describe("VaultTimeoutSettingsService", () => {
       expect(result).toContain(VaultTimeoutAction.Lock);
     });
 
-    it("contains Lock when the user has a persistent PIN configured", async () => {
-      stateService.getPinKeyEncryptedUserKey.mockResolvedValue(createEncString());
-
-      const result = await firstValueFrom(service.availableVaultTimeoutActions$());
-
-      expect(result).toContain(VaultTimeoutAction.Lock);
-    });
-
-    it("contains Lock when the user has a transient/ephemeral PIN configured", async () => {
-      stateService.getProtectedPin.mockResolvedValue("some-key");
+    it("contains Lock when the user has either a persistent or ephemeral PIN configured", async () => {
+      pinService.isPinSet.mockResolvedValue(true);
 
       const result = await firstValueFrom(service.availableVaultTimeoutActions$());
 
@@ -93,6 +96,7 @@ describe("VaultTimeoutSettingsService", () => {
 
     it("contains Lock when the user has biometrics configured", async () => {
       biometricStateService.biometricUnlockEnabled$ = of(true);
+      biometricStateService.getBiometricUnlockEnabled.mockResolvedValue(true);
 
       const result = await firstValueFrom(service.availableVaultTimeoutActions$());
 
@@ -101,8 +105,7 @@ describe("VaultTimeoutSettingsService", () => {
 
     it("not contains Lock when the user does not have a master password, PIN, or biometrics", async () => {
       userDecryptionOptionsSubject.next(new UserDecryptionOptions({ hasMasterPassword: false }));
-      stateService.getPinKeyEncryptedUserKey.mockResolvedValue(null);
-      stateService.getProtectedPin.mockResolvedValue(null);
+      pinService.isPinSet.mockResolvedValue(false);
       biometricStateService.biometricUnlockEnabled$ = of(false);
 
       const result = await firstValueFrom(service.availableVaultTimeoutActions$());
@@ -149,6 +152,8 @@ describe("VaultTimeoutSettingsService", () => {
         "returns $expected when policy is $policy, has unlock method is $unlockMethod, and user preference is $userPreference",
         async ({ unlockMethod, policy, userPreference, expected }) => {
           biometricStateService.biometricUnlockEnabled$ = of(unlockMethod);
+          biometricStateService.getBiometricUnlockEnabled.mockResolvedValue(unlockMethod);
+
           userDecryptionOptionsSubject.next(
             new UserDecryptionOptions({ hasMasterPassword: false }),
           );
@@ -165,7 +170,3 @@ describe("VaultTimeoutSettingsService", () => {
     });
   });
 });
-
-function createEncString() {
-  return Symbol() as unknown as EncString;
-}