Merge branch 'langleyd/4781_swiftui_template_examples' of https://github.com/vector-im/element-ios into langleyd/4781_swiftui_template_example2

RiotSwiftUI/Modules/Common/Test/XCTestPublisherExtensions.swift

@@ -34,6 +34,25 @@ extension XCTestCase {
         _ publisher: T,
         timeout: TimeInterval = 10
     ) throws -> T.Output {
+        return try xcAwaitDeferred(publisher, timeout: timeout)()
+    }
+    
+    /// XCTest utility that allows for a deferred wait of results from publishers, so that the output can be used for assertions.
+    ///
+    ///  ```
+    /// let collectedEvents = somePublisher.collect(3).first()
+    /// let awaitDeferred = xcAwaitDeferred(collectedEvents)
+    /// // Do some other work that publishes to somePublisher
+    /// XCTAssertEqual(try awaitDeferred(), [expected, values, here])
+    ///  ```
+    /// - Parameters:
+    ///   - publisher: The publisher to wait on.
+    ///   - timeout: A timeout after which we give up.
+    /// - Returns: A closure that starts the waiting of results when called. The closure will return the unwrapped result.
+    func xcAwaitDeferred<T: Publisher>(
+        _ publisher: T,
+        timeout: TimeInterval = 10
+    ) -> (() throws -> (T.Output)) {
         var result: Result<T.Output, Error>?
         let expectation = self.expectation(description: "Awaiting publisher")
 
@@ -52,12 +71,14 @@ extension XCTestCase {
                 result = .success(value)
             }
         )
-        waitForExpectations(timeout: timeout)
-        cancellable.cancel()
-        let unwrappedResult = try XCTUnwrap(
-            result,
-            "Awaited publisher did not produce any output"
-        )
-        return try unwrappedResult.get()
+        return {
+            self.waitForExpectations(timeout: timeout)
+            cancellable.cancel()
+            let unwrappedResult = try XCTUnwrap(
+                result,
+                "Awaited publisher did not produce any output"
+            )
+            return try unwrappedResult.get()
+        }
     }
 }

RiotSwiftUI/Modules/Common/ViewModel/BindableState.swift

@@ -0,0 +1,37 @@
+// 
+// Copyright 2021 New Vector Ltd
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+import Foundation
+
+/// Represents a specific portion of the ViewState that can be bound to with SwiftUI's [2-way binding](https://developer.apple.com/documentation/swiftui/binding).
+protocol BindableState {
+    /// The associated type of the Bindable State. Defaults to Void.
+    associatedtype BindStateType = Void
+    var bindings: BindStateType { get set }
+}
+
+extension BindableState where BindStateType == Void {
+    /// We provide a default implementation for the Void type so that we can have `ViewState` that
+    /// just doesn't include/take advantage of the bindings.
+    var bindings: Void {
+        get {
+            ()
+        }
+        set {
+            fatalError("Can't bind to the default Void binding.")
+        }
+    }
+}

RiotSwiftUI/Modules/Common/ViewModel/StateStoreViewModel.swift

@@ -20,79 +20,131 @@ import Combine
 import Foundation
 import Combine
 
-protocol BindableState {
-    associatedtype BindStateType = Void
-    var bindings: BindStateType { get set }
-}
-
-extension BindableState where BindStateType == Void {
-    var bindings: Void {
-        get {
-            ()
-        }
-        set {
-            fatalError("Can't bind to the default Void binding.")
-        }
-    }
-}
 
+/// A constrained and concise interface for interacting with the ViewModel.
+///
+/// This class is closely bound to`StateStoreViewModel`. It provides the exact interface the view should need to interact
+/// ViewModel (as modelled on our previous template architecture with the addition of two-way binding):
+/// - The ability read/observe view state
+/// - The ability to send view events
+/// - The ability to bind state to a specific portion of the view state safely.
+/// This class was brought about a little bit by necessity. The most idiomatic way of interacting with SwiftUI is via `@Published`
+/// properties which which are property wrappers and therefore can't be defined within protocols.
+/// A similar approach is taken in libraries like [CombineFeedback](https://github.com/sergdort/CombineFeedback).
+/// It provides a nice layer of consistency and also safety. As we are not passing the `ViewModel` to the view directly, shortcuts/hacks
+/// can't be made into the `ViewModel`.
 @available(iOS 14, *)
 class ViewModelContext<ViewState:BindableState, ViewAction>: ObservableObject {
-   
+    // MARK: - Properties
+
+    // MARK: Private
+
     private var cancellables = Set<AnyCancellable>()
     fileprivate let viewActions: PassthroughSubject<ViewAction, Never>
-    
+
+    // MARK: Public
+
+    /// Set-able/Bindable `Published` property for the bindable portion of the `ViewState`
     @Published var bindings: ViewState.BindStateType
+    /// Get-able/Observable `Published` property for the `ViewState`
     @Published fileprivate(set) var viewState: ViewState
 
+    // MARK: Setup
+
     init(initialViewState: ViewState) {
         self.bindings = initialViewState.bindings
         self.viewActions = PassthroughSubject()
         self.viewState = initialViewState
         if !(initialViewState.bindings is Void) {
+            // If we have bindable state defined, forward its updates on to the `ViewState`
             self.$bindings
                 .weakAssign(to: \.viewState.bindings, on: self)
                 .store(in: &cancellables)
         }
     }
-    
+
+    // MARK: Public
+
+    /// Send a `ViewAction` to the `ViewModel` for processing.
+    /// - Parameter viewAction: The `ViewAction` to send to the `ViewModel`.
     func send(viewAction: ViewAction) {
         viewActions.send(viewAction)
     }
 }
 
+/// A common ViewModel implementation for handling of `State`, `StateAction`s and `ViewAction`s
+///
+/// Generic type State is constrained to the BindableState protocol in that it may contain (but doesn't have to)
+/// a specific portion of state that can be safely bound to.
+/// If we decide to add more features to our state management (like doing state processing off the main thread)
+/// we can do it in this centralised place.
 @available(iOS 14, *)
-class StateStoreViewModel<State:BindableState, StateAction, ViewAction> {
-    
-    typealias Context = ViewModelContext<State, ViewAction>
-    
-    let state: CurrentValueSubject<State, Never>
+class StateStoreViewModel<State: BindableState, StateAction, ViewAction> {
 
+    typealias Context = ViewModelContext<State, ViewAction>
+
+    // MARK: - Properties
+
+    // MARK: Private
+
+    private let state: CurrentValueSubject<State, Never>
+
+    // MARK: Public
+
+    /// For storing subscription references.
+    ///
+    /// Left as public for `ViewModel` implementations convenience.
     var cancellables = Set<AnyCancellable>()
+
+    /// Constrained interface for passing to Views.
     var context: Context
-    
+
+    // MARK: Setup
+
     init(initialViewState: State) {
-        
         self.context = Context(initialViewState: initialViewState)
         self.state = CurrentValueSubject(initialViewState)
-        self.state.weakAssign(to: \.context.viewState, on: self)
+        // Connect the state to context viewState, that view uses for observing (but not modifying directly) the state.
+        self.state
+            .weakAssign(to: \.context.viewState, on: self)
             .store(in: &cancellables)
+        // Receive events from the view and pass on to the `ViewModel` for processing.
         self.context.viewActions.sink { [weak self] action in
             guard let self = self else { return }
             self.process(viewAction: action)
         }
         .store(in: &cancellables)
     }
-    
+
+    /// Send state actions to modify the state within the reducer.
+    /// - Parameter action: The state action to send to the reducer.
     func dispatch(action: StateAction) {
         Self.reducer(state: &state.value, action: action)
     }
 
-    class func reducer(state: inout State, action: StateAction) {
-
+    /// Send state actions from a publisher to modify the state within the reducer.
+    /// - Parameter actionPublisher: The publisher that produces actions to be sent to the reducer
+    func dispatch(actionPublisher: AnyPublisher<StateAction, Never>) {
+        actionPublisher.sink { [weak self] action in
+            guard let self = self else { return }
+            Self.reducer(state: &self.state.value, action: action)
+        }
+        .store(in: &cancellables)
     }
 
-    func process(viewAction: ViewAction) {
+    /// Override to handle mutations to the `State`
+    ///
+    /// A redux style reducer, all modifications to state happen here.
+    /// - Parameters:
+    ///   - state: The `inout` state to be modified,
+    ///   - action: The action that defines which state modification should take place.
+    class func reducer(state: inout State, action: StateAction) {
+        //Default implementation, -no-op
+    }
 
+    /// Override to handles incoming `ViewAction`s from the `ViewModel`.
+    /// - Parameter viewAction: The `ViewAction` to be processed in `ViewModel` implementation.
+    func process(viewAction: ViewAction) {
+        //Default implementation, -no-op
     }
 }

RiotSwiftUI/Modules/Template/SimpleUserProfileExample/Service/Mock/MockTemplateUserProfileService.swift

@@ -37,6 +37,6 @@ class MockTemplateUserProfileService: TemplateUserProfileServiceProtocol {
     }
     
     func simulateUpdate(presence: TemplateUserProfilePresence) {
-        self.presenceSubject.send(presence)
+        self.presenceSubject.value = presence
     }
 }

RiotSwiftUI/Modules/Template/SimpleUserProfileExample/Test/UI/TemplateUserProfileUITests.swift

@@ -1,4 +1,4 @@
-// 
+//
 // Copyright 2021 New Vector Ltd
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
@@ -19,7 +19,7 @@ import RiotSwiftUI
 
 @available(iOS 14.0, *)
 class TemplateUserProfileUITests: MockScreenTest {
-    
+
     override class var screenType: MockScreenState.Type {
         return MockTemplateUserProfileScreenState.self
     }
@@ -27,7 +27,7 @@ class TemplateUserProfileUITests: MockScreenTest {
     override class func createTest() -> MockScreenTest {
         return TemplateUserProfileUITests(selector: #selector(verifyTemplateUserProfileScreen))
     }
-    
+
     func verifyTemplateUserProfileScreen() throws {
         guard let screenState = screenState as? MockTemplateUserProfileScreenState else { fatalError("no screen") }
         switch screenState {
@@ -37,13 +37,13 @@ class TemplateUserProfileUITests: MockScreenTest {
             verifyTemplateUserProfileLongName(name: name)
         }
     }
-    
+
     func verifyTemplateUserProfilePresence(presence: TemplateUserProfilePresence) {
         let presenceText = app.staticTexts["presenceText"]
         XCTAssert(presenceText.exists)
         XCTAssert(presenceText.label == presence.title)
     }
-    
+
     func verifyTemplateUserProfileLongName(name: String) {
         let displayNameText = app.staticTexts["displayNameText"]
         XCTAssert(displayNameText.exists)

RiotSwiftUI/Modules/Template/SimpleUserProfileExample/Test/Unit/TemplateUserProfileViewModelTests.swift

@@ -26,29 +26,32 @@ class TemplateUserProfileViewModelTests: XCTestCase {
         static let displayName = "Alice"
     }
     var service: MockTemplateUserProfileService!
-    var viewModel: TemplateUserProfileViewModel!
+    var viewModel: TemplateUserProfileViewModelProtocol!
+    var context: TemplateUserProfileViewModelType.Context!
     var cancellables = Set<AnyCancellable>()
     override func setUpWithError() throws {
         service = MockTemplateUserProfileService(displayName: Constants.displayName, presence: Constants.presenceInitialValue)
-        viewModel = TemplateUserProfileViewModel(templateUserProfileService: service)
+        viewModel = TemplateUserProfileViewModel.makeTemplateUserProfileViewModel(templateUserProfileService: service)
+        context = viewModel.context
     }
-    
+
     func testInitialState() {
-        XCTAssertEqual(viewModel.viewState.displayName, Constants.displayName)
-        XCTAssertEqual(viewModel.viewState.presence, Constants.presenceInitialValue)
+        XCTAssertEqual(context.viewState.displayName, Constants.displayName)
+        XCTAssertEqual(context.viewState.presence, Constants.presenceInitialValue)
     }
 
     func testFirstPresenceReceived() throws {
-        let presencePublisher = viewModel.$viewState.map(\.presence).removeDuplicates().collect(1).first()
+        let presencePublisher = context.$viewState.map(\.presence).removeDuplicates().collect(1).first()
         XCTAssertEqual(try xcAwait(presencePublisher), [Constants.presenceInitialValue])
     }
-    
+
     func testPresenceUpdatesReceived() throws {
-        let presencePublisher = viewModel.$viewState.map(\.presence).removeDuplicates().collect(3).first()
+        let presencePublisher = context.$viewState.map(\.presence).removeDuplicates().collect(3).first()
+        let awaitDeferred = xcAwaitDeferred(presencePublisher)
         let newPresenceValue1: TemplateUserProfilePresence = .online
         let newPresenceValue2: TemplateUserProfilePresence = .idle
         service.simulateUpdate(presence: newPresenceValue1)
         service.simulateUpdate(presence: newPresenceValue2)
-        XCTAssertEqual(try xcAwait(presencePublisher), [Constants.presenceInitialValue, newPresenceValue1, newPresenceValue2])
+        XCTAssertEqual(try awaitDeferred(), [Constants.presenceInitialValue, newPresenceValue1, newPresenceValue2])
     }
 }

RiotSwiftUI/Modules/Template/SimpleUserProfileExample/ViewModel/TemplateUserProfileViewModel.swift

@@ -25,29 +25,29 @@ typealias TemplateUserProfileViewModelType = StateStoreViewModel<TemplateUserPro
                                                                  TemplateUserProfileViewAction>
 @available(iOS 14, *)
 class TemplateUserProfileViewModel: TemplateUserProfileViewModelType, TemplateUserProfileViewModelProtocol {
-    
+
     // MARK: - Properties
-    
+
     // MARK: Private
-    
+
     private let templateUserProfileService: TemplateUserProfileServiceProtocol
-    
+
     // MARK: Public
-    
+
     var completion: ((TemplateUserProfileViewModelResult) -> Void)?
-    
+
     // MARK: - Setup
-    
+
     static func makeTemplateUserProfileViewModel(templateUserProfileService: TemplateUserProfileServiceProtocol) -> TemplateUserProfileViewModelProtocol {
         return TemplateUserProfileViewModel(templateUserProfileService: templateUserProfileService)
     }
-    
+
     fileprivate init(templateUserProfileService: TemplateUserProfileServiceProtocol) {
         self.templateUserProfileService = templateUserProfileService
         super.init(initialViewState: Self.defaultState(templateUserProfileService: templateUserProfileService))
         setupPresenceObserving()
     }
-    
+
     private static func defaultState(templateUserProfileService: TemplateUserProfileServiceProtocol) -> TemplateUserProfileViewState {
         return TemplateUserProfileViewState(
             avatar: templateUserProfileService.avatarData,
@@ -55,15 +55,16 @@ class TemplateUserProfileViewModel: TemplateUserProfileViewModelType, TemplateUs
             presence: templateUserProfileService.presenceSubject.value
         )
     }
-    
+
     private func setupPresenceObserving() {
-        templateUserProfileService.presenceSubject
+        let presenceUpdatePublisher = templateUserProfileService.presenceSubject
             .map(TemplateUserProfileStateAction.updatePresence)
-            .sinkDispatchTo(self)
+            .eraseToAnyPublisher()
+        dispatch(actionPublisher: presenceUpdatePublisher)
     }
-    
+
     // MARK: - Public
-    
+
     override func process(viewAction: TemplateUserProfileViewAction) {
         switch viewAction {
         case .cancel:
@@ -72,13 +73,7 @@ class TemplateUserProfileViewModel: TemplateUserProfileViewModelType, TemplateUs
             done()
         }
     }
-      
-    /// A redux style reducer
-    ///
-    /// All modifications to state happen here.
-    /// - Parameters:
-    ///   - state: The `inout` state to be modified,
-    ///   - action: The action that defines which state modification should take place.
+
     override class func reducer(state: inout TemplateUserProfileViewState, action: TemplateUserProfileStateAction) {
         switch action {
         case .updatePresence(let presence):
@@ -86,11 +81,11 @@ class TemplateUserProfileViewModel: TemplateUserProfileViewModelType, TemplateUs
         }
         UILog.debug("[TemplateUserProfileViewModel] reducer with action \(action) produced state: \(state)")
     }
-    
+
     private func done() {
         completion?(.done)
     }
-    
+
     private func cancel() {
         completion?(.cancel)
     }

RiotSwiftUI/Modules/Template/TemplateAdvancedRoomsExample/TemplateRoomChat/Test/UI/TemplateRoomChatUITests.swift

@@ -18,6 +18,7 @@ import XCTest
 import RiotSwiftUI
 
 @available(iOS 14.0, *)
+<<<<<<< HEAD:RiotSwiftUI/Modules/Template/TemplateAdvancedRoomsExample/TemplateRoomChat/Test/UI/TemplateRoomChatUITests.swift
 class TemplateRoomChatUITests: MockScreenTest {
     
     override class var screenType: MockScreenState.Type {
@@ -39,12 +40,39 @@ class TemplateRoomChatUITests: MockScreenTest {
     }
     
     func verifyTemplateRoomChatPresence(presence: TemplateRoomChatPresence) {
+=======
+class TemplateUserProfileUITests: MockScreenTest {
+    
+    override class var screenType: MockScreenState.Type {
+        return MockTemplateUserProfileScreenState.self
+    }
+
+    override class func createTest() -> MockScreenTest {
+        return TemplateUserProfileUITests(selector: #selector(verifyTemplateUserProfileScreen))
+    }
+    
+    func verifyTemplateUserProfileScreen() throws {
+        guard let screenState = screenState as? MockTemplateUserProfileScreenState else { fatalError("no screen") }
+        switch screenState {
+        case .presence(let presence):
+            verifyTemplateUserProfilePresence(presence: presence)
+        case .longDisplayName(let name):
+            verifyTemplateUserProfileLongName(name: name)
+        }
+    }
+    
+    func verifyTemplateUserProfilePresence(presence: TemplateUserProfilePresence) {
+>>>>>>> ed82cec9f8dd0bb215c2c0d58c3f67649dc64dfb:RiotSwiftUI/Modules/Template/SimpleUserProfileExample/Test/UI/TemplateUserProfileUITests.swift
         let presenceText = app.staticTexts["presenceText"]
         XCTAssert(presenceText.exists)
         XCTAssert(presenceText.label == presence.title)
     }
     
+<<<<<<< HEAD:RiotSwiftUI/Modules/Template/TemplateAdvancedRoomsExample/TemplateRoomChat/Test/UI/TemplateRoomChatUITests.swift
     func verifyTemplateRoomChatLongName(name: String) {
+=======
+    func verifyTemplateUserProfileLongName(name: String) {
+>>>>>>> ed82cec9f8dd0bb215c2c0d58c3f67649dc64dfb:RiotSwiftUI/Modules/Template/SimpleUserProfileExample/Test/UI/TemplateUserProfileUITests.swift
         let displayNameText = app.staticTexts["displayNameText"]
         XCTAssert(displayNameText.exists)
         XCTAssert(displayNameText.label == name)