Channel Partial Update (#2681)

* Add partialChannelUpdate to ChannelEndpoints

* Expose partialChannelUpdate in ChannelController

* Update CHANGELOG

* Update ChannelUpdater tests

* Update ChannelController tests

Author: polqf

CHANGELOG.md

@@ -6,6 +6,8 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 ## StreamChat
 ### ✅ Added
 - Expose Extra Data for Giphy Attachment Payloads [#2678](https://github.com/GetStream/stream-chat-swift/pull/2678)
+- Add support for partial Channel update [#2681](https://github.com/GetStream/stream-chat-swift/pull/2681)
+
 ### 🐞 Fixed
 - Rescue messages that are stuck in `.sending` state [#2676](https://github.com/GetStream/stream-chat-swift/pull/2676)
 - Fix not being able to resend failed attachments [#2680](https://github.com/GetStream/stream-chat-swift/pull/2680)

Sources/StreamChat/APIClient/Endpoints/ChannelEndpoints.swift

@@ -44,6 +44,21 @@ extension Endpoint {
         )
     }
 
+    static func partialChannelUpdate(updates: ChannelEditDetailPayload, unsetProperties: [String]) -> Endpoint<EmptyResponse> {
+        let body: [String: AnyEncodable] = [
+            "set": AnyEncodable(updates),
+            "unset": AnyEncodable(unsetProperties)
+        ]
+
+        return .init(
+            path: .channelUpdate(updates.apiPath),
+            method: .patch,
+            queryItems: nil,
+            requiresConnectionId: false,
+            body: body
+        )
+    }
+
     static func muteChannel(cid: ChannelId, mute: Bool) -> Endpoint<EmptyResponse> {
         .init(
             path: .muteChannel(mute),

Sources/StreamChat/Controllers/ChannelController/ChannelController.swift

@@ -262,6 +262,50 @@ public class ChatChannelController: DataController, DelegateCallable, DataStoreP
         }
     }
 
+    /// Updates  channel information with provided data, and removes unneeded properties.
+    ///
+    /// - Parameters:
+    ///   - team: New team.
+    ///   - members: New members.
+    ///   - invites: New invites.
+    ///   - extraData: New `ExtraData`.
+    ///   - unsetProperties: Properties from the channel that are going to be cleared/unset.
+    ///   - completion: The completion. Will be called on a **callbackQueue** when the network request is finished.
+    ///                 If request fails, the completion will be called with an error.
+    ///
+    public func partialChannelUpdate(
+        name: String? = nil,
+        imageURL: URL? = nil,
+        team: String? = nil,
+        members: Set<UserId> = [],
+        invites: Set<UserId> = [],
+        extraData: [String: RawJSON] = [:],
+        unsetProperties: [String] = [],
+        completion: ((Error?) -> Void)? = nil
+    ) {
+        /// Perform action only if channel is already created on backend side and have a valid `cid`.
+        guard let cid = cid, isChannelAlreadyCreated else {
+            channelModificationFailed(completion)
+            return
+        }
+
+        let payload: ChannelEditDetailPayload = .init(
+            cid: cid,
+            name: name,
+            imageURL: imageURL,
+            team: team,
+            members: members,
+            invites: invites,
+            extraData: extraData
+        )
+
+        updater.partialChannelUpdate(updates: payload, unsetProperties: unsetProperties) { error in
+            self.callback {
+                completion?(error)
+            }
+        }
+    }
+
     /// Mutes the channel this controller manages.
     ///
     /// - Parameter completion: The completion. Will be called on a **callbackQueue** when the network request is finished.

Sources/StreamChat/Workers/ChannelUpdater.swift

@@ -99,14 +99,29 @@ class ChannelUpdater: Worker {
 
     /// Updates specific channel with new data.
     /// - Parameters:
-    ///   - channelPayload: New channel data..
+    ///   - channelPayload: New channel data.
     ///   - completion: Called when the API call is finished. Called with `Error` if the remote update fails.
     func updateChannel(channelPayload: ChannelEditDetailPayload, completion: ((Error?) -> Void)? = nil) {
         apiClient.request(endpoint: .updateChannel(channelPayload: channelPayload)) {
             completion?($0.error)
         }
     }
 
+    /// Updates specific channel with provided data, and removes unneeded properties.
+    /// - Parameters:
+    ///   - updates: Updated channel data. Only non-nil data will be updated.
+    ///   - unsetProperties: Properties from the channel that are going to be cleared/unset.
+    ///   - completion: Called when the API call is finished. Called with `Error` if the remote update fails.
+    func partialChannelUpdate(
+        updates: ChannelEditDetailPayload,
+        unsetProperties: [String],
+        completion: ((Error?) -> Void)? = nil
+    ) {
+        apiClient.request(endpoint: .partialChannelUpdate(updates: updates, unsetProperties: unsetProperties)) {
+            completion?($0.error)
+        }
+    }
+
     /// Mutes/unmutes the specific channel.
     /// - Parameters:
     ///   - cid: The channel identifier.

TestTools/StreamChatTestTools/Mocks/StreamChat/Workers/ChannelUpdater_Mock.swift

@@ -15,6 +15,10 @@ final class ChannelUpdater_Mock: ChannelUpdater {
     @Atomic var updateChannel_payload: ChannelEditDetailPayload?
     @Atomic var updateChannel_completion: ((Error?) -> Void)?
 
+    @Atomic var partialChannelUpdate_updates: ChannelEditDetailPayload?
+    @Atomic var partialChannelUpdate_unsetProperties: [String]?
+    @Atomic var partialChannelUpdate_completion: ((Error?) -> Void)?
+
     @Atomic var muteChannel_cid: ChannelId?
     @Atomic var muteChannel_mute: Bool?
     @Atomic var muteChannel_completion: ((Error?) -> Void)?
@@ -221,6 +225,12 @@ final class ChannelUpdater_Mock: ChannelUpdater {
         updateChannel_completion = completion
     }
 
+    override func partialChannelUpdate(updates: ChannelEditDetailPayload, unsetProperties: [String], completion: ((Error?) -> Void)? = nil) {
+        partialChannelUpdate_updates = updates
+        partialChannelUpdate_unsetProperties = unsetProperties
+        partialChannelUpdate_completion = completion
+    }
+
     override func muteChannel(cid: ChannelId, mute: Bool, completion: ((Error?) -> Void)? = nil) {
         muteChannel_cid = cid
         muteChannel_mute = mute

Tests/StreamChatTests/APIClient/Endpoints/ChannelEndpoints_Tests.swift

@@ -95,6 +95,28 @@ final class ChannelEndpoints_Tests: XCTestCase {
         // Assert endpoint is built correctly
         XCTAssertEqual(AnyEndpoint(expectedEndpoint), AnyEndpoint(endpoint))
         XCTAssertEqual("channels/\(channelPayload.apiPath)", endpoint.path.value)
+        XCTAssertEqual(expectedEndpoint.method, endpoint.method)
+    }
+
+    func test_partialChannelUpdate_buildsCorrectly() {
+        let channelPayload: ChannelEditDetailPayload = .unique
+        let unsetProperties = ["user", "clash"]
+
+        let expectedEndpoint = Endpoint<EmptyResponse>(
+            path: .channelUpdate(channelPayload.apiPath),
+            method: .patch,
+            queryItems: nil,
+            requiresConnectionId: false,
+            body: ["set": AnyEncodable(channelPayload), "unset": AnyEncodable(unsetProperties)]
+        )
+
+        // Build endpoint
+        let endpoint: Endpoint<EmptyResponse> = .partialChannelUpdate(updates: channelPayload, unsetProperties: unsetProperties)
+
+        // Assert endpoint is built correctly
+        XCTAssertEqual(AnyEndpoint(expectedEndpoint), AnyEndpoint(endpoint))
+        XCTAssertEqual("channels/\(channelPayload.apiPath)", endpoint.path.value)
+        XCTAssertEqual(expectedEndpoint.method, endpoint.method)
     }
 
     func test_deleteChannel_buildsCorrectly() {

Tests/StreamChatTests/Controllers/ChannelController/ChannelController_Tests.swift

@@ -1581,7 +1581,7 @@ final class ChannelController_Tests: XCTestCase {
         }
         XCTAssert(error is ClientError.ChannelNotCreatedYet)
 
-        // Simulate succsesfull backend channel creation
+        // Simulate successful backend channel creation
         env.channelUpdater!.update_onChannelCreated?(query.cid!)
 
         // Simulate `updateChannel` call and assert no error is returned
@@ -1641,6 +1641,97 @@ final class ChannelController_Tests: XCTestCase {
         AssertAsync.willBeEqual(completionCalledError as? TestError, testError)
     }
 
+    // MARK: - Channel partial update
+
+    func test_partialChannelUpdate_failsForNewChannels() throws {
+        //  Create `ChannelController` for new channel
+        let query = ChannelQuery(channelPayload: .unique)
+        setupControllerForNewChannel(query: query)
+
+        var receivedError: Error?
+        let expectation = self.expectation(description: "partialChannelUpdate completes")
+        controller.partialChannelUpdate { [callbackQueueID] error in
+            AssertTestQueue(withId: callbackQueueID)
+            receivedError = error
+            expectation.fulfill()
+        }
+
+        waitForExpectations(timeout: defaultTimeout)
+        XCTAssert(receivedError is ClientError.ChannelNotCreatedYet)
+    }
+
+    func test_partialChannelUpdate_propagatesSuccess() throws {
+        let name = "Jason Bourne"
+        let imageURL: URL? = nil
+        let team = "team-one"
+        let members: Set<UserId> = ["member1", "member2"]
+        let invites: Set<UserId> = ["invite1"]
+        let extraData: [String: RawJSON] = ["scope": "test"]
+        let unsetProperties: [String] = ["user.id", "channel_store"]
+
+        var receivedError: Error?
+        let expectation = self.expectation(description: "partialChannelUpdate completes")
+        controller.partialChannelUpdate(
+            name: name,
+            imageURL: imageURL,
+            team: team,
+            members: members,
+            invites: invites,
+            extraData: extraData,
+            unsetProperties: unsetProperties
+        ) { [callbackQueueID] error in
+            AssertTestQueue(withId: callbackQueueID)
+            receivedError = error
+            expectation.fulfill()
+        }
+
+        let updater = try XCTUnwrap(env.channelUpdater)
+
+        // Simulate successful update
+        updater.partialChannelUpdate_completion?(nil)
+        updater.partialChannelUpdate_completion = nil
+
+        waitForExpectations(timeout: defaultTimeout)
+
+        XCTAssertEqual(updater.partialChannelUpdate_updates?.name, name)
+        XCTAssertEqual(updater.partialChannelUpdate_updates?.imageURL, imageURL)
+        XCTAssertEqual(updater.partialChannelUpdate_updates?.team, team)
+        XCTAssertEqual(updater.partialChannelUpdate_updates?.members, members)
+        XCTAssertEqual(updater.partialChannelUpdate_updates?.invites, invites)
+        XCTAssertEqual(updater.partialChannelUpdate_updates?.extraData, extraData)
+        XCTAssertEqual(updater.partialChannelUpdate_unsetProperties, unsetProperties)
+        XCTAssertNil(receivedError)
+    }
+
+    func test_partialChannelUpdate_propagatesError() throws {
+        var receivedError: Error?
+        let expectation = self.expectation(description: "partialChannelUpdate completes")
+        controller.partialChannelUpdate(
+            name: .unique,
+            imageURL: .unique(),
+            team: .unique,
+            members: [],
+            invites: [],
+            extraData: [:],
+            unsetProperties: []
+        ) { [callbackQueueID] error in
+            AssertTestQueue(withId: callbackQueueID)
+            receivedError = error
+            expectation.fulfill()
+        }
+
+        let updater = try XCTUnwrap(env.channelUpdater)
+
+        // Simulate failed update
+        let testError = TestError()
+        updater.partialChannelUpdate_completion?(testError)
+        updater.partialChannelUpdate_completion = nil
+
+        waitForExpectations(timeout: defaultTimeout)
+
+        XCTAssertEqual(receivedError, testError)
+    }
+
     // MARK: - Muting channel
 
     func test_muteChannel_failsForNewChannels() throws {

Tests/StreamChatTests/Workers/ChannelUpdater_Tests.swift

@@ -708,6 +708,53 @@ final class ChannelUpdater_Tests: XCTestCase {
         AssertAsync.willBeEqual(completionCalledError as? TestError, error)
     }
 
+    // MARK: - Partial channel update
+
+    func test_partialChannelUpdate_makesCorrectAPICall() {
+        let updates: ChannelEditDetailPayload = .unique
+        let unsetProperties: [String] = ["user.id", "channel_store"]
+
+        // Simulate `partialChannelUpdate(updates:unsetProperties:completion:)` call
+        channelUpdater.partialChannelUpdate(updates: updates, unsetProperties: unsetProperties)
+
+        // Assert correct endpoint is called
+        let referenceEndpoint: Endpoint<EmptyResponse> = .partialChannelUpdate(updates: updates, unsetProperties: unsetProperties)
+        XCTAssertEqual(apiClient.request_endpoint, AnyEndpoint(referenceEndpoint))
+    }
+
+    func test_partialChannelUpdate_successfulResponse_isPropagatedToCompletion() {
+        // Simulate `partialChannelUpdate(updates:unsetProperties:completion:)` call
+        var receivedError: Error?
+        let expectation = self.expectation(description: "partialChannelUpdate completion")
+        channelUpdater.partialChannelUpdate(updates: .unique, unsetProperties: []) { error in
+            receivedError = error
+            expectation.fulfill()
+        }
+
+        // Simulate API response with success
+        apiClient.test_simulateResponse(Result<EmptyResponse, Error>.success(.init()))
+        waitForExpectations(timeout: defaultTimeout)
+
+        XCTAssertNil(receivedError)
+    }
+
+    func test_partialChannelUpdate_errorResponse_isPropagatedToCompletion() {
+        // Simulate `partialChannelUpdate(updates:unsetProperties:completion:)` call
+        var receivedError: Error?
+        let expectation = self.expectation(description: "partialChannelUpdate completion")
+        channelUpdater.partialChannelUpdate(updates: .unique, unsetProperties: []) { error in
+            receivedError = error
+            expectation.fulfill()
+        }
+
+        // Simulate API response with failure
+        let error = TestError()
+        apiClient.test_simulateResponse(Result<EmptyResponse, Error>.failure(error))
+        waitForExpectations(timeout: defaultTimeout)
+
+        XCTAssertEqual(receivedError, error)
+    }
+
     // MARK: - Mute channel
 
     func test_muteChannel_makesCorrectAPICall() {