Merge branch 'main' into brant/BITAU-152-handle-vault-lock-unlock

Author: brant-livefront

.github/workflows/build.yml

@@ -308,6 +308,7 @@ jobs:
 
       - name: Install Fastlane, Mint
         run: |
+          brew update
           brew install fastlane mint
 
       - name: Install Mint packages

AuthenticatorBridgeKit/AuthenticatorKeychainService.swift

@@ -29,10 +29,18 @@ public protocol AuthenticatorKeychainService: AnyObject {
 // MARK: - AuthenticatorKeychainServiceError
 
 /// Enum with possible error cases that can be thrown from `AuthenticatorKeychainService`.
-public enum AuthenticatorKeychainServiceError: Error, Equatable {
+public enum AuthenticatorKeychainServiceError: Error, Equatable, CustomNSError {
     /// When a `KeychainService` is unable to locate an auth key for a given storage key.
     ///
     /// - Parameter KeychainItem: The potential storage key for the auth key.
     ///
     case keyNotFound(SharedKeychainItem)
+
+    /// The user-info dictionary.
+    public var errorUserInfo: [String: Any] {
+        switch self {
+        case let .keyNotFound(keychainItem):
+            return ["Keychain Item": keychainItem.unformattedKey]
+        }
+    }
 }

AuthenticatorBridgeKit/Tests/TestHelpers/MockErrorReporter.swift

@@ -1,10 +1,20 @@
 @testable import AuthenticatorBridgeKit
 
 class MockErrorReporter: ErrorReporter {
+    var currentUserId: String?
     var errors = [Error]()
     var isEnabled = false
+    var region: (String, Bool)?
 
     func log(error: Error) {
         errors.append(error)
     }
+
+    func setRegion(_ region: String, isPreAuth: Bool) {
+        self.region = (region, isPreAuth)
+    }
+
+    func setUserId(_ userId: String?) {
+        currentUserId = userId
+    }
 }

Bitwarden/Application/SceneDelegate.swift

@@ -60,6 +60,7 @@ class SceneDelegate: UIResponder, UIWindowSceneDelegate {
             await appProcessor.start(
                 appContext: .mainApp,
                 navigator: rootViewController,
+                splashWindow: splashWindow,
                 window: appWindow
             )
             hideSplash()

Bitwarden/Application/Services/ErrorReporter/CrashlyticsErrorReporter.swift

@@ -30,4 +30,18 @@ final class CrashlyticsErrorReporter: ErrorReporter {
 
         Crashlytics.crashlytics().record(error: error)
     }
+
+    func setRegion(_ region: String, isPreAuth: Bool) {
+        guard isEnabled else {
+            return
+        }
+        Crashlytics.crashlytics().setCustomValue(region, forKey: isPreAuth ? "PreAuthRegion" : "Region")
+    }
+
+    func setUserId(_ userId: String?) {
+        guard isEnabled else {
+            return
+        }
+        Crashlytics.crashlytics().setUserID(userId)
+    }
 }

BitwardenShared/Core/Auth/Models/Enum/RegionType.swift

@@ -40,4 +40,13 @@ public enum RegionType: CaseIterable, Sendable {
             return nil
         }
     }
+
+    /// The name to be used by the error reporter.
+    var errorReporterName: String {
+        switch self {
+        case .europe: return "EU"
+        case .selfHosted: return "Self-Hosted"
+        case .unitedStates: return "US"
+        }
+    }
 }

BitwardenShared/Core/Auth/Models/Enum/RegionTypeTests.swift

@@ -0,0 +1,35 @@
+import XCTest
+
+@testable import BitwardenShared
+
+class RegionTypeTests: BitwardenTestCase {
+    // MARK: Tests
+
+    /// `getter:localizedName` returns the correct values.
+    func test_localizedName() {
+        XCTAssertEqual(RegionType.europe.localizedName, Localizations.eu)
+        XCTAssertEqual(RegionType.selfHosted.localizedName, Localizations.selfHosted)
+        XCTAssertEqual(RegionType.unitedStates.localizedName, Localizations.us)
+    }
+
+    /// `getter:baseUrlDescription` returns the correct values.
+    func test_baseUrlDescription() {
+        XCTAssertEqual(RegionType.europe.baseUrlDescription, "bitwarden.eu")
+        XCTAssertEqual(RegionType.selfHosted.baseUrlDescription, Localizations.selfHosted)
+        XCTAssertEqual(RegionType.unitedStates.baseUrlDescription, "bitwarden.com")
+    }
+
+    /// `getter:defaultURLs` returns the correct values.
+    func test_defaultURLs() {
+        XCTAssertEqual(RegionType.europe.defaultURLs?.api?.absoluteString, "https://api.bitwarden.eu")
+        XCTAssertNil(RegionType.selfHosted.defaultURLs)
+        XCTAssertEqual(RegionType.unitedStates.defaultURLs?.api?.absoluteString, "https://api.bitwarden.com")
+    }
+
+    /// `getter:errorReporterName` returns the correct values.
+    func test_errorReporterName() {
+        XCTAssertEqual(RegionType.europe.errorReporterName, "EU")
+        XCTAssertEqual(RegionType.selfHosted.errorReporterName, "Self-Hosted")
+        XCTAssertEqual(RegionType.unitedStates.errorReporterName, "US")
+    }
+}

BitwardenShared/Core/Auth/Services/KeychainService.swift

@@ -37,7 +37,7 @@ protocol KeychainService: AnyObject {
 
 // MARK: - KeychainServiceError
 
-enum KeychainServiceError: Error, Equatable {
+enum KeychainServiceError: Error, Equatable, CustomNSError {
     /// When creating an accessControl fails.
     ///
     /// - Parameter CFError: The potential system error.
@@ -55,6 +55,18 @@ enum KeychainServiceError: Error, Equatable {
     /// - Parameter OSStatus: The `OSStatus` returned from a keychain operation.
     ///
     case osStatusError(OSStatus)
+
+    /// The user-info dictionary.
+    public var errorUserInfo: [String: Any] {
+        switch self {
+        case .accessControlFailed:
+            return [:]
+        case let .keyNotFound(keychainItem):
+            return ["Keychain Item": keychainItem.unformattedKey]
+        case let .osStatusError(osStatus):
+            return ["OS Status": osStatus]
+        }
+    }
 }
 
 // MARK: - DefaultKeychainService

BitwardenShared/Core/Auth/Services/KeychainServiceTests.swift

@@ -0,0 +1,21 @@
+// swiftlint:disable:this file_name
+
+import XCTest
+
+@testable import BitwardenShared
+
+class KeychainServiceErrorTests: BitwardenTestCase {
+    // MARK: Tests
+
+    /// `getter:errorUserInfo` gets the appropriate user info based on the error case.
+    func test_errorUserInfo() {
+        let errorAccessControlFailed = KeychainServiceError.accessControlFailed(nil)
+        XCTAssertTrue(errorAccessControlFailed.errorUserInfo.isEmpty)
+
+        let errorKeyNotFound = KeychainServiceError.keyNotFound(KeychainItem.refreshToken(userId: "1"))
+        XCTAssertEqual(errorKeyNotFound.errorUserInfo["Keychain Item"] as? String, "refreshToken_1")
+
+        let errorOSStatusError = KeychainServiceError.osStatusError(3)
+        XCTAssertEqual(errorOSStatusError.errorUserInfo["OS Status"] as? Int32, 3)
+    }
+}

BitwardenShared/Core/Platform/Extensions/BitwardenSdk+Platform.swift

@@ -0,0 +1,14 @@
+// swiftlint:disable:this file_name
+
+import BitwardenSdk
+import Foundation
+
+extension BitwardenSdk.BitwardenError: CustomNSError {
+    /// The user-info dictionary.
+    public var errorUserInfo: [String: Any] {
+        guard case let .E(message) = self else {
+            return [:]
+        }
+        return ["Message": message]
+    }
+}

BitwardenShared/Core/Platform/Extensions/BitwardenSdk+PlatformTests.swift

@@ -0,0 +1,18 @@
+// swiftlint:disable:this file_name
+
+import BitwardenSdk
+import XCTest
+
+@testable import BitwardenShared
+
+class BitwardenErrorTests: BitwardenTestCase {
+    // MARK: Tests
+
+    /// `getter:errorUserInfo` gets the appropriate user info based on the message of the error `E`
+    func test_errorUserInfo() {
+        let expectedMessage = "expectedMessage"
+        let error = BitwardenSdk.BitwardenError.E(message: expectedMessage)
+        let userInfo = error.errorUserInfo
+        XCTAssertEqual(userInfo["Message"] as? String, expectedMessage)
+    }
+}

BitwardenShared/Core/Platform/Services/API/Errors/ServerError.swift

@@ -1,8 +1,10 @@
+import Foundation
+
 // MARK: - ServerError
 
 /// An enumeration of server errors.
 ///
-enum ServerError: Error, Equatable {
+enum ServerError: Error, Equatable, CustomNSError {
     /// A generic error.
     ///
     /// - Parameter errorResponse: The error response returned from the API request.
@@ -24,4 +26,9 @@ enum ServerError: Error, Equatable {
             validationErrorResponse.errorModel.message
         }
     }
+
+    /// The user-info dictionary.
+    public var errorUserInfo: [String: Any] {
+       ["Message": message]
+    }
 }

BitwardenShared/Core/Platform/Services/EnvironmentService.swift

@@ -59,6 +59,9 @@ protocol EnvironmentService {
 ///
 class DefaultEnvironmentService: EnvironmentService {
     // MARK: Properties
+    
+    /// The service used by the application to report non-fatal errors.
+    let errorReporter: ErrorReporter
 
     /// The service used by the application to manage account state.
     let stateService: StateService
@@ -77,10 +80,12 @@ class DefaultEnvironmentService: EnvironmentService {
     /// Initialize a `DefaultEnvironmentService`.
     ///
     /// - Parameters:
+    ///   - errorReporter: The service used by the application to report non-fatal errors
     ///   - stateService: The service used by the application to manage account state.
     ///   - standardUserDefaults: The shared UserDefaults instance.
     ///
-    init(stateService: StateService, standardUserDefaults: UserDefaults = .standard) {
+    init(errorReporter: ErrorReporter, stateService: StateService, standardUserDefaults: UserDefaults = .standard) {
+        self.errorReporter = errorReporter
         self.stateService = stateService
         self.standardUserDefaults = standardUserDefaults
 
@@ -105,6 +110,8 @@ class DefaultEnvironmentService: EnvironmentService {
         await setPreAuthURLs(urls: managedSettingsUrls ?? urls)
         environmentUrls = EnvironmentUrls(environmentUrlData: urls)
 
+        errorReporter.setRegion(region.errorReporterName, isPreAuth: false)
+
         // swiftformat:disable:next redundantSelf
         Logger.application.info("Loaded environment URLs: \(String(describing: self.environmentUrls))")
     }
@@ -113,6 +120,8 @@ class DefaultEnvironmentService: EnvironmentService {
         await stateService.setPreAuthEnvironmentUrls(urls)
         environmentUrls = EnvironmentUrls(environmentUrlData: urls)
 
+        errorReporter.setRegion(region.errorReporterName, isPreAuth: true)
+
         // swiftformat:disable:next redundantSelf
         Logger.application.info("Setting pre-auth URLs: \(String(describing: self.environmentUrls))")
     }

BitwardenShared/Core/Platform/Services/EnvironmentServiceTests.swift

@@ -5,6 +5,7 @@ import XCTest
 class EnvironmentServiceTests: XCTestCase {
     // MARK: Properties
 
+    var errorReporter: MockErrorReporter!
     var stateService: MockStateService!
     var standardUserDefaults: UserDefaults!
     var subject: EnvironmentService!
@@ -14,11 +15,13 @@ class EnvironmentServiceTests: XCTestCase {
     override func setUp() {
         super.setUp()
 
+        errorReporter = MockErrorReporter()
         stateService = MockStateService()
         standardUserDefaults = UserDefaults(suiteName: "test")
         standardUserDefaults.removeObject(forKey: "com.apple.configuration.managed")
 
         subject = DefaultEnvironmentService(
+            errorReporter: errorReporter,
             stateService: stateService,
             standardUserDefaults: standardUserDefaults
         )
@@ -27,6 +30,7 @@ class EnvironmentServiceTests: XCTestCase {
     override func tearDown() {
         super.tearDown()
 
+        errorReporter = nil
         stateService = nil
         standardUserDefaults = nil
         subject = nil
@@ -66,6 +70,9 @@ class EnvironmentServiceTests: XCTestCase {
         XCTAssertEqual(subject.settingsURL, URL(string: "https://example.com/#/settings"))
         XCTAssertEqual(subject.webVaultURL, URL(string: "https://example.com"))
         XCTAssertEqual(stateService.preAuthEnvironmentUrls, urls)
+
+        XCTAssertEqual(errorReporter.region?.region, "Self-Hosted")
+        XCTAssertEqual(errorReporter.region?.isPreAuth, false)
     }
 
     /// `loadURLsForActiveAccount()` handles EU URLs
@@ -87,6 +94,9 @@ class EnvironmentServiceTests: XCTestCase {
         XCTAssertEqual(subject.settingsURL, URL(string: "https://vault.bitwarden.eu/#/settings"))
         XCTAssertEqual(subject.webVaultURL, URL(string: "https://vault.bitwarden.eu"))
         XCTAssertEqual(stateService.preAuthEnvironmentUrls, urls)
+
+        XCTAssertEqual(errorReporter.region?.region, "EU")
+        XCTAssertEqual(errorReporter.region?.isPreAuth, false)
     }
 
     /// `loadURLsForActiveAccount()` loads the managed config URLs.
@@ -153,6 +163,9 @@ class EnvironmentServiceTests: XCTestCase {
         XCTAssertEqual(subject.settingsURL, URL(string: "https://vault.bitwarden.com/#/settings"))
         XCTAssertEqual(subject.webVaultURL, URL(string: "https://vault.bitwarden.com"))
         XCTAssertEqual(stateService.preAuthEnvironmentUrls, .defaultUS)
+
+        XCTAssertEqual(errorReporter.region?.region, "US")
+        XCTAssertEqual(errorReporter.region?.isPreAuth, false)
     }
 
     /// `loadURLsForActiveAccount()` loads the preAuth URLs if there's no active account
@@ -173,6 +186,9 @@ class EnvironmentServiceTests: XCTestCase {
         XCTAssertEqual(subject.settingsURL, URL(string: "https://example.com/#/settings"))
         XCTAssertEqual(subject.webVaultURL, URL(string: "https://example.com"))
         XCTAssertEqual(stateService.preAuthEnvironmentUrls, urls)
+
+        XCTAssertEqual(errorReporter.region?.region, "Self-Hosted")
+        XCTAssertEqual(errorReporter.region?.isPreAuth, false)
     }
 
     /// `setPreAuthURLs(urls:)` sets the pre-auth URLs.
@@ -191,5 +207,7 @@ class EnvironmentServiceTests: XCTestCase {
         XCTAssertEqual(subject.settingsURL, URL(string: "https://example.com/#/settings"))
         XCTAssertEqual(subject.webVaultURL, URL(string: "https://example.com"))
         XCTAssertEqual(stateService.preAuthEnvironmentUrls, urls)
+        XCTAssertEqual(errorReporter.region?.region, "Self-Hosted")
+        XCTAssertEqual(errorReporter.region?.isPreAuth, true)
     }
 }

BitwardenShared/Core/Platform/Services/ErrorReporter/ErrorReporter.swift

@@ -15,4 +15,14 @@ public protocol ErrorReporter: AnyObject, AuthenticatorBridgeKit.ErrorReporter {
     /// - Parameter error: The error to log.
     ///
     func log(error: Error)
+    
+    /// Sets the current region the user is on.
+    /// - Parameters:
+    ///   - region: Region the user is on (US, EU, SelfHosted).
+    ///   - isPreAuth: Whether this region is being used pre authentication or when already authenticated.
+    func setRegion(_ region: String, isPreAuth: Bool)
+
+    /// Sets the current user iD to attach to errors.
+    /// - Parameter userId: User ID to attach.
+    func setUserId(_ userId: String?)
 }

BitwardenShared/Core/Platform/Services/ServiceContainer.swift

@@ -320,10 +320,11 @@ public class ServiceContainer: Services { // swiftlint:disable:this type_body_le
         let stateService = DefaultStateService(
             appSettingsStore: appSettingsStore,
             dataStore: dataStore,
+            errorReporter: errorReporter,
             keychainRepository: keychainRepository
         )
 
-        let environmentService = DefaultEnvironmentService(stateService: stateService)
+        let environmentService = DefaultEnvironmentService(errorReporter: errorReporter, stateService: stateService)
         let collectionService = DefaultCollectionService(collectionDataStore: dataStore, stateService: stateService)
         let settingsService = DefaultSettingsService(settingsDataStore: dataStore, stateService: stateService)
         let tokenService = DefaultTokenService(keychainRepository: keychainRepository, stateService: stateService)