Merge branch 'feature/update-backup-params' into 'development'

Update backup params handling in XXMessenger

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

Examples/xx-messenger/Sources/BackupFeature/BackupComponent.swift

@@ -11,10 +11,6 @@ public struct BackupComponent: ReducerProtocol {
       case passphrase
     }
 
-    public enum Error: String, Swift.Error, Equatable {
-      case contactUsernameMissing
-    }
-
     public init(
       isRunning: Bool = false,
       isStarting: Bool = false,
@@ -102,14 +98,7 @@ public struct BackupComponent: ReducerProtocol {
         state.focusedField = nil
         return Effect.run { [state] subscriber in
           do {
-            let contact = try messenger.myContact(includeFacts: .types([.username]))
-            guard let username = try contact.getFact(.username)?.value else {
-              throw State.Error.contactUsernameMissing
-            }
-            try messenger.startBackup(
-              password: state.passphrase,
-              params: BackupParams(username: username)
-            )
+            try messenger.startBackup(password: state.passphrase)
             subscriber.send(.didStart(failure: nil))
           } catch {
             subscriber.send(.didStart(failure: error as NSError))

Examples/xx-messenger/Tests/BackupFeatureTests/BackupComponentTests.swift

@@ -63,7 +63,6 @@ final class BackupFeatureTests: XCTestCase {
   func testStartBackup() {
     var actions: [Action]!
     var isBackupRunning: [Bool] = [true]
-    let username = "test-username"
     let passphrase = "backup-password"
 
     let store = TestStore(
@@ -72,12 +71,6 @@ final class BackupFeatureTests: XCTestCase {
     )
     store.dependencies.app.mainQueue = .immediate
     store.dependencies.app.bgQueue = .immediate
-    store.dependencies.app.messenger.myContact.run = { includeFacts in
-      actions.append(.didGetMyContact(includingFacts: includeFacts))
-      var contact = Contact.unimplemented("contact-data".data(using: .utf8)!)
-      contact.getFactsFromContact.run = { _ in [Fact(type: .username, value: username)] }
-      return contact
-    }
     store.dependencies.app.messenger.startBackup.run = { passphrase, params in
       actions.append(.didStartBackup(passphrase: passphrase, params: params))
     }
@@ -102,12 +95,9 @@ final class BackupFeatureTests: XCTestCase {
     }
 
     XCTAssertNoDifference(actions, [
-      .didGetMyContact(
-        includingFacts: .types([.username])
-      ),
       .didStartBackup(
         passphrase: passphrase,
-        params: .init(username: username)
+        params: nil
       )
     ])
 
@@ -118,38 +108,6 @@ final class BackupFeatureTests: XCTestCase {
     }
   }
 
-  func testStartBackupWithoutContactUsername() {
-    var isBackupRunning: [Bool] = [false]
-
-    let store = TestStore(
-      initialState: BackupComponent.State(
-        passphrase: "1234"
-      ),
-      reducer: BackupComponent()
-    )
-    store.dependencies.app.mainQueue = .immediate
-    store.dependencies.app.bgQueue = .immediate
-    store.dependencies.app.messenger.myContact.run = { _ in
-      var contact = Contact.unimplemented("contact-data".data(using: .utf8)!)
-      contact.getFactsFromContact.run = { _ in [] }
-      return contact
-    }
-    store.dependencies.app.messenger.isBackupRunning.run = {
-      isBackupRunning.removeFirst()
-    }
-
-    store.send(.startTapped) {
-      $0.isStarting = true
-    }
-
-    let failure = BackupComponent.State.Error.contactUsernameMissing
-    store.receive(.didStart(failure: failure as NSError)) {
-      $0.isRunning = false
-      $0.isStarting = false
-      $0.alert = .error(failure)
-    }
-  }
-
   func testStartBackupMyContactFailure() {
     struct Failure: Error {}
     let failure = Failure()
@@ -163,7 +121,7 @@ final class BackupFeatureTests: XCTestCase {
     )
     store.dependencies.app.mainQueue = .immediate
     store.dependencies.app.bgQueue = .immediate
-    store.dependencies.app.messenger.myContact.run = { _ in throw failure }
+    store.dependencies.app.messenger.startBackup.run = { _, _ in throw failure }
     store.dependencies.app.messenger.isBackupRunning.run = {
       isBackupRunning.removeFirst()
     }
@@ -192,11 +150,6 @@ final class BackupFeatureTests: XCTestCase {
     )
     store.dependencies.app.mainQueue = .immediate
     store.dependencies.app.bgQueue = .immediate
-    store.dependencies.app.messenger.myContact.run = { _ in
-      var contact = Contact.unimplemented("data".data(using: .utf8)!)
-      contact.getFactsFromContact.run = { _ in [Fact(type: .username, value: "username")] }
-      return contact
-    }
     store.dependencies.app.messenger.startBackup.run = { _, _ in
       throw failure
     }
@@ -397,9 +350,8 @@ final class BackupFeatureTests: XCTestCase {
 
 private enum Action: Equatable {
   case didRegisterObserver
-  case didStartBackup(passphrase: String, params: BackupParams)
+  case didStartBackup(passphrase: String, params: String?)
   case didResumeBackup
   case didStopBackup
   case didRemoveBackup
-  case didGetMyContact(includingFacts: MessengerMyContact.IncludeFacts?)
 }

Examples/xx-messenger/Tests/RestoreFeatureTests/RestoreComponentTests.swift

@@ -82,7 +82,7 @@ final class RestoreComponentTests: XCTestCase {
       Fact(type: .phone, value: "restored-fact-phone"),
     ]
     let restoreResult = MessengerRestoreBackup.Result(
-      restoredParams: BackupParams(username: "restored-param-username"),
+      restoredParams: "",
       restoredContacts: [
         "contact-1-id".data(using: .utf8)!,
         "contact-2-id".data(using: .utf8)!,

Sources/XXMessengerClient/Messenger/Functions/MessengerBackupParams.swift

@@ -6,9 +6,9 @@ public struct MessengerBackupParams {
     case notRunning
   }
 
-  public var run: (BackupParams) throws -> Void
+  public var run: (String) throws -> Void
 
-  public func callAsFunction(_ params: BackupParams) throws {
+  public func callAsFunction(_ params: String) throws {
     try run(params)
   }
 }
@@ -19,9 +19,7 @@ extension MessengerBackupParams {
       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)
+      backup.addJSON(params)
     }
   }
 }

Sources/XXMessengerClient/Messenger/Functions/MessengerRestoreBackup.swift

@@ -5,14 +5,14 @@ import XCTestDynamicOverlay
 public struct MessengerRestoreBackup {
   public struct Result: Equatable {
     public init(
-      restoredParams: BackupParams,
+      restoredParams: String,
       restoredContacts: [Data]
     ) {
       self.restoredParams = restoredParams
       self.restoredContacts = restoredContacts
     }
 
-    public var restoredParams: BackupParams
+    public var restoredParams: String
     public var restoredContacts: [Data]
   }
 
@@ -42,8 +42,6 @@ extension MessengerRestoreBackup {
         sessionPassword: password,
         backupFileContents: backupData
       )
-      let paramsData = report.params.data(using: .utf8)!
-      let params = try BackupParams.decode(paramsData)
       let cMix = try env.loadCMix(
         storageDir: storageDir,
         password: password,
@@ -68,7 +66,7 @@ extension MessengerRestoreBackup {
       )
       env.ud.set(ud)
       return Result(
-        restoredParams: params,
+        restoredParams: report.params,
         restoredContacts: report.restoredContacts
       )
     }

Sources/XXMessengerClient/Messenger/Functions/MessengerStartBackup.swift

@@ -9,11 +9,11 @@ public struct MessengerStartBackup {
     case notLoggedIn
   }
 
-  public var run: (String, BackupParams) throws -> Void
+  public var run: (String, String?) throws -> Void
 
   public func callAsFunction(
     password: String,
-    params: BackupParams
+    params: String? = nil
   ) throws {
     try run(password, params)
   }
@@ -31,8 +31,6 @@ 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
       var semaphore: DispatchSemaphore? = .init(value: 0)
       let backup = try env.initializeBackup(
@@ -41,9 +39,9 @@ extension MessengerStartBackup {
         password: password,
         callback: .init { data in
           semaphore?.wait()
-          if !didAddParams {
+          if let params, !didAddParams {
             if let backup = env.backup() {
-              backup.addJSON(paramsString)
+              backup.addJSON(params)
               didAddParams = true
             }
           } else {

Sources/XXMessengerClient/Utils/BackupParams.swift

-import Foundation
-
-public struct BackupParams: Equatable {
-  public init(
-    username: String
-  ) {
-    self.username = username
-  }
-
-  public var username: 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

@@ -6,6 +6,7 @@ import XXClient
 final class MessengerBackupParamsTests: XCTestCase {
   func testBackupParams() throws {
     var didAddJSON: [String] = []
+    let params = "test-123"
 
     var env: MessengerEnvironment = .unimplemented
     env.backup.get = {
@@ -16,11 +17,9 @@ final class MessengerBackupParamsTests: XCTestCase {
     }
     let backup: MessengerBackupParams = .live(env)
 
-    try backup(.stub)
+    try backup(params)
 
-    XCTAssertNoDifference(didAddJSON, [
-      String(data: try BackupParams.stub.encode(), encoding: .utf8)!
-    ])
+    XCTAssertNoDifference(didAddJSON, [params])
   }
 
   func testBackupParamsWhenNoBackup() {
@@ -28,7 +27,7 @@ final class MessengerBackupParamsTests: XCTestCase {
     env.backup.get = { nil }
     let backup: MessengerBackupParams = .live(env)
 
-    XCTAssertThrowsError(try backup(.stub)) { error in
+    XCTAssertThrowsError(try backup("")) { error in
       XCTAssertNoDifference(
         error as NSError,
         MessengerBackupParams.Error.notRunning as NSError
@@ -45,7 +44,7 @@ final class MessengerBackupParamsTests: XCTestCase {
     }
     let backup: MessengerBackupParams = .live(env)
 
-    XCTAssertThrowsError(try backup(.stub)) { error in
+    XCTAssertThrowsError(try backup("")) { error in
       XCTAssertNoDifference(
         error as NSError,
         MessengerBackupParams.Error.notRunning as NSError

Tests/XXMessengerClientTests/Messenger/Functions/MessengerRestoreBackupTests.swift

@@ -10,10 +10,9 @@ final class MessengerRestoreBackupTests: XCTestCase {
     let ndfData = "ndf-data".data(using: .utf8)!
     let password = "password".data(using: .utf8)!
     let backupContacts: [Data] = (1...3).map { "contact-\($0)" }.map { $0.data(using: .utf8)! }
-    let backupParams = BackupParams.stub
     let backupReport = BackupReport(
       restoredContacts: backupContacts,
-      params: String(data: try! JSONEncoder().encode(backupParams), encoding: .utf8)!
+      params: "backup-report-params"
     )
     let cMixParams = "cmix-params".data(using: .utf8)!
     let e2eParams = "e2e-params".data(using: .utf8)!
@@ -157,7 +156,7 @@ final class MessengerRestoreBackupTests: XCTestCase {
     ])
 
     XCTAssertNoDifference(result, MessengerRestoreBackup.Result(
-      restoredParams: backupParams,
+      restoredParams: backupReport.params,
       restoredContacts: backupContacts
     ))
   }

Tests/XXMessengerClientTests/Messenger/Functions/MessengerStartBackupTests.swift

@@ -4,7 +4,7 @@ import XXClient
 @testable import XXMessengerClient
 
 final class MessengerStartBackupTests: XCTestCase {
-  func testStart() throws {
+  func testStartWithParams() throws {
     struct InitBackupParams: Equatable {
       var e2eId: Int
       var udId: Int
@@ -16,6 +16,7 @@ final class MessengerStartBackupTests: XCTestCase {
     var didSetBackup: [Backup?] = []
     var didAddJSON: [String] = []
 
+    let params = "backup-params"
     let password = "test-password"
     let e2eId = 123
     let udId = 321
@@ -49,7 +50,7 @@ final class MessengerStartBackupTests: XCTestCase {
     }
     let start: MessengerStartBackup = .live(env)
 
-    try start(password: password, params: .stub)
+    try start(password: password, params: params)
 
     XCTAssertNoDifference(didInitializeBackup, [
       .init(e2eId: e2eId, udId: udId, password: password)
@@ -62,9 +63,7 @@ final class MessengerStartBackupTests: XCTestCase {
       didHandleCallback.map(StringData.init),
       [].map(StringData.init)
     )
-    XCTAssertNoDifference(didAddJSON, [
-      String(data: try BackupParams.stub.encode(), encoding: .utf8)!
-    ])
+    XCTAssertNoDifference(didAddJSON, [params])
 
     backupCallbacks.forEach { $0.handle(dataWithParams) }
 
@@ -74,6 +73,60 @@ final class MessengerStartBackupTests: XCTestCase {
     )
   }
 
+  func testStartWithoutParams() 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?] = []
+
+    let password = "test-password"
+    let e2eId = 123
+    let udId = 321
+    let dataWithoutParams = "backup-without-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)
+      return .unimplemented
+    }
+    let start: MessengerStartBackup = .live(env)
+
+    try start(password: password)
+
+    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),
+      [dataWithoutParams].map(StringData.init)
+    )
+  }
+
   func testStartWhenRunning() {
     var env: MessengerEnvironment = .unimplemented
     env.backup.get = {
@@ -83,7 +136,7 @@ final class MessengerStartBackupTests: XCTestCase {
     }
     let start: MessengerStartBackup = .live(env)
 
-    XCTAssertThrowsError(try start(password: "", params: .stub)) { error in
+    XCTAssertThrowsError(try start(password: "")) { error in
       XCTAssertNoDifference(
         error as NSError,
         MessengerStartBackup.Error.isRunning as NSError
@@ -97,7 +150,7 @@ final class MessengerStartBackupTests: XCTestCase {
     env.e2e.get = { nil }
     let start: MessengerStartBackup = .live(env)
 
-    XCTAssertThrowsError(try start(password: "", params: .stub)) { error in
+    XCTAssertThrowsError(try start(password: "")) { error in
       XCTAssertNoDifference(
         error as NSError,
         MessengerStartBackup.Error.notConnected as NSError
@@ -112,7 +165,7 @@ final class MessengerStartBackupTests: XCTestCase {
     env.ud.get = { nil }
     let start: MessengerStartBackup = .live(env)
 
-    XCTAssertThrowsError(try start(password: "", params: .stub)) { error in
+    XCTAssertThrowsError(try start(password: "")) { error in
       XCTAssertNoDifference(
         error as NSError,
         MessengerStartBackup.Error.notLoggedIn as NSError
@@ -140,7 +193,7 @@ final class MessengerStartBackupTests: XCTestCase {
     env.initializeBackup.run = { _, _, _, _ in throw failure }
     let start: MessengerStartBackup = .live(env)
 
-    XCTAssertThrowsError(try start(password: "", params: .stub)) { error in
+    XCTAssertThrowsError(try start(password: "")) { error in
       XCTAssertNoDifference(error as NSError, failure as NSError)
     }
   }

Tests/XXMessengerClientTests/TestHelpers/TestDoubles.swift

@@ -18,12 +18,6 @@ extension Message {
   }
 }
 
-extension BackupParams {
-  static let stub = BackupParams(
-    username: "stub-username"
-  )
-}
-
 extension ReceivedFile {
   static func stub(_ id: Int) -> ReceivedFile {
     ReceivedFile(