Merge branch 'feature/messenger-backup' into 'development'

Messenger - backup

See merge request elixxir/elixxir-dapps-sdk-swift!107

Docs/XXMessengerClient.md

@@ -4,7 +4,7 @@
 
 ## ▶️ Instantiate messenger
 
-Example:
+### Example
 
 ```swift
 // setup environment:
@@ -24,7 +24,7 @@ let messenger: Messenger = .live(environment)
 
 ## 🚀 Start messenger
 
-Example:
+### Example
 
 ```swift
 // allow cancellation of callbacks:
@@ -84,7 +84,7 @@ func start(messenger: Messenger) throws {
 
 ## 🛠 Use client components directly
 
-Example:
+### Example
 
 ```swift
 // get cMix:
@@ -95,4 +95,60 @@ let e2e = messenger.e2e()
 
 // get UserDicovery:
 let ud = messenger.ud()
+
+// get Backup:
+let backup = messenger.backup()
 ```
+
+## 💾 Backup
+
+### Make backup
+
+```swift
+// start receiving backup data before starting or resuming backup:
+let cancellable = messenger.registerBackupCallback(.init { data in
+  // handle backup data, save on disk, upload to cloud, etc.
+})
+
+// check if backup is already running:
+if messenger.isBackupRunning() == false {
+  do {
+    // try to resume previous backup:
+    try messenger.resumeBackup()
+  } catch {
+    // try to start a new backup:
+    let params: BackupParams = ...
+    try messenger.startBackup(
+      password: "backup-passphrase",
+      params: params
+    )
+  }
+}
+
+// update params in the backup:
+let params: BackupParams = ...
+try messenger.backupParams(params)
+
+// stop the backup:
+try messenger.stopBackup()
+
+// optionally stop receiving backup data
+cancellable.cancel()
+```
+
+When starting a new backup you must provide `BackupParams` to prevent creating backups that does not contain it.
+
+The registered backup callback can be reused later when a new backup is started. There is no need to cancel it and register a new callback in such a case.
+
+### Restore from backup
+
+```swift
+let result = try messenger.restoreBackup(
+  backupData: ...,
+  backupPassphrase: "backup-passphrase"
+)
+
+// handle restoration result
+```
+
+If no error was thrown during restoration, the `Messenger` is already loaded, started, connected, and logged in.
\ No newline at end of file

Sources/XXMessengerClient/Messenger/Functions/MessengerBackupParams.swift

+import Bindings
+import XCTestDynamicOverlay
+
+public struct MessengerBackupParams {
+  public enum Error: Swift.Error, Equatable {
+    case notRunning
+  }
+
+  public var run: (BackupParams) throws -> Void
+
+  public func callAsFunction(_ params: BackupParams) throws {
+    try run(params)
+  }
+}
+
+extension MessengerBackupParams {
+  public static func live(_ env: MessengerEnvironment) -> MessengerBackupParams {
+    MessengerBackupParams { params in
+      guard let backup = env.backup(), backup.isRunning() else {
+        throw Error.notRunning
+      }
+      let paramsData = try params.encode()
+      let paramsString = String(data: paramsData, encoding: .utf8)!
+      backup.addJSON(paramsString)
+    }
+  }
+}
+
+extension MessengerBackupParams {
+  public static let unimplemented = MessengerBackupParams(
+    run: XCTUnimplemented("\(Self.self)")
+  )
+}

Sources/XXMessengerClient/Messenger/Functions/MessengerIsBackupRunning.swift

+import XCTestDynamicOverlay
+import XXClient
+
+public struct MessengerIsBackupRunning {
+  public var run: () -> Bool
+
+  public func callAsFunction() -> Bool {
+    run()
+  }
+}
+
+extension MessengerIsBackupRunning {
+  public static func live(_ env: MessengerEnvironment) -> MessengerIsBackupRunning {
+    MessengerIsBackupRunning {
+      env.backup()?.isRunning() == true
+    }
+  }
+}
+
+extension MessengerIsBackupRunning {
+  public static let unimplemented = MessengerIsBackupRunning(
+    run: XCTUnimplemented("\(Self.self)")
+  )
+}

Sources/XXMessengerClient/Messenger/Functions/MessengerRegisterBackupCallback.swift

+import XCTestDynamicOverlay
+import XXClient
+
+public struct MessengerRegisterBackupCallback {
+  public var run: (UpdateBackupFunc) -> Cancellable
+
+  public func callAsFunction(_ callback: UpdateBackupFunc) -> Cancellable {
+    run(callback)
+  }
+}
+
+extension MessengerRegisterBackupCallback {
+  public static func live(_ env: MessengerEnvironment) -> MessengerRegisterBackupCallback {
+    MessengerRegisterBackupCallback { callback in
+      env.backupCallbacks.register(callback)
+    }
+  }
+}
+
+extension MessengerRegisterBackupCallback {
+  public static let unimplemented = MessengerRegisterBackupCallback(
+    run: XCTUnimplemented("\(Self.self)", placeholder: Cancellable {})
+  )
+}

Sources/XXMessengerClient/Messenger/Functions/MessengerRestoreBackup.swift

@@ -42,9 +42,8 @@ extension MessengerRestoreBackup {
         sessionPassword: password,
         backupFileContents: backupData
       )
-      let decoder = JSONDecoder()
       let paramsData = report.params.data(using: .utf8)!
-      let params = try decoder.decode(BackupParams.self, from: paramsData)
+      let params = try BackupParams.decode(paramsData)
       let cMix = try env.loadCMix(
         storageDir: storageDir,
         password: password,

Sources/XXMessengerClient/Messenger/Functions/MessengerResumeBackup.swift

+import Bindings
+import XCTestDynamicOverlay
+
+public struct MessengerResumeBackup {
+  public enum Error: Swift.Error, Equatable {
+    case isRunning
+    case notConnected
+    case notLoggedIn
+  }
+
+  public var run: () throws -> Void
+
+  public func callAsFunction() throws {
+    try run()
+  }
+}
+
+extension MessengerResumeBackup {
+  public static func live(_ env: MessengerEnvironment) -> MessengerResumeBackup {
+    MessengerResumeBackup {
+      guard env.backup()?.isRunning() != true else {
+        throw Error.isRunning
+      }
+      guard let e2e = env.e2e() else {
+        throw Error.notConnected
+      }
+      guard let ud = env.ud() else {
+        throw Error.notLoggedIn
+      }
+      let backup = try env.resumeBackup(
+        e2eId: e2e.getId(),
+        udId: ud.getId(),
+        callback: env.backupCallbacks.registered()
+      )
+      env.backup.set(backup)
+    }
+  }
+}
+
+extension MessengerResumeBackup {
+  public static let unimplemented = MessengerResumeBackup(
+    run: XCTUnimplemented("\(Self.self)")
+  )
+}

Sources/XXMessengerClient/Messenger/Functions/MessengerStartBackup.swift

+import XCTestDynamicOverlay
+import XXClient
+
+public struct MessengerStartBackup {
+  public enum Error: Swift.Error, Equatable {
+    case isRunning
+    case notConnected
+    case notLoggedIn
+  }
+
+  public var run: (String, BackupParams) throws -> Void
+
+  public func callAsFunction(
+    password: String,
+    params: BackupParams
+  ) throws {
+    try run(password, params)
+  }
+}
+
+extension MessengerStartBackup {
+  public static func live(_ env: MessengerEnvironment) -> MessengerStartBackup {
+    MessengerStartBackup { password, params in
+      guard env.backup()?.isRunning() != true else {
+        throw Error.isRunning
+      }
+      guard let e2e = env.e2e() else {
+        throw Error.notConnected
+      }
+      guard let ud = env.ud() else {
+        throw Error.notLoggedIn
+      }
+      let paramsData = try params.encode()
+      let paramsString = String(data: paramsData, encoding: .utf8)!
+      var didAddParams = false
+      func addParams() {
+        guard let backup = env.backup() else { return }
+        backup.addJSON(paramsString)
+        didAddParams = true
+      }
+      let backup = try env.initializeBackup(
+        e2eId: e2e.getId(),
+        udId: ud.getId(),
+        password: password,
+        callback: .init { data in
+          if !didAddParams {
+            addParams()
+          } else {
+            env.backupCallbacks.registered().handle(data)
+          }
+        }
+      )
+      env.backup.set(backup)
+    }
+  }
+}
+
+extension MessengerStartBackup {
+  public static let unimplemented = MessengerStartBackup(
+    run: XCTUnimplemented("\(Self.self)")
+  )
+}

Sources/XXMessengerClient/Messenger/Functions/MessengerStopBackup.swift

+import Bindings
+import XCTestDynamicOverlay
+
+public struct MessengerStopBackup {
+  public var run: () throws -> Void
+
+  public func callAsFunction() throws {
+    try run()
+  }
+}
+
+extension MessengerStopBackup {
+  public static func live(_ env: MessengerEnvironment) -> MessengerStopBackup {
+    MessengerStopBackup {
+      guard let backup = env.backup() else { return }
+      try backup.stop()
+      env.backup.set(nil)
+    }
+  }
+}
+
+extension MessengerStopBackup {
+  public static let unimplemented = MessengerStopBackup(
+    run: XCTUnimplemented("\(Self.self)")
+  )
+}

Sources/XXMessengerClient/Messenger/Messenger.swift

@@ -4,6 +4,7 @@ public struct Messenger {
   public var cMix: Stored<CMix?>
   public var e2e: Stored<E2E?>
   public var ud: Stored<UserDiscovery?>
+  public var backup: Stored<Backup?>
   public var isCreated: MessengerIsCreated
   public var create: MessengerCreate
   public var restoreBackup: MessengerRestoreBackup
@@ -29,6 +30,12 @@ public struct Messenger {
   public var registerForNotifications: MessengerRegisterForNotifications
   public var verifyContact: MessengerVerifyContact
   public var sendMessage: MessengerSendMessage
+  public var registerBackupCallback: MessengerRegisterBackupCallback
+  public var isBackupRunning: MessengerIsBackupRunning
+  public var startBackup: MessengerStartBackup
+  public var resumeBackup: MessengerResumeBackup
+  public var backupParams: MessengerBackupParams
+  public var stopBackup: MessengerStopBackup
 }
 
 extension Messenger {
@@ -37,6 +44,7 @@ extension Messenger {
       cMix: env.cMix,
       e2e: env.e2e,
       ud: env.ud,
+      backup: env.backup,
       isCreated: .live(env),
       create: .live(env),
       restoreBackup: .live(env),
@@ -61,7 +69,13 @@ extension Messenger {
       lookupContacts: .live(env),
       registerForNotifications: .live(env),
       verifyContact: .live(env),
-      sendMessage: .live(env)
+      sendMessage: .live(env),
+      registerBackupCallback: .live(env),
+      isBackupRunning: .live(env),
+      startBackup: .live(env),
+      resumeBackup: .live(env),
+      backupParams: .live(env),
+      stopBackup: .live(env)
     )
   }
 }
@@ -71,6 +85,7 @@ extension Messenger {
     cMix: .unimplemented(),
     e2e: .unimplemented(),
     ud: .unimplemented(),
+    backup: .unimplemented(),
     isCreated: .unimplemented,
     create: .unimplemented,
     restoreBackup: .unimplemented,
@@ -95,6 +110,12 @@ extension Messenger {
     lookupContacts: .unimplemented,
     registerForNotifications: .unimplemented,
     verifyContact: .unimplemented,
-    sendMessage: .unimplemented
+    sendMessage: .unimplemented,
+    registerBackupCallback: .unimplemented,
+    isBackupRunning: .unimplemented,
+    startBackup: .unimplemented,
+    resumeBackup: .unimplemented,
+    backupParams: .unimplemented,
+    stopBackup: .unimplemented
   )
 }

Sources/XXMessengerClient/Messenger/MessengerEnvironment.swift

@@ -4,6 +4,8 @@ import XCTestDynamicOverlay
 
 public struct MessengerEnvironment {
   public var authCallbacks: AuthCallbacksRegistry
+  public var backup: Stored<Backup?>
+  public var backupCallbacks: BackupCallbacksRegistry
   public var cMix: Stored<CMix?>
   public var downloadNDF: DownloadAndVerifySignedNdf
   public var e2e: Stored<E2E?>
@@ -12,6 +14,7 @@ public struct MessengerEnvironment {
   public var getCMixParams: GetCMixParams
   public var getE2EParams: GetE2EParams
   public var getSingleUseParams: GetSingleUseParams
+  public var initializeBackup: InitializeBackup
   public var isListeningForMessages: Stored<Bool>
   public var isRegisteredWithUD: IsRegisteredWithUD
   public var loadCMix: LoadCMix
@@ -26,6 +29,7 @@ public struct MessengerEnvironment {
   public var newUdManagerFromBackup: NewUdManagerFromBackup
   public var passwordStorage: PasswordStorage
   public var registerForNotifications: RegisterForNotifications
+  public var resumeBackup: ResumeBackup
   public var searchUD: SearchUD
   public var sleep: (TimeInterval) -> Void
   public var storageDir: String
@@ -45,6 +49,8 @@ extension MessengerEnvironment {
   public static func live() -> MessengerEnvironment {
     MessengerEnvironment(
       authCallbacks: .live(),
+      backup: .inMemory(),
+      backupCallbacks: .live(),
       cMix: .inMemory(),
       downloadNDF: .live,
       e2e: .inMemory(),
@@ -53,6 +59,7 @@ extension MessengerEnvironment {
       getCMixParams: .liveDefault,
       getE2EParams: .liveDefault,
       getSingleUseParams: .liveDefault,
+      initializeBackup: .live,
       isListeningForMessages: .inMemory(false),
       isRegisteredWithUD: .live,
       loadCMix: .live,
@@ -67,6 +74,7 @@ extension MessengerEnvironment {
       newUdManagerFromBackup: .live,
       passwordStorage: .keychain,
       registerForNotifications: .live,
+      resumeBackup: .live,
       searchUD: .live,
       sleep: { Thread.sleep(forTimeInterval: $0) },
       storageDir: MessengerEnvironment.defaultStorageDir,
@@ -81,6 +89,8 @@ extension MessengerEnvironment {
 extension MessengerEnvironment {
   public static let unimplemented = MessengerEnvironment(
     authCallbacks: .unimplemented,
+    backup: .unimplemented(),
+    backupCallbacks: .unimplemented,
     cMix: .unimplemented(),
     downloadNDF: .unimplemented,
     e2e: .unimplemented(),
@@ -89,6 +99,7 @@ extension MessengerEnvironment {
     getCMixParams: .unimplemented,
     getE2EParams: .unimplemented,
     getSingleUseParams: .unimplemented,
+    initializeBackup: .unimplemented,
     isListeningForMessages: .unimplemented(placeholder: false),
     isRegisteredWithUD: .unimplemented,
     loadCMix: .unimplemented,
@@ -103,6 +114,7 @@ extension MessengerEnvironment {
     newUdManagerFromBackup: .unimplemented,
     passwordStorage: .unimplemented,
     registerForNotifications: .unimplemented,
+    resumeBackup: .unimplemented,
     searchUD: .unimplemented,
     sleep: XCTUnimplemented("\(Self.self).sleep"),
     storageDir: "unimplemented",

Sources/XXMessengerClient/Utils/BackupCallbackRegistry.swift

+import Foundation
+import XCTestDynamicOverlay
+import XXClient
+
+public struct BackupCallbacksRegistry {
+  public var register: (UpdateBackupFunc) -> Cancellable
+  public var registered: () -> UpdateBackupFunc
+}
+
+extension BackupCallbacksRegistry {
+  public static func live() -> BackupCallbacksRegistry {
+    class Registry {
+      var callbacks: [UUID: UpdateBackupFunc] = [:]
+    }
+    let registry = Registry()
+    return BackupCallbacksRegistry(
+      register: { callback in
+        let id = UUID()
+        registry.callbacks[id] = callback
+        return Cancellable { registry.callbacks[id] = nil }
+      },
+      registered: {
+        UpdateBackupFunc { data in
+          registry.callbacks.values.forEach { $0.handle(data) }
+        }
+      }
+    )
+  }
+}
+
+extension BackupCallbacksRegistry {
+  public static let unimplemented = BackupCallbacksRegistry(
+    register: XCTUnimplemented("\(Self.self).register", placeholder: Cancellable {}),
+    registered: XCTUnimplemented("\(Self.self).registered", placeholder: UpdateBackupFunc { _ in })
+  )
+}

Sources/XXMessengerClient/Utils/BackupParams.swift

 import Foundation
 
-public struct BackupParams: Equatable, Codable {
+public struct BackupParams: Equatable {
   public init(
     username: String,
     email: String?,
@@ -15,3 +15,13 @@ public struct BackupParams: Equatable, Codable {
   public var email: String?
   public var phone: String?
 }
+
+extension BackupParams: Codable {
+  public static func decode(_ data: Data) throws -> Self {
+    try JSONDecoder().decode(Self.self, from: data)
+  }
+
+  public func encode() throws -> Data {
+    try JSONEncoder().encode(self)
+  }
+}

Tests/XXMessengerClientTests/Messenger/Functions/MessengerBackupParamsTests.swift

+import CustomDump
+import XCTest
+import XXClient
+@testable import XXMessengerClient
+
+final class MessengerBackupParamsTests: XCTestCase {
+  func testBackupParams() throws {
+    var didAddJSON: [String] = []
+
+    var env: MessengerEnvironment = .unimplemented
+    env.backup.get = {
+      var backup: Backup = .unimplemented
+      backup.isRunning.run = { true }
+      backup.addJSON.run = { didAddJSON.append($0) }
+      return backup
+    }
+    let backup: MessengerBackupParams = .live(env)
+    let params = BackupParams(
+      username: "test-username",
+      email: "test-email",
+      phone: "test-phone"
+    )
+
+    try backup(params)
+
+    XCTAssertNoDifference(didAddJSON, [
+      String(data: try params.encode(), encoding: .utf8)!
+    ])
+  }
+
+  func testBackupParamsWhenNoBackup() {
+    var env: MessengerEnvironment = .unimplemented
+    env.backup.get = { nil }
+    let backup: MessengerBackupParams = .live(env)
+    let params = BackupParams(username: "test", email: nil, phone: nil)
+
+    XCTAssertThrowsError(try backup(params)) { error in
+      XCTAssertNoDifference(
+        error as NSError,
+        MessengerBackupParams.Error.notRunning as NSError
+      )
+    }
+  }
+
+  func testBackupParamsWhenBackupNotRunning() {
+    var env: MessengerEnvironment = .unimplemented
+    env.backup.get = {
+      var backup: Backup = .unimplemented
+      backup.isRunning.run = { false }
+      return backup
+    }
+    let backup: MessengerBackupParams = .live(env)
+    let params = BackupParams(username: "test", email: nil, phone: nil)
+
+    XCTAssertThrowsError(try backup(params)) { error in
+      XCTAssertNoDifference(
+        error as NSError,
+        MessengerBackupParams.Error.notRunning as NSError
+      )
+    }
+  }
+}

Tests/XXMessengerClientTests/Messenger/Functions/MessengerIsBackupRunningTests.swift

+import XCTest
+import XXClient
+@testable import XXMessengerClient
+
+final class MessengerIsBackupRunningTests: XCTestCase {
+  func testWithoutBackup() {
+    var env: MessengerEnvironment = .unimplemented
+    env.backup.get = { nil }
+    let isRunning: MessengerIsBackupRunning = .live(env)
+
+    XCTAssertFalse(isRunning())
+  }
+
+  func testWithBackupRunning() {
+    var env: MessengerEnvironment = .unimplemented
+    env.backup.get = {
+      var backup: Backup = .unimplemented
+      backup.isRunning.run = { true }
+      return backup
+    }
+    let isRunning: MessengerIsBackupRunning = .live(env)
+
+    XCTAssertTrue(isRunning())
+  }
+
+  func testWithBackupNotRunning() {
+    var env: MessengerEnvironment = .unimplemented
+    env.backup.get = {
+      var backup: Backup = .unimplemented
+      backup.isRunning.run = { false }
+      return backup
+    }
+    let isRunning: MessengerIsBackupRunning = .live(env)
+
+    XCTAssertFalse(isRunning())
+  }
+}

Tests/XXMessengerClientTests/Messenger/Functions/MessengerRegisterBackupCallbackTests.swift

+import CustomDump
+import XCTest
+import XXClient
+@testable import XXMessengerClient
+
+final class MessengerRegisterBackupCallbackTests: XCTestCase {
+  func testRegisterBackupCallback() {
+    var registeredCallbacks: [UpdateBackupFunc] = []
+    var didHandleData: [Data] = []
+    var didCancelRegisteredCallback = 0
+
+    var env: MessengerEnvironment = .unimplemented
+    env.backupCallbacks.register = { callback in
+      registeredCallbacks.append(callback)
+      return Cancellable { didCancelRegisteredCallback += 1 }
+    }
+    let registerBackupCallback: MessengerRegisterBackupCallback = .live(env)
+    let cancellable = registerBackupCallback(UpdateBackupFunc { data in
+      didHandleData.append(data)
+    })
+
+    XCTAssertEqual(registeredCallbacks.count, 1)
+
+    registeredCallbacks.forEach { callback in
+      callback.handle("test".data(using: .utf8)!)
+    }
+
+    XCTAssertNoDifference(didHandleData, ["test".data(using: .utf8)!])
+
+    cancellable.cancel()
+
+    XCTAssertEqual(didCancelRegisteredCallback, 1)
+  }
+}

Tests/XXMessengerClientTests/Messenger/Functions/MessengerResumeBackupTests.swift

+import CustomDump
+import XCTest
+import XXClient
+@testable import XXMessengerClient
+
+final class MessengerResumeBackupTests: XCTestCase {
+  func testResume() throws {
+    struct ResumeBackupParams: Equatable {
+      var e2eId: Int
+      var udId: Int
+    }
+    var didResumeBackup: [ResumeBackupParams] = []
+    var backupCallbacks: [UpdateBackupFunc] = []
+    var didHandleCallback: [Data] = []
+    var didSetBackup: [Backup?] = []
+
+    let e2eId = 123
+    let udId = 321
+    let data = "test-data".data(using: .utf8)!
+
+    var env: MessengerEnvironment = .unimplemented
+    env.backup.get = { nil }
+    env.backup.set = { didSetBackup.append($0) }
+    env.e2e.get = {
+      var e2e: E2E = .unimplemented
+      e2e.getId.run = { e2eId }
+      return e2e
+    }
+    env.ud.get = {
+      var ud: UserDiscovery = .unimplemented
+      ud.getId.run = { udId }
+      return ud
+    }
+    env.backupCallbacks.registered = {
+      UpdateBackupFunc { didHandleCallback.append($0) }
+    }
+    env.resumeBackup.run = { e2eId, udId, callback in
+      didResumeBackup.append(.init(e2eId: e2eId, udId: udId))
+      backupCallbacks.append(callback)
+      return .unimplemented
+    }
+    let resume: MessengerResumeBackup = .live(env)
+
+    try resume()
+
+    XCTAssertNoDifference(didResumeBackup, [
+      .init(e2eId: e2eId, udId: udId)
+    ])
+    XCTAssertNoDifference(didSetBackup.map { $0 != nil }, [true])
+
+    backupCallbacks.forEach { $0.handle(data) }
+
+    XCTAssertNoDifference(didHandleCallback, [data])
+  }
+
+  func testResumeWhenRunning() {
+    var env: MessengerEnvironment = .unimplemented
+    env.backup.get = {
+      var backup: Backup = .unimplemented
+      backup.isRunning.run = { true }
+      return backup
+    }
+    let resume: MessengerResumeBackup = .live(env)
+
+    XCTAssertThrowsError(try resume()) { error in
+      XCTAssertNoDifference(
+        error as NSError,
+        MessengerResumeBackup.Error.isRunning as NSError
+      )
+    }
+  }
+
+  func testResumeWhenNotConnected() {
+    var env: MessengerEnvironment = .unimplemented
+    env.backup.get = { nil }
+    env.e2e.get = { nil }
+    let resume: MessengerResumeBackup = .live(env)
+
+    XCTAssertThrowsError(try resume()) { error in
+      XCTAssertNoDifference(
+        error as NSError,
+        MessengerResumeBackup.Error.notConnected as NSError
+      )
+    }
+  }
+
+  func testResumeWhenNotLoggedIn() {
+    var env: MessengerEnvironment = .unimplemented
+    env.backup.get = { nil }
+    env.e2e.get = { .unimplemented }
+    env.ud.get = { nil }
+    let resume: MessengerResumeBackup = .live(env)
+
+    XCTAssertThrowsError(try resume()) { error in
+      XCTAssertNoDifference(
+        error as NSError,
+        MessengerResumeBackup.Error.notLoggedIn as NSError
+      )
+    }
+  }
+
+  func testResumeFailure() {
+    struct Failure: Error, Equatable {}
+    let failure = Failure()
+
+    var env: MessengerEnvironment = .unimplemented
+    env.backup.get = { nil }
+    env.e2e.get = {
+      var e2e: E2E = .unimplemented
+      e2e.getId.run = { 123 }
+      return e2e
+    }
+    env.ud.get = {
+      var ud: UserDiscovery = .unimplemented
+      ud.getId.run = { 321 }
+      return ud
+    }
+    env.backupCallbacks.registered = { UpdateBackupFunc { _ in  } }
+    env.resumeBackup.run = { _, _ , _ in throw failure }
+    let resume: MessengerResumeBackup = .live(env)
+
+    XCTAssertThrowsError(try resume()) { error in
+      XCTAssertNoDifference(error as NSError, failure as NSError)
+    }
+  }
+}

Tests/XXMessengerClientTests/Messenger/Functions/MessengerStartBackupTests.swift

+import CustomDump
+import XCTest
+import XXClient
+@testable import XXMessengerClient
+
+final class MessengerStartBackupTests: XCTestCase {
+  func testStart() throws {
+    struct InitBackupParams: Equatable {
+      var e2eId: Int
+      var udId: Int
+      var password: String
+    }
+    var didInitializeBackup: [InitBackupParams] = []
+    var backupCallbacks: [UpdateBackupFunc] = []
+    var didHandleCallback: [Data] = []
+    var didSetBackup: [Backup?] = []
+    var didAddJSON: [String] = []
+
+    let password = "test-password"
+    let e2eId = 123
+    let udId = 321
+    let dataWithoutParams = "backup-without-params".data(using: .utf8)!
+    let dataWithParams = "backup-with-params".data(using: .utf8)!
+
+    var env: MessengerEnvironment = .unimplemented
+    env.backup.get = { didSetBackup.last as? Backup }
+    env.backup.set = { didSetBackup.append($0) }
+    env.e2e.get = {
+      var e2e: E2E = .unimplemented
+      e2e.getId.run = { e2eId }
+      return e2e
+    }
+    env.ud.get = {
+      var ud: UserDiscovery = .unimplemented
+      ud.getId.run = { udId }
+      return ud
+    }
+    env.backupCallbacks.registered = {
+      UpdateBackupFunc { didHandleCallback.append($0) }
+    }
+    env.initializeBackup.run = { e2eId, udId, password, callback in
+      didInitializeBackup.append(.init(e2eId: e2eId, udId: udId, password: password))
+      backupCallbacks.append(callback)
+      var backup: Backup = .unimplemented
+      backup.addJSON.run = { string in
+        didAddJSON.append(string)
+      }
+      return backup
+    }
+    let start: MessengerStartBackup = .live(env)
+
+    try start(password: password, params: .stub)
+
+    XCTAssertNoDifference(didInitializeBackup, [
+      .init(e2eId: e2eId, udId: udId, password: password)
+    ])
+    XCTAssertNoDifference(didSetBackup.map { $0 != nil }, [true])
+
+    backupCallbacks.forEach { $0.handle(dataWithoutParams) }
+
+    XCTAssertNoDifference(
+      didHandleCallback.map(StringData.init),
+      [].map(StringData.init)
+    )
+    XCTAssertNoDifference(didAddJSON, [
+      String(data: try BackupParams.stub.encode(), encoding: .utf8)!
+    ])
+
+    backupCallbacks.forEach { $0.handle(dataWithParams) }
+
+    XCTAssertNoDifference(
+      didHandleCallback.map(StringData.init),
+      [dataWithParams].map(StringData.init)
+    )
+  }
+
+  func testStartWhenRunning() {
+    var env: MessengerEnvironment = .unimplemented
+    env.backup.get = {
+      var backup: Backup = .unimplemented
+      backup.isRunning.run = { true }
+      return backup
+    }
+    let start: MessengerStartBackup = .live(env)
+
+    XCTAssertThrowsError(try start(password: "", params: .stub)) { error in
+      XCTAssertNoDifference(
+        error as NSError,
+        MessengerStartBackup.Error.isRunning as NSError
+      )
+    }
+  }
+
+  func testStartWhenNotConnected() {
+    var env: MessengerEnvironment = .unimplemented
+    env.backup.get = { nil }
+    env.e2e.get = { nil }
+    let start: MessengerStartBackup = .live(env)
+
+    XCTAssertThrowsError(try start(password: "", params: .stub)) { error in
+      XCTAssertNoDifference(
+        error as NSError,
+        MessengerStartBackup.Error.notConnected as NSError
+      )
+    }
+  }
+
+  func testStartWhenNotLoggedIn() {
+    var env: MessengerEnvironment = .unimplemented
+    env.backup.get = { nil }
+    env.e2e.get = { .unimplemented }
+    env.ud.get = { nil }
+    let start: MessengerStartBackup = .live(env)
+
+    XCTAssertThrowsError(try start(password: "", params: .stub)) { error in
+      XCTAssertNoDifference(
+        error as NSError,
+        MessengerStartBackup.Error.notLoggedIn as NSError
+      )
+    }
+  }
+
+  func testStartFailure() {
+    struct Failure: Error, Equatable {}
+    let failure = Failure()
+
+    var env: MessengerEnvironment = .unimplemented
+    env.backup.get = { nil }
+    env.e2e.get = {
+      var e2e: E2E = .unimplemented
+      e2e.getId.run = { 123 }
+      return e2e
+    }
+    env.ud.get = {
+      var ud: UserDiscovery = .unimplemented
+      ud.getId.run = { 321 }
+      return ud
+    }
+    env.backupCallbacks.registered = { UpdateBackupFunc { _ in  } }
+    env.initializeBackup.run = { _, _, _, _ in throw failure }
+    let start: MessengerStartBackup = .live(env)
+
+    XCTAssertThrowsError(try start(password: "", params: .stub)) { error in
+      XCTAssertNoDifference(error as NSError, failure as NSError)
+    }
+  }
+}

Tests/XXMessengerClientTests/Messenger/Functions/MessengerStopBackupTests.swift

+import CustomDump
+import XCTest
+import XXClient
+@testable import XXMessengerClient
+
+final class MessengerStopBackupTests: XCTestCase {
+  func testStop() throws {
+    var didStopBackup = 0
+    var didSetBackup: [Backup?] = []
+
+    var env: MessengerEnvironment = .unimplemented
+    env.backup.get = {
+      var backup: Backup = .unimplemented
+      backup.stop.run = { didStopBackup += 1 }
+      return backup
+    }
+    env.backup.set = { backup in
+      didSetBackup.append(backup)
+    }
+    let stop: MessengerStopBackup = .live(env)
+
+    try stop()
+
+    XCTAssertEqual(didStopBackup, 1)
+    XCTAssertEqual(didSetBackup.count, 1)
+    XCTAssertNil(didSetBackup.first as? Backup)
+  }
+
+  func testStopFailure() {
+    struct Failure: Error, Equatable {}
+    let failure = Failure()
+
+    var env: MessengerEnvironment = .unimplemented
+    env.backup.get = {
+      var backup: Backup = .unimplemented
+      backup.stop.run = { throw failure }
+      return backup
+    }
+    let stop: MessengerStopBackup = .live(env)
+
+    XCTAssertThrowsError(try stop()) { error in
+      XCTAssertNoDifference(error as NSError, failure as NSError)
+    }
+  }
+
+  func testStopWithoutBackup() throws {
+    var env: MessengerEnvironment = .unimplemented
+    env.backup.get = { nil }
+    let stop: MessengerStopBackup = .live(env)
+
+    try stop()
+  }
+}

Tests/XXMessengerClientTests/TestHelpers/StringData.swift

+import CustomDump
+import Foundation
+
+struct StringData: Equatable, CustomDumpStringConvertible {
+  var data: Data
+
+  var customDumpDescription: String {
+    if let string = String(data: data, encoding: .utf8) {
+      return #"Data(string: "\#(string)", encoding: .utf8)"#
+    } else {
+      return data.customDumpDescription
+    }
+  }
+}

Tests/XXMessengerClientTests/TestHelpers/Message+stubs.swift → Tests/XXMessengerClientTests/TestHelpers/TestDoubles.swift

 import XXClient
+import XXMessengerClient
 
 extension Message {
   static func stub(_ stubId: Int) -> Message {
@@ -16,3 +17,11 @@ extension Message {
     )
   }
 }
+
+extension BackupParams {
+  static let stub = BackupParams(
+    username: "stub-username",
+    email: "stub-email",
+    phone: "stub-phone"
+  )
+}