Update the SDK adopting new power levels APIs. (#2545)

* Update the SDK adopting new power levels APIs.

* Fix test compilation error.

ElementX.xcodeproj/project.pbxproj

@@ -7120,7 +7120,7 @@
 			repositoryURL = "https://github.com/matrix-org/matrix-rust-components-swift";
 			requirement = {
 				kind = exactVersion;
-				version = 1.1.46;
+				version = 1.1.47;
 			};
 		};
 		821C67C9A7F8CC3FD41B28B4 /* XCRemoteSwiftPackageReference "emojibase-bindings" */ = {

ElementX.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved

@@ -130,8 +130,8 @@
       "kind" : "remoteSourceControl",
       "location" : "https://github.com/matrix-org/matrix-rust-components-swift",
       "state" : {
-        "revision" : "f0b060274251263c6470d90d5877af2856c0da14",
+        "revision" : "57931f2aca93dab50cb86352081a6cdd6cdcf61b",
-        "version" : "1.1.46"
+        "version" : "1.1.47"
       }
     },
     {

ElementX/Sources/FlowCoordinators/RoomRolesAndPermissionsFlowCoordinator.swift

@@ -131,7 +131,7 @@ class RoomRolesAndPermissionsFlowCoordinator: FlowCoordinatorProtocol {
             case .editRoles(let role):
                 stateMachine.tryEvent(.changeRoles, userInfo: role)
             case .editPermissions(let group):
-                stateMachine.tryEvent(.changePermissions, userInfo: (group, RoomPermissions.default))
+                stateMachine.tryEvent(.changePermissions, userInfo: (group, RoomPermissions(powerLevels: .mock)))
             }
         }
         .store(in: &cancellables)

ElementX/Sources/Mocks/Generated/GeneratedMocks.swift

@@ -2712,21 +2712,21 @@ class RoomProxyMock: RoomProxyProtocol {
             return flagAsFavouriteReturnValue
         }
     }
-    //MARK: - currentPowerLevelChanges
+    //MARK: - powerLevels
 
-    var currentPowerLevelChangesCallsCount = 0
+    var powerLevelsCallsCount = 0
-    var currentPowerLevelChangesCalled: Bool {
+    var powerLevelsCalled: Bool {
-        return currentPowerLevelChangesCallsCount > 0
+        return powerLevelsCallsCount > 0
     }
-    var currentPowerLevelChangesReturnValue: Result<RoomPowerLevelChanges, RoomProxyError>!
+    var powerLevelsReturnValue: Result<RoomPowerLevels, RoomProxyError>!
-    var currentPowerLevelChangesClosure: (() async -> Result<RoomPowerLevelChanges, RoomProxyError>)?
+    var powerLevelsClosure: (() async -> Result<RoomPowerLevels, RoomProxyError>)?
 
-    func currentPowerLevelChanges() async -> Result<RoomPowerLevelChanges, RoomProxyError> {
+    func powerLevels() async -> Result<RoomPowerLevels, RoomProxyError> {
-        currentPowerLevelChangesCallsCount += 1
+        powerLevelsCallsCount += 1
-        if let currentPowerLevelChangesClosure = currentPowerLevelChangesClosure {
+        if let powerLevelsClosure = powerLevelsClosure {
-            return await currentPowerLevelChangesClosure()
+            return await powerLevelsClosure()
         } else {
-            return currentPowerLevelChangesReturnValue
+            return powerLevelsReturnValue
         }
     }
     //MARK: - applyPowerLevelChanges

ElementX/Sources/Mocks/RoomProxyMock.swift

@@ -88,7 +88,7 @@ extension RoomProxyMock {
         underlyingIsFavourite = false
         flagAsFavouriteReturnValue = .success(())
         
-        currentPowerLevelChangesReturnValue = .success(.init())
+        powerLevelsReturnValue = .success(.mock)
         applyPowerLevelChangesReturnValue = .success(())
         updatePowerLevelsForUsersReturnValue = .success(())
         canUserUserIDSendStateEventClosure = { [weak self] userID, _ in

ElementX/Sources/Screens/RoomChangePermissionsScreen/RoomChangePermissionsScreenModels.swift

@@ -31,7 +31,7 @@ struct RoomChangePermissionsScreenViewState: BindableState {
     
     /// Whether or not there are and changes to be saved.
     var hasChanges: Bool {
-        bindings.settings.contains { currentPermissions[keyPath: $0.keyPath] ?? RoomPermissions.defaultValue(for: $0.keyPath) != $0.value }
+        bindings.settings.contains { currentPermissions[keyPath: $0.keyPath] != $0.value }
     }
 }
 
@@ -61,42 +61,42 @@ extension RoomChangePermissionsScreenViewState {
         switch group {
         case .roomDetails:
             let settings = [
-                RoomPermissionsSetting(keyPath: \.roomName,
+                RoomPermissionsSetting(title: L10n.screenRoomChangePermissionsRoomName,
-                                       value: currentPermissions.roomName ?? RoomPermissions.defaultValue(for: \.roomName),
+                                       value: currentPermissions.roomName,
-                                       title: L10n.screenRoomChangePermissionsRoomName),
+                                       keyPath: \.roomName),
-                RoomPermissionsSetting(keyPath: \.roomAvatar,
+                RoomPermissionsSetting(title: L10n.screenRoomChangePermissionsRoomAvatar,
-                                       value: currentPermissions.roomAvatar ?? RoomPermissions.defaultValue(for: \.roomAvatar),
+                                       value: currentPermissions.roomAvatar,
-                                       title: L10n.screenRoomChangePermissionsRoomAvatar),
+                                       keyPath: \.roomAvatar),
-                RoomPermissionsSetting(keyPath: \.roomTopic,
+                RoomPermissionsSetting(title: L10n.screenRoomChangePermissionsRoomTopic,
-                                       value: currentPermissions.roomTopic ?? RoomPermissions.defaultValue(for: \.roomTopic),
+                                       value: currentPermissions.roomTopic,
-                                       title: L10n.screenRoomChangePermissionsRoomTopic)
+                                       keyPath: \.roomTopic)
             ]
             
             self.init(title: L10n.screenRoomChangePermissionsRoomDetails, currentPermissions: currentPermissions, bindings: .init(settings: settings))
         
         case .messagesAndContent:
             let settings = [
-                RoomPermissionsSetting(keyPath: \.eventsDefault,
+                RoomPermissionsSetting(title: L10n.screenRoomChangePermissionsSendMessages,
-                                       value: currentPermissions.eventsDefault ?? RoomPermissions.defaultValue(for: \.eventsDefault),
+                                       value: currentPermissions.eventsDefault,
-                                       title: L10n.screenRoomChangePermissionsSendMessages),
+                                       keyPath: \.eventsDefault),
-                RoomPermissionsSetting(keyPath: \.redact,
+                RoomPermissionsSetting(title: L10n.screenRoomChangePermissionsDeleteMessages,
-                                       value: currentPermissions.redact ?? RoomPermissions.defaultValue(for: \.redact),
+                                       value: currentPermissions.redact,
-                                       title: L10n.screenRoomChangePermissionsDeleteMessages)
+                                       keyPath: \.redact)
             ]
             
             self.init(title: L10n.screenRoomChangePermissionsMessagesAndContent, currentPermissions: currentPermissions, bindings: .init(settings: settings))
         
         case .memberModeration:
             let settings = [
-                RoomPermissionsSetting(keyPath: \.invite,
+                RoomPermissionsSetting(title: L10n.screenRoomChangePermissionsInvitePeople,
-                                       value: currentPermissions.invite ?? RoomPermissions.defaultValue(for: \.invite),
+                                       value: currentPermissions.invite,
-                                       title: L10n.screenRoomChangePermissionsInvitePeople),
+                                       keyPath: \.invite),
-                RoomPermissionsSetting(keyPath: \.kick,
+                RoomPermissionsSetting(title: L10n.screenRoomChangePermissionsRemovePeople,
-                                       value: currentPermissions.kick ?? RoomPermissions.defaultValue(for: \.kick),
+                                       value: currentPermissions.kick,
-                                       title: L10n.screenRoomChangePermissionsRemovePeople),
+                                       keyPath: \.kick),
-                RoomPermissionsSetting(keyPath: \.ban,
+                RoomPermissionsSetting(title: L10n.screenRoomChangePermissionsBanPeople,
-                                       value: currentPermissions.ban ?? RoomPermissions.defaultValue(for: \.ban),
+                                       value: currentPermissions.ban,
-                                       title: L10n.screenRoomChangePermissionsBanPeople)
+                                       keyPath: \.ban)
             ]
             
             self.init(title: L10n.screenRoomChangePermissionsMemberModeration, currentPermissions: currentPermissions, bindings: .init(settings: settings))

ElementX/Sources/Screens/RoomChangePermissionsScreen/RoomChangePermissionsScreenViewModel.swift

@@ -15,6 +15,7 @@
 //
 
 import Combine
+import MatrixRustSDK
 import SwiftUI
 
 typealias RoomChangePermissionsScreenViewModelType = StateStoreViewModel<RoomChangePermissionsScreenViewState, RoomChangePermissionsScreenViewAction>
@@ -62,12 +63,12 @@ class RoomChangePermissionsScreenViewModel: RoomChangePermissionsScreenViewModel
             hideLoadingIndicator()
         }
         
-        var updatedPermissions = RoomPermissions()
+        var changes = RoomPowerLevelChanges()
         for setting in state.bindings.settings {
-            updatedPermissions[keyPath: setting.keyPath] = setting.value
+            changes[keyPath: setting.rustKeyPath] = setting.value.rustPowerLevel
         }
         
-        switch await roomProxy.applyPowerLevelChanges(updatedPermissions.makePowerLevelChanges()) {
+        switch await roomProxy.applyPowerLevelChanges(changes) {
         case .success:
             MXLog.info("Success")
         case .failure:
@@ -75,9 +76,9 @@ class RoomChangePermissionsScreenViewModel: RoomChangePermissionsScreenViewModel
             return
         }
         
-        switch await roomProxy.currentPowerLevelChanges() {
+        switch await roomProxy.powerLevels() {
-        case .success(let powerLevelChanges):
+        case .success(let powerLevels):
-            state.currentPermissions = .init(powerLevelChanges: powerLevelChanges)
+            state.currentPermissions = .init(powerLevels: powerLevels)
         case .failure:
             context.alertInfo = AlertInfo(id: .generic)
             return

ElementX/Sources/Screens/RoomChangePermissionsScreen/View/RoomChangePermissionsScreen.swift

@@ -75,7 +75,7 @@ struct RoomChangePermissionsScreen_Previews: PreviewProvider, TestablePreview {
     }
     
     static func makeViewModel(group: RoomRolesAndPermissionsScreenPermissionsGroup) -> RoomChangePermissionsScreenViewModel {
-        RoomChangePermissionsScreenViewModel(currentPermissions: .default,
+        RoomChangePermissionsScreenViewModel(currentPermissions: .init(powerLevels: .mock),
                                              group: group,
                                              roomProxy: RoomProxyMock(with: .init()),
                                              userIndicatorController: UserIndicatorControllerMock())

ElementX/Sources/Services/Room/RoomPermissions.swift

@@ -18,12 +18,14 @@ import Foundation
 import MatrixRustSDK
 
 struct RoomPermissionsSetting: Identifiable {
-    var id: KeyPath<RoomPermissions, RoomMemberDetails.Role?> { keyPath }
+    var id: KeyPath<RoomPermissions, RoomMemberDetails.Role> { keyPath }
     
-    let keyPath: WritableKeyPath<RoomPermissions, RoomMemberDetails.Role?>
+    /// The title of this setting.
-    var value: RoomMemberDetails.Role
     let title: String
     
+    /// The selected role of this setting.
+    var value: RoomMemberDetails.Role
+    /// All of the available roles that this setting can be configured with.
     var allValues: [(title: String, tag: RoomMemberDetails.Role)] {
         [
             (title: L10n.screenRoomChangePermissionsAdministrators, tag: .administrator),
@@ -31,87 +33,63 @@ struct RoomPermissionsSetting: Identifiable {
             (title: L10n.screenRoomChangePermissionsEveryone, tag: .user)
         ]
     }
+    
+    /// The `RoomPermissions` property that this setting is for.
+    let keyPath: KeyPath<RoomPermissions, RoomMemberDetails.Role>
+    /// The `RoomPowerLevelChanges` property that this setting is saved into.
+    var rustKeyPath: WritableKeyPath<RoomPowerLevelChanges, Int64?> {
+        switch keyPath {
+        case \.ban: \.ban
+        case \.invite: \.invite
+        case \.kick: \.kick
+        case \.redact: \.redact
+        case \.eventsDefault: \.eventsDefault
+        case \.stateDefault: \.stateDefault
+        case \.usersDefault: \.usersDefault
+        case \.roomName: \.roomName
+        case \.roomAvatar: \.roomAvatar
+        case \.roomTopic: \.roomTopic
+        default: fatalError("Unexpected key path: \(keyPath)")
+        }
+    }
 }
 
 struct RoomPermissions {
     /// The level required to ban a user.
-    var ban: RoomMemberDetails.Role?
+    var ban: RoomMemberDetails.Role
     /// The level required to invite a user.
-    var invite: RoomMemberDetails.Role?
+    var invite: RoomMemberDetails.Role
     /// The level required to kick a user.
-    var kick: RoomMemberDetails.Role?
+    var kick: RoomMemberDetails.Role
     /// The level required to redact an event.
-    var redact: RoomMemberDetails.Role?
+    var redact: RoomMemberDetails.Role
     /// The default level required to send message events.
-    var eventsDefault: RoomMemberDetails.Role?
+    var eventsDefault: RoomMemberDetails.Role
     /// The default level required to send state events.
-    var stateDefault: RoomMemberDetails.Role?
+    var stateDefault: RoomMemberDetails.Role
     /// The default power level for every user in the room.
-    var usersDefault: RoomMemberDetails.Role?
+    var usersDefault: RoomMemberDetails.Role
     /// The level required to change the room's name.
-    var roomName: RoomMemberDetails.Role?
+    var roomName: RoomMemberDetails.Role
     /// The level required to change the room's avatar.
-    var roomAvatar: RoomMemberDetails.Role?
+    var roomAvatar: RoomMemberDetails.Role
     /// The level required to change the room's topic.
-    var roomTopic: RoomMemberDetails.Role?
+    var roomTopic: RoomMemberDetails.Role
 }
 
 extension RoomPermissions {
-    /// Returns the default value for a particular permission.
+    /// Create permissions from the room's power levels.
-    static func defaultValue(for keyPath: KeyPath<RoomPermissions, RoomMemberDetails.Role?>) -> RoomMemberDetails.Role {
+    init(powerLevels: RoomPowerLevels) {
-        switch keyPath {
+        ban = RoomMemberDetails.Role(rustPowerLevel: powerLevels.ban)
-        case \.ban: .moderator
+        invite = RoomMemberDetails.Role(rustPowerLevel: powerLevels.invite)
-        case \.invite: .user
+        kick = RoomMemberDetails.Role(rustPowerLevel: powerLevels.kick)
-        case \.kick: .moderator
+        redact = RoomMemberDetails.Role(rustPowerLevel: powerLevels.redact)
-        case \.redact: .moderator
+        eventsDefault = RoomMemberDetails.Role(rustPowerLevel: powerLevels.eventsDefault)
-        case \.eventsDefault: .user
+        stateDefault = RoomMemberDetails.Role(rustPowerLevel: powerLevels.stateDefault)
-        case \.stateDefault: .moderator
+        usersDefault = RoomMemberDetails.Role(rustPowerLevel: powerLevels.usersDefault)
-        case \.usersDefault: .user
+        roomName = RoomMemberDetails.Role(rustPowerLevel: powerLevels.roomName)
-        case \.roomName: .moderator
+        roomAvatar = RoomMemberDetails.Role(rustPowerLevel: powerLevels.roomAvatar)
-        case \.roomAvatar: .moderator
+        roomTopic = RoomMemberDetails.Role(rustPowerLevel: powerLevels.roomTopic)
-        case \.roomTopic: .moderator
-        default: fatalError("Unexpected key path: \(keyPath)")
-        }
-    }
-    
-    /// Constructs a set of permissions using the default values.
-    static var `default`: RoomPermissions {
-        RoomPermissions(ban: defaultValue(for: \.ban),
-                        invite: defaultValue(for: \.invite),
-                        kick: defaultValue(for: \.kick),
-                        redact: defaultValue(for: \.redact),
-                        eventsDefault: defaultValue(for: \.eventsDefault),
-                        stateDefault: defaultValue(for: \.stateDefault),
-                        usersDefault: defaultValue(for: \.usersDefault),
-                        roomName: defaultValue(for: \.roomName),
-                        roomAvatar: defaultValue(for: \.roomAvatar),
-                        roomTopic: defaultValue(for: \.roomTopic))
-    }
-    
-    init(powerLevelChanges: RoomPowerLevelChanges) {
-        ban = powerLevelChanges.ban.map(RoomMemberDetails.Role.init)
-        invite = powerLevelChanges.invite.map(RoomMemberDetails.Role.init)
-        kick = powerLevelChanges.kick.map(RoomMemberDetails.Role.init)
-        redact = powerLevelChanges.redact.map(RoomMemberDetails.Role.init)
-        eventsDefault = powerLevelChanges.eventsDefault.map(RoomMemberDetails.Role.init)
-        stateDefault = powerLevelChanges.stateDefault.map(RoomMemberDetails.Role.init)
-        usersDefault = powerLevelChanges.usersDefault.map(RoomMemberDetails.Role.init)
-        roomName = powerLevelChanges.roomName.map(RoomMemberDetails.Role.init)
-        roomAvatar = powerLevelChanges.roomAvatar.map(RoomMemberDetails.Role.init)
-        roomTopic = powerLevelChanges.roomTopic.map(RoomMemberDetails.Role.init)
-    }
-    
-    func makePowerLevelChanges() -> RoomPowerLevelChanges {
-        RoomPowerLevelChanges(ban: ban?.rustPowerLevel,
-                              invite: invite?.rustPowerLevel,
-                              kick: kick?.rustPowerLevel,
-                              redact: redact?.rustPowerLevel,
-                              eventsDefault: eventsDefault?.rustPowerLevel,
-                              stateDefault: stateDefault?.rustPowerLevel,
-                              usersDefault: usersDefault?.rustPowerLevel,
-                              roomName: roomName?.rustPowerLevel,
-                              roomAvatar: roomAvatar?.rustPowerLevel,
-                              roomTopic: roomTopic?.rustPowerLevel)
     }
 }
 
@@ -135,3 +113,18 @@ extension RoomMemberDetails.Role {
         suggestedPowerLevelForRole(role: rustRole)
     }
 }
+
+extension RoomPowerLevels {
+    static var mock: RoomPowerLevels {
+        RoomPowerLevels(ban: 50,
+                        invite: 0,
+                        kick: 50,
+                        redact: 50,
+                        eventsDefault: 0,
+                        stateDefault: 50,
+                        usersDefault: 0,
+                        roomName: 50,
+                        roomAvatar: 50,
+                        roomTopic: 50)
+    }
+}

ElementX/Sources/Services/Room/RoomProxy.swift

@@ -373,9 +373,9 @@ class RoomProxy: RoomProxyProtocol {
     
     // MARK: - Power Levels
     
-    func currentPowerLevelChanges() async -> Result<RoomPowerLevelChanges, RoomProxyError> {
+    func powerLevels() async -> Result<RoomPowerLevels, RoomProxyError> {
         do {
-            return try await .success(room.buildPowerLevelChangesFromCurrent())
+            return try await .success(room.getPowerLevels())
         } catch {
             MXLog.error("Failed building the current power level settings: \(error)")
             return .failure(.failedCheckingPermission)

ElementX/Sources/Services/Room/RoomProxyProtocol.swift

@@ -115,7 +115,7 @@ protocol RoomProxyProtocol {
     
     // MARK: - Power Levels
     
-    func currentPowerLevelChanges() async -> Result<RoomPowerLevelChanges, RoomProxyError>
+    func powerLevels() async -> Result<RoomPowerLevels, RoomProxyError>
     func applyPowerLevelChanges(_ changes: RoomPowerLevelChanges) async -> Result<Void, RoomProxyError>
     func updatePowerLevelsForUsers(_ updates: [(userID: String, powerLevel: Int64)]) async -> Result<Void, RoomProxyError>
     func canUser(userID: String, sendStateEvent event: StateEventType) async -> Result<Bool, RoomProxyError>

UnitTests/Sources/RoomChangePermissionsScreenViewModelTests.swift

@@ -29,7 +29,7 @@ class RoomChangePermissionsScreenViewModelTests: XCTestCase {
     
     override func setUp() {
         roomProxy = RoomProxyMock(with: .init())
-        viewModel = RoomChangePermissionsScreenViewModel(currentPermissions: .init(),
+        viewModel = RoomChangePermissionsScreenViewModel(currentPermissions: .init(powerLevels: .mock),
                                                          group: .roomDetails,
                                                          roomProxy: roomProxy,
                                                          userIndicatorController: UserIndicatorControllerMock())
@@ -45,7 +45,7 @@ class RoomChangePermissionsScreenViewModelTests: XCTestCase {
         XCTAssertFalse(context.viewState.hasChanges)
         
         // When updating a setting.
-        let setting = RoomPermissionsSetting(keyPath: \.roomAvatar, value: .user, title: "")
+        let setting = RoomPermissionsSetting(title: "", value: .user, keyPath: \.roomAvatar)
         context.settings[index] = setting
         
         // Then the setting should update and the changes should be flagged.
@@ -59,7 +59,7 @@ class RoomChangePermissionsScreenViewModelTests: XCTestCase {
             XCTFail("There should be a setting for the room avatar.")
             return
         }
-        context.settings[index] = RoomPermissionsSetting(keyPath: \.roomAvatar, value: .user, title: "")
+        context.settings[index] = RoomPermissionsSetting(title: "", value: .user, keyPath: \.roomAvatar)
         XCTAssertEqual(context.settings[index].value, .user)
         XCTAssertTrue(context.viewState.hasChanges)
         

UnitTests/Sources/RoomPermissionsTests.swift

@@ -20,72 +20,32 @@ import XCTest
 @testable import ElementX
 
 class RoomPermissionsTests: XCTestCase {
-    func testEmptyFromRust() {
+    func testFromRust() {
-        // Given an empty set of power level changes.
+        // Given a set of power level changes with various values.
-        let powerLevelChanges = RoomPowerLevelChanges()
+        let powerLevels = RoomPowerLevels(ban: 100,
+                                          invite: 100,
+                                          kick: 100,
+                                          redact: 50,
+                                          eventsDefault: 50,
+                                          stateDefault: 50,
+                                          usersDefault: 0,
+                                          roomName: 0,
+                                          roomAvatar: 0,
+                                          roomTopic: 0)
         
         // When creating room permissions from them.
-        let permissions = RoomPermissions(powerLevelChanges: powerLevelChanges)
+        let permissions = RoomPermissions(powerLevels: powerLevels)
         
-        // Then none of the permissions should be set.
+        // Then the permissions should be created with values mapped to the correct role.
-        XCTAssertNil(permissions.ban)
-        XCTAssertNil(permissions.invite)
-        XCTAssertNil(permissions.kick)
-        XCTAssertNil(permissions.redact)
-        XCTAssertNil(permissions.eventsDefault)
-        XCTAssertNil(permissions.stateDefault)
-        XCTAssertNil(permissions.usersDefault)
-        XCTAssertNil(permissions.roomName)
-        XCTAssertNil(permissions.roomAvatar)
-        XCTAssertNil(permissions.roomTopic)
-    }
-    
-    func testCompleteFromRust() {
-        // Given a set of power level changes with all the values set to 100.
-        let powerLevelChanges = RoomPowerLevelChanges(ban: 100,
-                                                      invite: 100,
-                                                      kick: 100,
-                                                      redact: 100,
-                                                      eventsDefault: 100,
-                                                      stateDefault: 100,
-                                                      usersDefault: 100,
-                                                      roomName: 100,
-                                                      roomAvatar: 100,
-                                                      roomTopic: 100)
-        
-        // When creating room permissions from them.
-        let permissions = RoomPermissions(powerLevelChanges: powerLevelChanges)
-        
-        // Then all of the permissions should be for an administrator.
         XCTAssertEqual(permissions.ban, .administrator)
         XCTAssertEqual(permissions.invite, .administrator)
         XCTAssertEqual(permissions.kick, .administrator)
-        XCTAssertEqual(permissions.redact, .administrator)
+        XCTAssertEqual(permissions.redact, .moderator)
-        XCTAssertEqual(permissions.eventsDefault, .administrator)
+        XCTAssertEqual(permissions.eventsDefault, .moderator)
-        XCTAssertEqual(permissions.stateDefault, .administrator)
+        XCTAssertEqual(permissions.stateDefault, .moderator)
-        XCTAssertEqual(permissions.usersDefault, .administrator)
+        XCTAssertEqual(permissions.usersDefault, .user)
-        XCTAssertEqual(permissions.roomName, .administrator)
+        XCTAssertEqual(permissions.roomName, .user)
-        XCTAssertEqual(permissions.roomAvatar, .administrator)
+        XCTAssertEqual(permissions.roomAvatar, .user)
-        XCTAssertEqual(permissions.roomTopic, .administrator)
+        XCTAssertEqual(permissions.roomTopic, .user)
-    }
-    
-    func testToRust() {
-        // Given a set of permissions where on some of the values have been set.
-        let permissions = RoomPermissions(roomName: .administrator, roomAvatar: .administrator, roomTopic: .administrator)
-        
-        // When creating power level changes from them.
-        let powerLevelChanges = permissions.makePowerLevelChanges()
-        
-        // Then only the permissions that were set should be included.
-        XCTAssertNil(powerLevelChanges.ban, "Unset values should be nil for Rust to merge with the current value.")
-        XCTAssertNil(powerLevelChanges.invite, "Unset values should be nil for Rust to merge with the current value.")
-        XCTAssertNil(powerLevelChanges.kick, "Unset values should be nil for Rust to merge with the current value.")
-        XCTAssertNil(powerLevelChanges.redact, "Unset values should be nil for Rust to merge with the current value.")
-        XCTAssertNil(powerLevelChanges.eventsDefault, "Unset values should be nil for Rust to merge with the current value.")
-        XCTAssertNil(powerLevelChanges.stateDefault, "Unset values should be nil for Rust to merge with the current value.")
-        XCTAssertNil(powerLevelChanges.usersDefault, "Unset values should be nil for Rust to merge with the current value.")
-        XCTAssertEqual(powerLevelChanges.roomName, 100)
-        XCTAssertEqual(powerLevelChanges.roomAvatar, 100)
-        XCTAssertEqual(powerLevelChanges.roomTopic, 100)
     }
 }

project.yml

@@ -48,7 +48,7 @@ packages:
   # Element/Matrix dependencies
   MatrixRustSDK:
     url: https://github.com/matrix-org/matrix-rust-components-swift
-    exactVersion: 1.1.46
+    exactVersion: 1.1.47
     # path: ../matrix-rust-sdk
   Compound:
     url: https://github.com/element-hq/compound-ios