Update MessengerStartBackup function

- When first data arrive, ignore it and add params to the backup
- When following data arrive (that included params), handle it

Docs/XXMessengerClient.md

@@ -117,11 +117,15 @@ if messenger.isBackupRunning() == false {
     try messenger.resumeBackup()
   } catch {
     // try to start a new backup:
-    try messenger.startBackup(password: "backup-passphrase")
+    let params: BackupParams = ...
+    try messenger.startBackup(
+      password: "backup-passphrase",
+      params: params
+    )
   }
 }
 
-// add backup params to the backup:
+// update params in the backup:
 let params: BackupParams = ...
 try messenger.backupParams(params)
 
@@ -132,6 +136,8 @@ try messenger.stopBackup()
 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:

Sources/XXMessengerClient/Messenger/Functions/MessengerStartBackup.swift

@@ -8,16 +8,19 @@ public struct MessengerStartBackup {
     case notLoggedIn
   }
 
-  public var run: (String) throws -> Void
+  public var run: (String, BackupParams) throws -> Void
 
-  public func callAsFunction(password: String) throws {
-    try run(password)
+  public func callAsFunction(
+    password: String,
+    params: BackupParams
+  ) throws {
+    try run(password, params)
   }
 }
 
 extension MessengerStartBackup {
   public static func live(_ env: MessengerEnvironment) -> MessengerStartBackup {
-    MessengerStartBackup { password in
+    MessengerStartBackup { password, params in
       guard env.backup()?.isRunning() != true else {
         throw Error.isRunning
       }
@@ -27,11 +30,25 @@ extension MessengerStartBackup {
       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: env.backupCallbacks.registered()
+        callback: .init { data in
+          if !didAddParams {
+            addParams()
+          } else {
+            env.backupCallbacks.registered().handle(data)
+          }
+        }
       )
       env.backup.set(backup)
     }

Tests/XXMessengerClientTests/Messenger/Functions/MessengerStartBackupTests.swift

@@ -14,14 +14,16 @@ final class MessengerStartBackupTests: XCTestCase {
     var backupCallbacks: [UpdateBackupFunc] = []
     var didHandleCallback: [Data] = []
     var didSetBackup: [Backup?] = []
+    var didAddJSON: [String] = []
 
     let password = "test-password"
     let e2eId = 123
     let udId = 321
-    let data = "test-data".data(using: .utf8)!
+    let dataWithoutParams = "backup-without-params".data(using: .utf8)!
+    let dataWithParams = "backup-with-params".data(using: .utf8)!
 
     var env: MessengerEnvironment = .unimplemented
-    env.backup.get = { nil }
+    env.backup.get = { didSetBackup.last as? Backup }
     env.backup.set = { didSetBackup.append($0) }
     env.e2e.get = {
       var e2e: E2E = .unimplemented
@@ -39,20 +41,37 @@ final class MessengerStartBackupTests: XCTestCase {
     env.initializeBackup.run = { e2eId, udId, password, callback in
       didInitializeBackup.append(.init(e2eId: e2eId, udId: udId, password: password))
       backupCallbacks.append(callback)
-      return .unimplemented
+      var backup: Backup = .unimplemented
+      backup.addJSON.run = { string in
+        didAddJSON.append(string)
+      }
+      return backup
     }
     let start: MessengerStartBackup = .live(env)
 
-    try start(password: password)
+    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(data) }
+    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, [data])
+    XCTAssertNoDifference(
+      didHandleCallback.map(StringData.init),
+      [dataWithParams].map(StringData.init)
+    )
   }
 
   func testStartWhenRunning() {
@@ -64,7 +83,7 @@ final class MessengerStartBackupTests: XCTestCase {
     }
     let start: MessengerStartBackup = .live(env)
 
-    XCTAssertThrowsError(try start(password: "")) { error in
+    XCTAssertThrowsError(try start(password: "", params: .stub)) { error in
       XCTAssertNoDifference(
         error as NSError,
         MessengerStartBackup.Error.isRunning as NSError
@@ -78,7 +97,7 @@ final class MessengerStartBackupTests: XCTestCase {
     env.e2e.get = { nil }
     let start: MessengerStartBackup = .live(env)
 
-    XCTAssertThrowsError(try start(password: "")) { error in
+    XCTAssertThrowsError(try start(password: "", params: .stub)) { error in
       XCTAssertNoDifference(
         error as NSError,
         MessengerStartBackup.Error.notConnected as NSError
@@ -93,7 +112,7 @@ final class MessengerStartBackupTests: XCTestCase {
     env.ud.get = { nil }
     let start: MessengerStartBackup = .live(env)
 
-    XCTAssertThrowsError(try start(password: "")) { error in
+    XCTAssertThrowsError(try start(password: "", params: .stub)) { error in
       XCTAssertNoDifference(
         error as NSError,
         MessengerStartBackup.Error.notLoggedIn as NSError
@@ -121,7 +140,7 @@ final class MessengerStartBackupTests: XCTestCase {
     env.initializeBackup.run = { _, _, _, _ in throw failure }
     let start: MessengerStartBackup = .live(env)
 
-    XCTAssertThrowsError(try start(password: "abcd")) { error in
+    XCTAssertThrowsError(try start(password: "", params: .stub)) { error in
       XCTAssertNoDifference(error as NSError, failure as NSError)
     }
   }

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"
+  )
+}