Implement the flow for leaving a space. (#4568)

ElementX/Sources/Mocks/Generated/GeneratedMocks.swift

@@ -16111,6 +16111,76 @@ class SpaceServiceProxyMock: SpaceServiceProxyProtocol, @unchecked Sendable {
             return spaceRoomListSpaceIDParentReturnValue
         }
     }
+    //MARK: - leaveSpace
+
+    var leaveSpaceSpaceIDUnderlyingCallsCount = 0
+    var leaveSpaceSpaceIDCallsCount: Int {
+        get {
+            if Thread.isMainThread {
+                return leaveSpaceSpaceIDUnderlyingCallsCount
+            } else {
+                var returnValue: Int? = nil
+                DispatchQueue.main.sync {
+                    returnValue = leaveSpaceSpaceIDUnderlyingCallsCount
+                }
+
+                return returnValue!
+            }
+        }
+        set {
+            if Thread.isMainThread {
+                leaveSpaceSpaceIDUnderlyingCallsCount = newValue
+            } else {
+                DispatchQueue.main.sync {
+                    leaveSpaceSpaceIDUnderlyingCallsCount = newValue
+                }
+            }
+        }
+    }
+    var leaveSpaceSpaceIDCalled: Bool {
+        return leaveSpaceSpaceIDCallsCount > 0
+    }
+    var leaveSpaceSpaceIDReceivedSpaceID: String?
+    var leaveSpaceSpaceIDReceivedInvocations: [String] = []
+
+    var leaveSpaceSpaceIDUnderlyingReturnValue: Result<LeaveSpaceHandleProxy, SpaceServiceProxyError>!
+    var leaveSpaceSpaceIDReturnValue: Result<LeaveSpaceHandleProxy, SpaceServiceProxyError>! {
+        get {
+            if Thread.isMainThread {
+                return leaveSpaceSpaceIDUnderlyingReturnValue
+            } else {
+                var returnValue: Result<LeaveSpaceHandleProxy, SpaceServiceProxyError>? = nil
+                DispatchQueue.main.sync {
+                    returnValue = leaveSpaceSpaceIDUnderlyingReturnValue
+                }
+
+                return returnValue!
+            }
+        }
+        set {
+            if Thread.isMainThread {
+                leaveSpaceSpaceIDUnderlyingReturnValue = newValue
+            } else {
+                DispatchQueue.main.sync {
+                    leaveSpaceSpaceIDUnderlyingReturnValue = newValue
+                }
+            }
+        }
+    }
+    var leaveSpaceSpaceIDClosure: ((String) async -> Result<LeaveSpaceHandleProxy, SpaceServiceProxyError>)?
+
+    func leaveSpace(spaceID: String) async -> Result<LeaveSpaceHandleProxy, SpaceServiceProxyError> {
+        leaveSpaceSpaceIDCallsCount += 1
+        leaveSpaceSpaceIDReceivedSpaceID = spaceID
+        DispatchQueue.main.async {
+            self.leaveSpaceSpaceIDReceivedInvocations.append(spaceID)
+        }
+        if let leaveSpaceSpaceIDClosure = leaveSpaceSpaceIDClosure {
+            return await leaveSpaceSpaceIDClosure(spaceID)
+        } else {
+            return leaveSpaceSpaceIDReturnValue
+        }
+    }
 }
 class StaticRoomSummaryProviderMock: StaticRoomSummaryProviderProtocol, @unchecked Sendable {
     var roomListPublisher: CurrentValuePublisher<[RoomSummary], Never> {

ElementX/Sources/Mocks/Generated/SDKGeneratedMocks.swift

@@ -10135,6 +10135,128 @@ open class LazyTimelineItemProviderSDKMock: MatrixRustSDK.LazyTimelineItemProvid
         }
     }
 }
+open class LeaveSpaceHandleSDKMock: MatrixRustSDK.LeaveSpaceHandle, @unchecked Sendable {
+    init() {
+        super.init(noPointer: .init())
+    }
+
+    public required init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) {
+        fatalError("init(unsafeFromRawPointer:) has not been implemented")
+    }
+
+    fileprivate var pointer: UnsafeMutableRawPointer!
+
+    //MARK: - leave
+
+    open var leaveRoomIdsThrowableError: Error?
+    var leaveRoomIdsUnderlyingCallsCount = 0
+    open var leaveRoomIdsCallsCount: Int {
+        get {
+            if Thread.isMainThread {
+                return leaveRoomIdsUnderlyingCallsCount
+            } else {
+                var returnValue: Int? = nil
+                DispatchQueue.main.sync {
+                    returnValue = leaveRoomIdsUnderlyingCallsCount
+                }
+
+                return returnValue!
+            }
+        }
+        set {
+            if Thread.isMainThread {
+                leaveRoomIdsUnderlyingCallsCount = newValue
+            } else {
+                DispatchQueue.main.sync {
+                    leaveRoomIdsUnderlyingCallsCount = newValue
+                }
+            }
+        }
+    }
+    open var leaveRoomIdsCalled: Bool {
+        return leaveRoomIdsCallsCount > 0
+    }
+    open var leaveRoomIdsReceivedRoomIds: [String]?
+    open var leaveRoomIdsReceivedInvocations: [[String]] = []
+    open var leaveRoomIdsClosure: (([String]) async throws -> Void)?
+
+    open override func leave(roomIds: [String]) async throws {
+        if let error = leaveRoomIdsThrowableError {
+            throw error
+        }
+        leaveRoomIdsCallsCount += 1
+        leaveRoomIdsReceivedRoomIds = roomIds
+        DispatchQueue.main.async {
+            self.leaveRoomIdsReceivedInvocations.append(roomIds)
+        }
+        try await leaveRoomIdsClosure?(roomIds)
+    }
+
+    //MARK: - rooms
+
+    var roomsUnderlyingCallsCount = 0
+    open var roomsCallsCount: Int {
+        get {
+            if Thread.isMainThread {
+                return roomsUnderlyingCallsCount
+            } else {
+                var returnValue: Int? = nil
+                DispatchQueue.main.sync {
+                    returnValue = roomsUnderlyingCallsCount
+                }
+
+                return returnValue!
+            }
+        }
+        set {
+            if Thread.isMainThread {
+                roomsUnderlyingCallsCount = newValue
+            } else {
+                DispatchQueue.main.sync {
+                    roomsUnderlyingCallsCount = newValue
+                }
+            }
+        }
+    }
+    open var roomsCalled: Bool {
+        return roomsCallsCount > 0
+    }
+
+    var roomsUnderlyingReturnValue: [LeaveSpaceRoom]!
+    open var roomsReturnValue: [LeaveSpaceRoom]! {
+        get {
+            if Thread.isMainThread {
+                return roomsUnderlyingReturnValue
+            } else {
+                var returnValue: [LeaveSpaceRoom]? = nil
+                DispatchQueue.main.sync {
+                    returnValue = roomsUnderlyingReturnValue
+                }
+
+                return returnValue!
+            }
+        }
+        set {
+            if Thread.isMainThread {
+                roomsUnderlyingReturnValue = newValue
+            } else {
+                DispatchQueue.main.sync {
+                    roomsUnderlyingReturnValue = newValue
+                }
+            }
+        }
+    }
+    open var roomsClosure: (() -> [LeaveSpaceRoom])?
+
+    open override func rooms() -> [LeaveSpaceRoom] {
+        roomsCallsCount += 1
+        if let roomsClosure = roomsClosure {
+            return roomsClosure()
+        } else {
+            return roomsReturnValue
+        }
+    }
+}
 open class MediaFileHandleSDKMock: MatrixRustSDK.MediaFileHandle, @unchecked Sendable {
     init() {
         super.init(noPointer: .init())
@@ -22227,6 +22349,81 @@ open class SpaceServiceSDKMock: MatrixRustSDK.SpaceService, @unchecked Sendable
         }
     }
 
+    //MARK: - leaveSpace
+
+    open var leaveSpaceSpaceIdThrowableError: Error?
+    var leaveSpaceSpaceIdUnderlyingCallsCount = 0
+    open var leaveSpaceSpaceIdCallsCount: Int {
+        get {
+            if Thread.isMainThread {
+                return leaveSpaceSpaceIdUnderlyingCallsCount
+            } else {
+                var returnValue: Int? = nil
+                DispatchQueue.main.sync {
+                    returnValue = leaveSpaceSpaceIdUnderlyingCallsCount
+                }
+
+                return returnValue!
+            }
+        }
+        set {
+            if Thread.isMainThread {
+                leaveSpaceSpaceIdUnderlyingCallsCount = newValue
+            } else {
+                DispatchQueue.main.sync {
+                    leaveSpaceSpaceIdUnderlyingCallsCount = newValue
+                }
+            }
+        }
+    }
+    open var leaveSpaceSpaceIdCalled: Bool {
+        return leaveSpaceSpaceIdCallsCount > 0
+    }
+    open var leaveSpaceSpaceIdReceivedSpaceId: String?
+    open var leaveSpaceSpaceIdReceivedInvocations: [String] = []
+
+    var leaveSpaceSpaceIdUnderlyingReturnValue: LeaveSpaceHandle!
+    open var leaveSpaceSpaceIdReturnValue: LeaveSpaceHandle! {
+        get {
+            if Thread.isMainThread {
+                return leaveSpaceSpaceIdUnderlyingReturnValue
+            } else {
+                var returnValue: LeaveSpaceHandle? = nil
+                DispatchQueue.main.sync {
+                    returnValue = leaveSpaceSpaceIdUnderlyingReturnValue
+                }
+
+                return returnValue!
+            }
+        }
+        set {
+            if Thread.isMainThread {
+                leaveSpaceSpaceIdUnderlyingReturnValue = newValue
+            } else {
+                DispatchQueue.main.sync {
+                    leaveSpaceSpaceIdUnderlyingReturnValue = newValue
+                }
+            }
+        }
+    }
+    open var leaveSpaceSpaceIdClosure: ((String) async throws -> LeaveSpaceHandle)?
+
+    open override func leaveSpace(spaceId: String) async throws -> LeaveSpaceHandle {
+        if let error = leaveSpaceSpaceIdThrowableError {
+            throw error
+        }
+        leaveSpaceSpaceIdCallsCount += 1
+        leaveSpaceSpaceIdReceivedSpaceId = spaceId
+        DispatchQueue.main.async {
+            self.leaveSpaceSpaceIdReceivedInvocations.append(spaceId)
+        }
+        if let leaveSpaceSpaceIdClosure = leaveSpaceSpaceIdClosure {
+            return try await leaveSpaceSpaceIdClosure(spaceId)
+        } else {
+            return leaveSpaceSpaceIdReturnValue
+        }
+    }
+
     //MARK: - spaceRoomList
 
     open var spaceRoomListSpaceIdThrowableError: Error?

ElementX/Sources/Mocks/SDK/LeaveSpaceHandleSDKMock.swift

@@ -0,0 +1,142 @@
+//
+// Copyright 2025 New Vector Ltd.
+//
+// SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
+// Please see LICENSE files in the repository root for full details.
+//
+
+import Foundation
+import MatrixRustSDK
+
+extension LeaveSpaceHandleSDKMock {
+    struct Configuration {
+        var rooms: [LeaveSpaceRoom] = .mockRooms
+    }
+    
+    convenience init(_ configuration: Configuration) {
+        self.init()
+        
+        roomsClosure = { configuration.rooms }
+    }
+}
+
+extension [LeaveSpaceRoom] {
+    static var mockAdminRooms: [LeaveSpaceRoom] {
+        mockRooms.filter(\.isLastAdmin)
+    }
+    
+    static var mockRooms: [LeaveSpaceRoom] {
+        [
+            LeaveSpaceRoom(spaceRoom: SpaceRoom(id: "1",
+                                                name: "Lighting",
+                                                avatarURL: .mockMXCAvatar,
+                                                isSpace: false,
+                                                memberCount: 10,
+                                                joinRule: .public),
+                           isLastAdmin: false),
+            LeaveSpaceRoom(spaceRoom: SpaceRoom(id: "2",
+                                                name: "Sound",
+                                                isSpace: false,
+                                                memberCount: 20,
+                                                joinRule: .private),
+                           isLastAdmin: false),
+            LeaveSpaceRoom(spaceRoom: SpaceRoom(id: "3",
+                                                name: "Set & Costume",
+                                                isSpace: false,
+                                                memberCount: 25,
+                                                joinRule: .restricted(rules: [])),
+                           isLastAdmin: false),
+            LeaveSpaceRoom(spaceRoom: SpaceRoom(id: "4",
+                                                name: "The Theatre",
+                                                isSpace: true,
+                                                memberCount: 100,
+                                                joinRule: .private,
+                                                childrenCount: 20),
+                           isLastAdmin: false),
+            LeaveSpaceRoom(spaceRoom: SpaceRoom(id: "5",
+                                                name: "Bookings",
+                                                isSpace: false,
+                                                memberCount: 200,
+                                                joinRule: .private,
+                                                childrenCount: 0),
+                           isLastAdmin: true),
+            LeaveSpaceRoom(spaceRoom: SpaceRoom(id: "6",
+                                                name: "Events",
+                                                isSpace: false,
+                                                memberCount: 65,
+                                                joinRule: .restricted(rules: []),
+                                                childrenCount: 0),
+                           isLastAdmin: true),
+            LeaveSpaceRoom(spaceRoom: SpaceRoom(id: "7",
+                                                name: "Mario Kart",
+                                                isSpace: false,
+                                                memberCount: 123,
+                                                joinRule: .public),
+                           isLastAdmin: false),
+            LeaveSpaceRoom(spaceRoom: SpaceRoom(id: "8",
+                                                name: "Tetris",
+                                                isSpace: false,
+                                                memberCount: 95,
+                                                joinRule: .public),
+                           isLastAdmin: false),
+            LeaveSpaceRoom(spaceRoom: SpaceRoom(id: "9",
+                                                name: "Minecraft",
+                                                isSpace: false,
+                                                memberCount: 39,
+                                                joinRule: .public),
+                           isLastAdmin: false),
+            LeaveSpaceRoom(spaceRoom: SpaceRoom(id: "10",
+                                                name: "Lemmings",
+                                                isSpace: false,
+                                                memberCount: 67,
+                                                joinRule: .public),
+                           isLastAdmin: true),
+            LeaveSpaceRoom(spaceRoom: SpaceRoom(id: "11",
+                                                name: "Rayman",
+                                                isSpace: false,
+                                                memberCount: 23,
+                                                joinRule: .public),
+                           isLastAdmin: false),
+            LeaveSpaceRoom(spaceRoom: SpaceRoom(id: "12",
+                                                name: "Gaming",
+                                                avatarURL: .mockMXCAvatar,
+                                                isSpace: true,
+                                                memberCount: 835,
+                                                joinRule: .public,
+                                                childrenCount: 15),
+                           isLastAdmin: true)
+        ]
+    }
+}
+
+private extension SpaceRoom {
+    init(id: String,
+         canonicalAlias: String? = nil,
+         name: String,
+         topic: String? = nil,
+         avatarURL: URL? = nil,
+         isSpace: Bool,
+         memberCount: UInt64,
+         joinRule: JoinRule? = .public,
+         isDirect: Bool? = false,
+         childrenCount: UInt64 = 0,
+         membership: Membership? = .joined,
+         heroes: [RoomHero]? = [],
+         via: [String] = []) {
+        self.init(roomId: id,
+                  canonicalAlias: canonicalAlias,
+                  name: name,
+                  topic: topic,
+                  avatarUrl: avatarURL?.absoluteString,
+                  roomType: isSpace ? .space : .room,
+                  numJoinedMembers: memberCount,
+                  joinRule: joinRule,
+                  worldReadable: true,
+                  guestCanJoin: false,
+                  isDirect: isDirect,
+                  childrenCount: childrenCount,
+                  state: membership,
+                  heroes: heroes,
+                  via: via)
+    }
+}

ElementX/Sources/Mocks/SpaceServiceProxyMock.swift

@@ -13,6 +13,7 @@ extension SpaceServiceProxyMock {
     struct Configuration {
         var joinedSpaces: [SpaceRoomProxyProtocol] = []
         var spaceRoomLists: [String: SpaceRoomListProxyMock] = [:]
+        var leaveSpaceRooms: [LeaveSpaceRoom] = []
     }
     
     convenience init(_ configuration: Configuration) {
@@ -26,6 +27,10 @@ extension SpaceServiceProxyMock {
                 .failure(.sdkError(ClientProxyMockError.generic))
             }
         }
+        leaveSpaceSpaceIDClosure = { spaceID in
+            .success(LeaveSpaceHandleProxy(spaceID: spaceID,
+                                           leaveHandle: LeaveSpaceHandleSDKMock(.init(rooms: configuration.leaveSpaceRooms))))
+        }
     }
 }