mirror of
https://github.com/Novaloop-AG/element-x-ios.git
synced 2026-11-05 20:09:04 +00:00
Mauro
268d6c8ead
* Store the notifications switch per account Adds AccountSettings.enableNotifications and moves the app-wide value into the signed in accounts before they're restored: the first account takes it out of the app settings and the others get the same switch, so someone who turned notifications off keeps them off. * Add a notification service to every user session Each account's NotificationService sets its pusher when its notifications are on and deletes it when they're off (appending with multiple accounts), keeps the account's unread count and decides which of its delivered notifications to clear. It asks the NotificationManager, the only owner of the notification center, through actions: remove the notifications matching a rule, request authorization and the unread count. The UserSessionManager connects every live session's service to the manager, and flows and screens use the session's service instead of the manager, which leaves the flow parameters. * Route notifications by account Taps only open rooms of the active account for now, a tap made while restoring only opens once its account is the active one, replies are sent from the account they were made for, and signing out only clears that account's notifications unless it was the last one. The notification extension hides pushes for an account that signed out while other accounts are still signed in. * Turn notifications on and off for each account The notification settings switch is now saved per account, and each account's NotificationService sets or deletes its pusher when it changes, asking for permission when it's turned on. * Apply review suggestions to multi-account notifications Migration - Move the notifications switch with a single per-account migration, like 26.10.1 and 26.10.2, and drop its dedicated test. Notification manager and service - Follow each account's badge count publisher directly, removing the badge count action and the stored counts. - Only reset the badge and unregister from APNs when the last account signs out, as each account already clears its own notifications. - Set up the service's subscriptions in a single setupSubscriptions(). - Rename switchChanged(to:) to enableNotificationsChanged(to:) and pusherConfiguration(identifiers:) to pusherConfiguration(for:). - Build the service without hopping to the main actor, it already runs there. Notification service extension - Check the account's switch in NotificationHandler using the session's settings, and log an error when a push arrives for an account that's turned off. - Always show pushes that match no signed-in account and log an error, so a broken setup stays visible. Other - Store a pending inline reply in a PendingInlineReplyDetails struct. - Assign the chats tab badge with weakAssign. - Make PusherConfiguration Equatable so the pusher test checks it in one expectation. - Clarify the comment about notifications without a receiver. * Print instead of logging before the app hooks run in the NSE A push that matches no signed-in account goes back to printing, as MXLog shouldn't be used before the app hooks have run. The push is still shown so a broken setup stays visible.
893 lines
65 KiB
Swift
893 lines
65 KiB
Swift
//
|
|
// Copyright 2025 Element Creations Ltd.
|
|
// Copyright 2022-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 Combine
|
|
import MatrixRustSDK
|
|
import MatrixRustSDKMocks
|
|
import SwiftUI
|
|
import UIKit
|
|
|
|
class UITestsAppCoordinator: AppCoordinatorProtocol, SecureWindowManagerDelegate {
|
|
private let appSettings: AppSettings
|
|
private let analytics: AnalyticsServiceProtocol
|
|
private let userIndicatorController: UserIndicatorControllerProtocol
|
|
|
|
private let navigationRootCoordinator: NavigationRootCoordinator
|
|
|
|
// periphery:ignore - retaining purpose
|
|
private var mockScreen: MockScreen?
|
|
|
|
// periphery:ignore - retaining purpose
|
|
private var alternateWindowMockScreen: MockScreen?
|
|
|
|
let windowManager: SecureWindowManagerProtocol
|
|
|
|
init(appDelegate: AppDelegate) {
|
|
windowManager = WindowManager(appDelegate: appDelegate)
|
|
// disabling View animations
|
|
UIView.setAnimationsEnabled(false)
|
|
|
|
navigationRootCoordinator = NavigationRootCoordinator()
|
|
|
|
MXLog.configure(currentTarget: "uitests")
|
|
|
|
appSettings = AppSettings.volatile()
|
|
|
|
let analyticsClient = AnalyticsClientMock()
|
|
analyticsClient.isRunning = false
|
|
|
|
analytics = AnalyticsServiceMock(.init())
|
|
userIndicatorController = UserIndicatorController()
|
|
|
|
windowManager.delegate = self
|
|
}
|
|
|
|
func start() {
|
|
guard let screenID = ProcessInfo.testScreenID else { fatalError("Unable to launch with unknown screen.") }
|
|
|
|
let mockScreen = MockScreen(id: screenID,
|
|
windowManager: windowManager,
|
|
navigationRootCoordinator: navigationRootCoordinator,
|
|
appSettings: appSettings,
|
|
analytics: analytics,
|
|
userIndicatorController: userIndicatorController)
|
|
|
|
if let coordinator = mockScreen.coordinator {
|
|
navigationRootCoordinator.setRootCoordinator(coordinator)
|
|
}
|
|
|
|
self.mockScreen = mockScreen
|
|
}
|
|
|
|
func toPresentable() -> AnyView {
|
|
AnyView(navigationRootCoordinator.toPresentable()
|
|
.environment(\.analyticsService, analytics))
|
|
}
|
|
|
|
func handlePotentialPhishingAttempt(url: URL, openURLAction: @escaping (URL) -> Void) -> Bool {
|
|
fatalError("Not implemented.")
|
|
}
|
|
|
|
func handleDeepLink(_ url: URL, isExternalURL: Bool, windowType: SecondaryWindowType?) -> Bool {
|
|
fatalError("Not implemented.")
|
|
}
|
|
|
|
func handleAppRoute(_ appRoute: AppRoute, windowType: SecondaryWindowType?) {
|
|
fatalError("Not implemented.")
|
|
}
|
|
|
|
func handleUserActivity(_ activity: NSUserActivity) {
|
|
fatalError("Not implemented.")
|
|
}
|
|
|
|
func windowManagerDidConfigureWindows(_ windowManager: SecureWindowManagerProtocol) {
|
|
userIndicatorController.window = windowManager.overlayWindow
|
|
|
|
// Set up the alternate window for the App Lock flow coordinator tests.
|
|
guard let screenID = ProcessInfo.testScreenID, screenID == .appLockFlow || screenID == .appLockFlowDisabled else { return }
|
|
let screen = MockScreen(id: screenID == .appLockFlow ? .appLockFlowAlternateWindow : .appLockFlowDisabledAlternateWindow,
|
|
windowManager: windowManager,
|
|
navigationRootCoordinator: navigationRootCoordinator,
|
|
appSettings: appSettings,
|
|
analytics: analytics,
|
|
userIndicatorController: userIndicatorController)
|
|
|
|
guard let coordinator = screen.coordinator else {
|
|
fatalError()
|
|
}
|
|
|
|
windowManager.alternateWindow.rootViewController = UIHostingController(rootView: coordinator.toPresentable().statusBarHidden())
|
|
|
|
alternateWindowMockScreen = screen
|
|
}
|
|
}
|
|
|
|
class MockScreen: Identifiable {
|
|
let id: UITestsScreenIdentifier
|
|
let windowManager: SecureWindowManagerProtocol
|
|
let navigationRootCoordinator: NavigationRootCoordinator
|
|
|
|
private let appSettings: AppSettings
|
|
private let analytics: AnalyticsServiceProtocol
|
|
private let userIndicatorController: UserIndicatorControllerProtocol
|
|
|
|
private var client: UITestsSignalling.Client?
|
|
|
|
private var retainedState = [Any]()
|
|
private var cancellables = Set<AnyCancellable>()
|
|
|
|
init(id: UITestsScreenIdentifier,
|
|
windowManager: SecureWindowManagerProtocol,
|
|
navigationRootCoordinator: NavigationRootCoordinator,
|
|
appSettings: AppSettings,
|
|
analytics: AnalyticsServiceProtocol,
|
|
userIndicatorController: UserIndicatorControllerProtocol) {
|
|
self.id = id
|
|
self.windowManager = windowManager
|
|
self.navigationRootCoordinator = navigationRootCoordinator
|
|
self.appSettings = appSettings
|
|
self.analytics = analytics
|
|
self.userIndicatorController = userIndicatorController
|
|
}
|
|
|
|
lazy var coordinator: CoordinatorProtocol? = {
|
|
switch id {
|
|
case .serverSelection:
|
|
let navigationStackCoordinator = NavigationStackCoordinator()
|
|
let coordinator = ServerSelectionScreenCoordinator(parameters: .init(authenticationService: AuthenticationService.mock,
|
|
authenticationFlow: .login,
|
|
appSettings: appSettings,
|
|
homeserverHistoryManager: HomeserverHistoryManager(appSettings: appSettings),
|
|
userIndicatorController: userIndicatorController))
|
|
navigationStackCoordinator.setRootCoordinator(coordinator)
|
|
return navigationStackCoordinator
|
|
case .authenticationFlow, .provisionedAuthenticationFlow, .singleProviderAuthenticationFlow, .multipleProvidersAuthenticationFlow:
|
|
let appSettings: AppSettings! = appSettings
|
|
|
|
if id == .singleProviderAuthenticationFlow || id == .multipleProvidersAuthenticationFlow {
|
|
let accountProviders: [AccountProvider] = if id == .singleProviderAuthenticationFlow {
|
|
[.managed(serverName: "example.com", baseURL: "https://matrix.example.com")]
|
|
} else {
|
|
[.managed(serverName: "guest.example.com", baseURL: "https://matrix.guest.example.com"),
|
|
.managed(serverName: "example.com", baseURL: "https://matrix.example.com")]
|
|
}
|
|
appSettings.override(accountProviders: accountProviders,
|
|
allowOtherAccountProviders: false,
|
|
hideBrandChrome: false,
|
|
pushGatewayBaseURL: appSettings.pushGatewayBaseURL,
|
|
oAuthRedirectURL: appSettings.oAuthRedirectURL,
|
|
oAuthClientURIPath: appSettings.oAuthClientURIPath,
|
|
websiteURL: appSettings.websiteURL,
|
|
logoURL: appSettings.logoURL,
|
|
copyrightURL: appSettings.copyrightURL,
|
|
acceptableUseURL: appSettings.acceptableUseURL,
|
|
privacyURL: appSettings.privacyURL,
|
|
encryptionURL: appSettings.encryptionURL,
|
|
deviceVerificationURL: appSettings.deviceVerificationURL,
|
|
chatBackupDetailsURL: appSettings.chatBackupDetailsURL,
|
|
identityPinningViolationDetailsURL: appSettings.identityPinningViolationDetailsURL,
|
|
historySharingDetailsURL: appSettings.historySharingDetailsURL,
|
|
elementWebHosts: appSettings.elementWebHosts,
|
|
accountProvisioningHost: appSettings.accountProvisioningHost,
|
|
bugReportApplicationID: appSettings.bugReportApplicationID,
|
|
analyticsTermsURL: appSettings.analyticsTermsURL,
|
|
mapTilerConfiguration: AppSettings.bundledMapTilerConfiguration)
|
|
}
|
|
|
|
let flowCoordinator = AuthenticationFlowCoordinator(authenticationService: AuthenticationService.mock,
|
|
bugReportService: BugReportServiceMock(.init()),
|
|
navigationRootCoordinator: navigationRootCoordinator,
|
|
appMediator: AppMediatorMock(.init()),
|
|
appSettings: appSettings,
|
|
appHooks: AppHooks(),
|
|
userIndicatorController: userIndicatorController)
|
|
flowCoordinator.start()
|
|
retainedState.append(flowCoordinator)
|
|
|
|
if id == .provisionedAuthenticationFlow {
|
|
flowCoordinator.handleAppRoute(.accountProvisioningLink(.init(accountProvider: "example.com", loginHint: nil)), animated: false)
|
|
}
|
|
|
|
return nil
|
|
case .appLockFlow, .appLockFlowDisabled:
|
|
// The tested coordinator is setup below in the alternate window.
|
|
// Here we just return a blank screen to snapshot as the unlocked app.
|
|
return BlankFormCoordinator()
|
|
case .appLockFlowAlternateWindow, .appLockFlowDisabledAlternateWindow:
|
|
let navigationCoordinator = NavigationRootCoordinator()
|
|
|
|
let keychainController = KeychainController(service: .tests, accessGroup: InfoPlistReader.main.keychainAccessGroupIdentifier)
|
|
keychainController.resetSecrets()
|
|
|
|
let context = LAContextMock()
|
|
context.biometryTypeValue = UIDevice.current.isPhone ? .faceID : .touchID // (iPhone 14 & iPad 9th gen)
|
|
context.evaluatePolicyReturnValue = true
|
|
context.evaluatedPolicyDomainStateValue = Data("😎".utf8)
|
|
|
|
let appLockService = AppLockService(keychainController: keychainController,
|
|
appSettings: appSettings,
|
|
context: context)
|
|
|
|
if id == .appLockFlowAlternateWindow {
|
|
let pinCode = "2023"
|
|
guard case .success = appLockService.setupPINCode(pinCode),
|
|
appLockService.unlock(with: pinCode) else {
|
|
fatalError("Failed to preset the PIN code.")
|
|
}
|
|
}
|
|
|
|
let notificationCenter = UITestsNotificationCenter()
|
|
do {
|
|
try notificationCenter.startListening()
|
|
} catch {
|
|
fatalError("Failed to start listening for notifications.")
|
|
}
|
|
|
|
let flowCoordinator = AppLockFlowCoordinator(initialState: .unlocked,
|
|
appLockService: appLockService,
|
|
navigationCoordinator: navigationCoordinator,
|
|
notificationCenter: notificationCenter,
|
|
appSettings: appSettings)
|
|
|
|
flowCoordinator.actions
|
|
.sink { [weak self] action in
|
|
guard let self else { return }
|
|
|
|
switch action {
|
|
case .lockApp:
|
|
windowManager.switchToAlternate()
|
|
case .unlockApp:
|
|
windowManager.switchToMain()
|
|
case .forceLogout:
|
|
break
|
|
}
|
|
}
|
|
.store(in: &cancellables)
|
|
|
|
retainedState.append(flowCoordinator)
|
|
|
|
return navigationCoordinator
|
|
case .appLockSetupFlow, .appLockSetupFlowUnlock, .appLockSetupFlowMandatory:
|
|
let navigationStackCoordinator = NavigationStackCoordinator()
|
|
// The flow expects an existing root coordinator, use a blank form as a placeholder.
|
|
navigationStackCoordinator.setRootCoordinator(BlankFormCoordinator())
|
|
|
|
let keychainController = KeychainController(service: .tests, accessGroup: InfoPlistReader.main.keychainAccessGroupIdentifier)
|
|
keychainController.resetSecrets()
|
|
|
|
let context = LAContextMock()
|
|
context.biometryTypeValue = UIDevice.current.isPhone ? .faceID : .touchID // (iPhone 14 & iPad 9th gen)
|
|
context.evaluatePolicyReturnValue = true
|
|
context.evaluatedPolicyDomainStateValue = Data("😎".utf8)
|
|
|
|
let appLockService = AppLockService(keychainController: keychainController,
|
|
appSettings: appSettings,
|
|
context: context)
|
|
if id == .appLockSetupFlowUnlock, case .failure = appLockService.setupPINCode("2023") {
|
|
fatalError("Failed to pre-set the PIN code")
|
|
}
|
|
|
|
let flow: AppLockSetupFlowCoordinator.PresentationFlow = id == .appLockSetupFlowMandatory ? .onboarding : .settings
|
|
let flowCoordinator = AppLockSetupFlowCoordinator(presentingFlow: flow,
|
|
appLockService: appLockService,
|
|
navigationStackCoordinator: navigationStackCoordinator)
|
|
flowCoordinator.start()
|
|
|
|
retainedState.append(flowCoordinator)
|
|
|
|
return navigationStackCoordinator
|
|
case .bugReport:
|
|
let navigationStackCoordinator = NavigationStackCoordinator()
|
|
let clientProxy = ClientProxyMock(.init(userID: "@mock:client.com", roomSummaryProvider: RoomSummaryProviderMock(.init(state: .loaded(.mockRooms)))))
|
|
let userSession = UserSessionMock(.init(clientProxy: clientProxy))
|
|
let coordinator = BugReportScreenCoordinator(parameters: .init(bugReportService: BugReportServiceMock(.init()),
|
|
userSession: userSession,
|
|
userIndicatorController: nil,
|
|
screenshot: nil,
|
|
isModallyPresented: true))
|
|
navigationStackCoordinator.setRootCoordinator(coordinator)
|
|
return navigationStackCoordinator
|
|
case .roomPlainNoAvatar:
|
|
let navigationStackCoordinator = NavigationStackCoordinator()
|
|
let parameters = RoomScreenCoordinatorParameters(userSession: UserSessionMock(.init()),
|
|
roomProxy: JoinedRoomProxyMock(.init(name: "Some room name", avatarURL: nil)),
|
|
timelineController: TimelineControllerMock(.init()),
|
|
mediaPlayerProvider: MediaPlayerProviderMock(),
|
|
emojiProvider: EmojiProvider(userSettings: .mock()),
|
|
linkMetadataProvider: LinkMetadataProvider(),
|
|
completionSuggestionService: CompletionSuggestionServiceMock(configuration: .init()),
|
|
ongoingCallRoomIDPublisher: .init(.init(nil)),
|
|
appMediator: AppMediatorMock(.init()),
|
|
analytics: analytics,
|
|
composerDraftService: ComposerDraftServiceMock(.init()),
|
|
timelineControllerFactory: TimelineControllerFactoryMock(.init()),
|
|
userIndicatorController: UserIndicatorControllerMock())
|
|
let coordinator = RoomScreenCoordinator(parameters: parameters)
|
|
navigationStackCoordinator.setRootCoordinator(coordinator)
|
|
return navigationStackCoordinator
|
|
case .roomSmallTimeline:
|
|
let navigationStackCoordinator = NavigationStackCoordinator()
|
|
let timelineController = TimelineControllerMock(.init(timelineItems: TimelineFixtures.smallChunk))
|
|
let parameters = RoomScreenCoordinatorParameters(userSession: UserSessionMock(.init()),
|
|
roomProxy: JoinedRoomProxyMock(.init(name: "New room", avatarURL: .mockMXCAvatar)),
|
|
timelineController: timelineController,
|
|
mediaPlayerProvider: MediaPlayerProviderMock(),
|
|
emojiProvider: EmojiProvider(userSettings: .mock()),
|
|
linkMetadataProvider: LinkMetadataProvider(),
|
|
completionSuggestionService: CompletionSuggestionServiceMock(configuration: .init()),
|
|
ongoingCallRoomIDPublisher: .init(.init(nil)),
|
|
appMediator: AppMediatorMock(.init()),
|
|
analytics: analytics,
|
|
composerDraftService: ComposerDraftServiceMock(.init()),
|
|
timelineControllerFactory: TimelineControllerFactoryMock(.init()),
|
|
userIndicatorController: UserIndicatorControllerMock())
|
|
let coordinator = RoomScreenCoordinator(parameters: parameters)
|
|
navigationStackCoordinator.setRootCoordinator(coordinator)
|
|
return navigationStackCoordinator
|
|
case .roomSmallTimelineWithReactions:
|
|
let navigationStackCoordinator = NavigationStackCoordinator()
|
|
let timelineController = TimelineControllerMock(.init(timelineItems: TimelineFixtures.default))
|
|
let parameters = RoomScreenCoordinatorParameters(userSession: UserSessionMock(.init()),
|
|
roomProxy: JoinedRoomProxyMock(.init(name: "New room", avatarURL: .mockMXCAvatar)),
|
|
timelineController: timelineController,
|
|
mediaPlayerProvider: MediaPlayerProviderMock(),
|
|
emojiProvider: EmojiProvider(userSettings: .mock()),
|
|
linkMetadataProvider: LinkMetadataProvider(),
|
|
completionSuggestionService: CompletionSuggestionServiceMock(configuration: .init()),
|
|
ongoingCallRoomIDPublisher: .init(.init(nil)),
|
|
appMediator: AppMediatorMock(.init()),
|
|
analytics: analytics,
|
|
composerDraftService: ComposerDraftServiceMock(.init()),
|
|
timelineControllerFactory: TimelineControllerFactoryMock(.init()), userIndicatorController: UserIndicatorControllerMock())
|
|
let coordinator = RoomScreenCoordinator(parameters: parameters)
|
|
navigationStackCoordinator.setRootCoordinator(coordinator)
|
|
return navigationStackCoordinator
|
|
case .roomSmallTimelineWithReadReceipts:
|
|
let navigationStackCoordinator = NavigationStackCoordinator()
|
|
let timelineController = TimelineControllerMock(.init(timelineItems: TimelineFixtures.smallChunkWithReadReceipts))
|
|
let parameters = RoomScreenCoordinatorParameters(userSession: UserSessionMock(.init()),
|
|
roomProxy: JoinedRoomProxyMock(.init(name: "New room", avatarURL: .mockMXCAvatar)),
|
|
timelineController: timelineController,
|
|
mediaPlayerProvider: MediaPlayerProviderMock(),
|
|
emojiProvider: EmojiProvider(userSettings: .mock()),
|
|
linkMetadataProvider: LinkMetadataProvider(),
|
|
completionSuggestionService: CompletionSuggestionServiceMock(configuration: .init()),
|
|
ongoingCallRoomIDPublisher: .init(.init(nil)),
|
|
appMediator: AppMediatorMock(.init()),
|
|
analytics: analytics,
|
|
composerDraftService: ComposerDraftServiceMock(.init()),
|
|
timelineControllerFactory: TimelineControllerFactoryMock(.init()), userIndicatorController: UserIndicatorControllerMock())
|
|
let coordinator = RoomScreenCoordinator(parameters: parameters)
|
|
navigationStackCoordinator.setRootCoordinator(coordinator)
|
|
return navigationStackCoordinator
|
|
case .roomSmallTimelineIncomingAndSmallPagination:
|
|
let navigationStackCoordinator = NavigationStackCoordinator()
|
|
|
|
let itemProvider = SignallingTimelineItemProviderMock(itemProxies: TimelineFixtures.smallChunkProxies,
|
|
listenForSignals: true)
|
|
itemProvider.backPaginationResponses = [TimelineFixtures.singleMessageChunkProxies]
|
|
itemProvider.incomingItems = [TimelineFixtures.incomingMessageProxy]
|
|
let roomProxy = JoinedRoomProxyMock(.init(name: "Small timeline", avatarURL: .mockMXCAvatar))
|
|
let timelineController = makeSignallingTimelineController(itemProvider: itemProvider, roomProxy: roomProxy)
|
|
let parameters = RoomScreenCoordinatorParameters(userSession: UserSessionMock(.init()),
|
|
roomProxy: roomProxy,
|
|
timelineController: timelineController,
|
|
mediaPlayerProvider: MediaPlayerProviderMock(),
|
|
emojiProvider: EmojiProvider(userSettings: .mock()),
|
|
linkMetadataProvider: LinkMetadataProvider(),
|
|
completionSuggestionService: CompletionSuggestionServiceMock(configuration: .init()),
|
|
ongoingCallRoomIDPublisher: .init(.init(nil)),
|
|
appMediator: AppMediatorMock(.init()),
|
|
analytics: analytics,
|
|
composerDraftService: ComposerDraftServiceMock(.init()),
|
|
timelineControllerFactory: TimelineControllerFactoryMock(.init()), userIndicatorController: UserIndicatorControllerMock())
|
|
let coordinator = RoomScreenCoordinator(parameters: parameters)
|
|
|
|
navigationStackCoordinator.setRootCoordinator(coordinator)
|
|
return navigationStackCoordinator
|
|
case .roomSmallTimelineLargePagination:
|
|
let navigationStackCoordinator = NavigationStackCoordinator()
|
|
|
|
let itemProvider = SignallingTimelineItemProviderMock(itemProxies: TimelineFixtures.smallChunkProxies,
|
|
listenForSignals: true)
|
|
itemProvider.backPaginationResponses = [TimelineFixtures.largeChunkProxies]
|
|
let roomProxy = JoinedRoomProxyMock(.init(name: "Small timeline, paginating", avatarURL: .mockMXCAvatar))
|
|
let timelineController = makeSignallingTimelineController(itemProvider: itemProvider, roomProxy: roomProxy)
|
|
let parameters = RoomScreenCoordinatorParameters(userSession: UserSessionMock(.init()),
|
|
roomProxy: roomProxy,
|
|
timelineController: timelineController,
|
|
mediaPlayerProvider: MediaPlayerProviderMock(),
|
|
emojiProvider: EmojiProvider(userSettings: .mock()),
|
|
linkMetadataProvider: LinkMetadataProvider(),
|
|
completionSuggestionService: CompletionSuggestionServiceMock(configuration: .init()),
|
|
ongoingCallRoomIDPublisher: .init(.init(nil)),
|
|
appMediator: AppMediatorMock(.init()),
|
|
analytics: analytics,
|
|
composerDraftService: ComposerDraftServiceMock(.init()), timelineControllerFactory: TimelineControllerFactoryMock(.init()), userIndicatorController: UserIndicatorControllerMock())
|
|
let coordinator = RoomScreenCoordinator(parameters: parameters)
|
|
|
|
navigationStackCoordinator.setRootCoordinator(coordinator)
|
|
return navigationStackCoordinator
|
|
case .roomLayoutTop:
|
|
let navigationStackCoordinator = NavigationStackCoordinator()
|
|
|
|
let itemProvider = SignallingTimelineItemProviderMock(itemProxies: TimelineFixtures.largeChunkProxies,
|
|
listenForSignals: true)
|
|
itemProvider.backPaginationResponses = [TimelineFixtures.largeChunkProxies]
|
|
let roomProxy = JoinedRoomProxyMock(.init(name: "Large timeline", avatarURL: .mockMXCAvatar))
|
|
let timelineController = makeSignallingTimelineController(itemProvider: itemProvider, roomProxy: roomProxy)
|
|
let parameters = RoomScreenCoordinatorParameters(userSession: UserSessionMock(.init()),
|
|
roomProxy: roomProxy,
|
|
timelineController: timelineController,
|
|
mediaPlayerProvider: MediaPlayerProviderMock(),
|
|
emojiProvider: EmojiProvider(userSettings: .mock()),
|
|
linkMetadataProvider: LinkMetadataProvider(),
|
|
completionSuggestionService: CompletionSuggestionServiceMock(configuration: .init()),
|
|
ongoingCallRoomIDPublisher: .init(.init(nil)),
|
|
appMediator: AppMediatorMock(.init()),
|
|
analytics: analytics,
|
|
composerDraftService: ComposerDraftServiceMock(.init()),
|
|
timelineControllerFactory: TimelineControllerFactoryMock(.init()), userIndicatorController: UserIndicatorControllerMock())
|
|
let coordinator = RoomScreenCoordinator(parameters: parameters)
|
|
|
|
navigationStackCoordinator.setRootCoordinator(coordinator)
|
|
return navigationStackCoordinator
|
|
case .roomLayoutMiddle:
|
|
let navigationStackCoordinator = NavigationStackCoordinator()
|
|
|
|
let itemProvider = SignallingTimelineItemProviderMock(itemProxies: TimelineFixtures.largeChunkProxies,
|
|
listenForSignals: true)
|
|
itemProvider.backPaginationResponses = [TimelineFixtures.largeChunkProxies]
|
|
itemProvider.incomingItems = [TimelineFixtures.incomingMessageProxy]
|
|
let roomProxy = JoinedRoomProxyMock(.init(name: "Large timeline", avatarURL: .mockMXCAvatar))
|
|
let timelineController = makeSignallingTimelineController(itemProvider: itemProvider, roomProxy: roomProxy)
|
|
let parameters = RoomScreenCoordinatorParameters(userSession: UserSessionMock(.init()),
|
|
roomProxy: roomProxy,
|
|
timelineController: timelineController,
|
|
mediaPlayerProvider: MediaPlayerProviderMock(),
|
|
emojiProvider: EmojiProvider(userSettings: .mock()),
|
|
linkMetadataProvider: LinkMetadataProvider(),
|
|
completionSuggestionService: CompletionSuggestionServiceMock(configuration: .init()),
|
|
ongoingCallRoomIDPublisher: .init(.init(nil)),
|
|
appMediator: AppMediatorMock(.init()),
|
|
analytics: analytics,
|
|
composerDraftService: ComposerDraftServiceMock(.init()),
|
|
timelineControllerFactory: TimelineControllerFactoryMock(.init()), userIndicatorController: UserIndicatorControllerMock())
|
|
let coordinator = RoomScreenCoordinator(parameters: parameters)
|
|
|
|
navigationStackCoordinator.setRootCoordinator(coordinator)
|
|
return navigationStackCoordinator
|
|
case .roomLayoutBottom:
|
|
let navigationStackCoordinator = NavigationStackCoordinator()
|
|
|
|
let itemProvider = SignallingTimelineItemProviderMock(itemProxies: TimelineFixtures.largeChunkProxies,
|
|
listenForSignals: true)
|
|
itemProvider.incomingItems = [TimelineFixtures.incomingMessageProxy]
|
|
let roomProxy = JoinedRoomProxyMock(.init(name: "Large timeline", avatarURL: .mockMXCAvatar))
|
|
let timelineController = makeSignallingTimelineController(itemProvider: itemProvider, roomProxy: roomProxy)
|
|
let parameters = RoomScreenCoordinatorParameters(userSession: UserSessionMock(.init()),
|
|
roomProxy: roomProxy,
|
|
timelineController: timelineController,
|
|
mediaPlayerProvider: MediaPlayerProviderMock(),
|
|
emojiProvider: EmojiProvider(userSettings: .mock()),
|
|
linkMetadataProvider: LinkMetadataProvider(),
|
|
completionSuggestionService: CompletionSuggestionServiceMock(configuration: .init()),
|
|
ongoingCallRoomIDPublisher: .init(.init(nil)),
|
|
appMediator: AppMediatorMock(.init()),
|
|
analytics: analytics,
|
|
composerDraftService: ComposerDraftServiceMock(.init()),
|
|
timelineControllerFactory: TimelineControllerFactoryMock(.init()), userIndicatorController: UserIndicatorControllerMock())
|
|
let coordinator = RoomScreenCoordinator(parameters: parameters)
|
|
|
|
navigationStackCoordinator.setRootCoordinator(coordinator)
|
|
return navigationStackCoordinator
|
|
case .roomLayoutHighlight:
|
|
let navigationStackCoordinator = NavigationStackCoordinator()
|
|
|
|
let timelineController = TimelineControllerMock(.init(timelineItems: TimelineFixtures.permalinkChunk))
|
|
let parameters = RoomScreenCoordinatorParameters(userSession: UserSessionMock(.init()),
|
|
roomProxy: JoinedRoomProxyMock(.init(name: "Timeline highlight", avatarURL: .mockMXCAvatar)),
|
|
timelineController: timelineController,
|
|
mediaPlayerProvider: MediaPlayerProviderMock(),
|
|
emojiProvider: EmojiProvider(userSettings: .mock()),
|
|
linkMetadataProvider: LinkMetadataProvider(),
|
|
completionSuggestionService: CompletionSuggestionServiceMock(configuration: .init()),
|
|
ongoingCallRoomIDPublisher: .init(.init(nil)),
|
|
appMediator: AppMediatorMock(.init()),
|
|
analytics: analytics,
|
|
composerDraftService: ComposerDraftServiceMock(.init()),
|
|
timelineControllerFactory: TimelineControllerFactoryMock(.init()), userIndicatorController: UserIndicatorControllerMock())
|
|
let coordinator = RoomScreenCoordinator(parameters: parameters)
|
|
navigationStackCoordinator.setRootCoordinator(coordinator)
|
|
|
|
do {
|
|
let client = try UITestsSignalling.Client(mode: .app)
|
|
client.signals.sink { [weak self] signal in
|
|
guard case .timeline(.focusOnEvent(let eventID)) = signal else { return }
|
|
coordinator.focusOnEvent(.init(eventID: eventID, shouldSetPin: false))
|
|
try? client.send(.success)
|
|
}
|
|
.store(in: &cancellables)
|
|
} catch {
|
|
fatalError("Failure setting up signalling: \(error)")
|
|
}
|
|
|
|
self.client = client
|
|
return navigationStackCoordinator
|
|
case .roomWithDisclosedPolls:
|
|
let navigationStackCoordinator = NavigationStackCoordinator()
|
|
|
|
let timelineController = TimelineControllerMock(.init(timelineItems: TimelineFixtures.disclosedPolls))
|
|
let parameters = RoomScreenCoordinatorParameters(userSession: UserSessionMock(.init()),
|
|
roomProxy: JoinedRoomProxyMock(.init(name: "Polls timeline", avatarURL: .mockMXCAvatar)),
|
|
timelineController: timelineController,
|
|
mediaPlayerProvider: MediaPlayerProviderMock(),
|
|
emojiProvider: EmojiProvider(userSettings: .mock()),
|
|
linkMetadataProvider: LinkMetadataProvider(),
|
|
completionSuggestionService: CompletionSuggestionServiceMock(configuration: .init()),
|
|
ongoingCallRoomIDPublisher: .init(.init(nil)),
|
|
appMediator: AppMediatorMock(.init()),
|
|
analytics: analytics,
|
|
composerDraftService: ComposerDraftServiceMock(.init()),
|
|
timelineControllerFactory: TimelineControllerFactoryMock(.init()), userIndicatorController: UserIndicatorControllerMock())
|
|
let coordinator = RoomScreenCoordinator(parameters: parameters)
|
|
|
|
navigationStackCoordinator.setRootCoordinator(coordinator)
|
|
return navigationStackCoordinator
|
|
case .roomWithUndisclosedPolls:
|
|
let navigationStackCoordinator = NavigationStackCoordinator()
|
|
|
|
let timelineController = TimelineControllerMock(.init(timelineItems: TimelineFixtures.undisclosedPolls))
|
|
let parameters = RoomScreenCoordinatorParameters(userSession: UserSessionMock(.init()),
|
|
roomProxy: JoinedRoomProxyMock(.init(name: "Polls timeline", avatarURL: .mockMXCAvatar)),
|
|
timelineController: timelineController,
|
|
mediaPlayerProvider: MediaPlayerProviderMock(),
|
|
emojiProvider: EmojiProvider(userSettings: .mock()),
|
|
linkMetadataProvider: LinkMetadataProvider(),
|
|
completionSuggestionService: CompletionSuggestionServiceMock(configuration: .init()),
|
|
ongoingCallRoomIDPublisher: .init(.init(nil)),
|
|
appMediator: AppMediatorMock(.init()),
|
|
analytics: analytics,
|
|
composerDraftService: ComposerDraftServiceMock(.init()),
|
|
timelineControllerFactory: TimelineControllerFactoryMock(.init()), userIndicatorController: UserIndicatorControllerMock())
|
|
let coordinator = RoomScreenCoordinator(parameters: parameters)
|
|
|
|
navigationStackCoordinator.setRootCoordinator(coordinator)
|
|
return navigationStackCoordinator
|
|
case .roomWithOutgoingPolls:
|
|
let navigationStackCoordinator = NavigationStackCoordinator()
|
|
|
|
let timelineController = TimelineControllerMock(.init(timelineItems: TimelineFixtures.outgoingPolls))
|
|
let parameters = RoomScreenCoordinatorParameters(userSession: UserSessionMock(.init()),
|
|
roomProxy: JoinedRoomProxyMock(.init(name: "Polls timeline", avatarURL: .mockMXCAvatar)),
|
|
timelineController: timelineController,
|
|
mediaPlayerProvider: MediaPlayerProviderMock(),
|
|
emojiProvider: EmojiProvider(userSettings: .mock()),
|
|
linkMetadataProvider: LinkMetadataProvider(),
|
|
completionSuggestionService: CompletionSuggestionServiceMock(configuration: .init()),
|
|
ongoingCallRoomIDPublisher: .init(.init(nil)),
|
|
appMediator: AppMediatorMock(.init()),
|
|
analytics: analytics,
|
|
composerDraftService: ComposerDraftServiceMock(.init()),
|
|
timelineControllerFactory: TimelineControllerFactoryMock(.init()), userIndicatorController: UserIndicatorControllerMock())
|
|
let coordinator = RoomScreenCoordinator(parameters: parameters)
|
|
|
|
navigationStackCoordinator.setRootCoordinator(coordinator)
|
|
return navigationStackCoordinator
|
|
case .sessionVerification:
|
|
var sessionVerificationControllerProxy = SessionVerificationControllerProxyMock.configureMock(otherDeviceStartsSasVerification: true,
|
|
requestDelay: .seconds(5))
|
|
let parameters = SessionVerificationScreenCoordinatorParameters(sessionVerificationControllerProxy: sessionVerificationControllerProxy,
|
|
flow: .deviceInitiator,
|
|
userSession: UserSessionMock(.init()))
|
|
return SessionVerificationScreenCoordinator(parameters: parameters)
|
|
case .userSessionScreen, .userSessionScreenReply, .userSessionSpacesFlow:
|
|
let userID = "@mock:client.com"
|
|
let userSettings = appSettings.userSettings(for: userID)
|
|
userSettings.account.hasRunIdentityConfirmationOnboarding = true
|
|
userSettings.app.hasRunNotificationPermissionsOnboarding = true
|
|
userSettings.app.analyticsConsentState = .optedOut
|
|
|
|
let roomSummaries: [RoomSummary] = if id == .userSessionSpacesFlow {
|
|
[[RoomSummary].mockSpaceInvites[0]] + .mockRooms
|
|
} else {
|
|
.mockRooms
|
|
}
|
|
|
|
let clientProxy = ClientProxyMock(.init(userID: userID,
|
|
deviceID: "MOCKCLIENT",
|
|
roomSummaryProvider: RoomSummaryProviderMock(.init(state: .loaded(roomSummaries))),
|
|
spaceServiceConfiguration: .init(topLevelSpaces: .mockSpaceList.filter(\.isSpace) + .mockSingleRoom),
|
|
roomPreviews: [SpaceServiceRoom].mockSpaceList.map { RoomPreviewProxyMock(spaceServiceRoom: $0) },
|
|
defaultRoomMembers: .allMembersAsAdmin))
|
|
clientProxy.recentlyVisitedRoomsFilterReturnValue = .mockRooms
|
|
|
|
// The tab bar remains hidden for the non-spaces tests as we don't supply any mock spaces.
|
|
let spaceServiceProxy = SpaceServiceProxyMock(id == .userSessionSpacesFlow ? .populated : .init())
|
|
clientProxy.spaceService = spaceServiceProxy
|
|
|
|
let appMediator = AppMediatorMock(.init())
|
|
appMediator.windowManager = windowManager
|
|
|
|
let itemProvider = SignallingTimelineItemProviderMock(itemProxies: TimelineFixtures.largeChunkProxies)
|
|
|
|
let timelineController = makeSignallingTimelineController(itemProvider: itemProvider,
|
|
roomProxy: JoinedRoomProxyMock(.init()))
|
|
|
|
let timelineControllerFactory = TimelineControllerFactoryMock(.init(timelineController: timelineController))
|
|
|
|
let userSession = UserSessionMock(.init(clientProxy: clientProxy, userSettings: userSettings))
|
|
let flowCoordinator = UserSessionFlowCoordinator(isNewLogin: false,
|
|
navigationRootCoordinator: navigationRootCoordinator,
|
|
appLockService: AppLockService(keychainController: KeychainControllerMock(),
|
|
appSettings: appSettings),
|
|
flowParameters: CommonFlowParameters(userSession: userSession,
|
|
availableSessionsPublisher: .init([.init(userSession: userSession)]),
|
|
bugReportService: BugReportServiceMock(.init()),
|
|
elementCallService: ElementCallServiceMock(.init()),
|
|
timelineControllerFactory: timelineControllerFactory,
|
|
emojiProvider: EmojiProvider(userSettings: userSession.userSettings),
|
|
linkMetadataProvider: LinkMetadataProvider(),
|
|
appMediator: appMediator,
|
|
appHooks: AppHooks(),
|
|
analytics: analytics,
|
|
userIndicatorController: UserIndicatorControllerMock(),
|
|
stateMachineFactory: StateMachineFactory()))
|
|
|
|
flowCoordinator.start()
|
|
|
|
retainedState.append(flowCoordinator)
|
|
|
|
return nil
|
|
case .roomMembersListScreenPendingInvites:
|
|
let navigationStackCoordinator = NavigationStackCoordinator()
|
|
let members: [RoomMemberProxyMock] = [.mockInvitedAlice, .mockBob, .mockCharlie]
|
|
let coordinator = RoomMembersListScreenCoordinator(parameters: .init(userSession: UserSessionMock(.init()),
|
|
roomProxy: JoinedRoomProxyMock(.init(name: "test", members: members)),
|
|
userIndicatorController: userIndicatorController,
|
|
analytics: analytics))
|
|
navigationStackCoordinator.setRootCoordinator(coordinator)
|
|
return navigationStackCoordinator
|
|
case .roomRolesAndPermissionsFlow:
|
|
let navigationStackCoordinator = NavigationStackCoordinator()
|
|
navigationStackCoordinator.setRootCoordinator(BlankFormCoordinator())
|
|
let coordinator = RoomRolesAndPermissionsFlowCoordinator(parameters: .init(roomProxy: JoinedRoomProxyMock(.init(members: .allMembersAsAdmin)),
|
|
mediaProvider: MediaProviderMock(.init()),
|
|
navigationStackCoordinator: navigationStackCoordinator,
|
|
userIndicatorController: userIndicatorController,
|
|
analytics: analytics))
|
|
retainedState.append(coordinator)
|
|
coordinator.start()
|
|
return navigationStackCoordinator
|
|
case .startChatFlow:
|
|
let clientProxy = ClientProxyMock(.init(userID: "@mock:client.com"))
|
|
clientProxy.createRoomNameTopicAccessTypeIsSpaceUserIDsAvatarURLAliasLocalPartReturnValue =
|
|
.success("!new-room:client.com")
|
|
clientProxy.roomForIdentifierClosure = { roomID in .joined(JoinedRoomProxyMock(.init(id: roomID, members: []))) }
|
|
let userSession = UserSessionMock(.init(clientProxy: clientProxy))
|
|
|
|
let userDiscoveryService = UserDiscoveryServiceMock()
|
|
userDiscoveryService.searchProfilesWithReturnValue = .success([.mockBob, .mockBobby])
|
|
|
|
let navigationStackCoordinator = NavigationStackCoordinator()
|
|
let flowCoordinator = StartChatFlowCoordinator(entryPoint: .startChat,
|
|
userDiscoveryService: userDiscoveryService,
|
|
navigationStackCoordinator: navigationStackCoordinator,
|
|
flowParameters: CommonFlowParameters(userSession: userSession,
|
|
availableSessionsPublisher: .init([.init(userSession: userSession)]),
|
|
bugReportService: BugReportServiceMock(.init()),
|
|
elementCallService: ElementCallServiceMock(.init()),
|
|
timelineControllerFactory: TimelineControllerFactoryMock(.init()),
|
|
emojiProvider: EmojiProvider(userSettings: userSession.userSettings),
|
|
linkMetadataProvider: LinkMetadataProvider(),
|
|
appMediator: AppMediatorMock(.init()),
|
|
appHooks: AppHooks(),
|
|
analytics: analytics,
|
|
userIndicatorController: UserIndicatorControllerMock(),
|
|
stateMachineFactory: StateMachineFactory()))
|
|
flowCoordinator.actionsPublisher
|
|
.sink { [weak self] action in
|
|
guard let self else { return }
|
|
switch action {
|
|
case .finished(let roomID):
|
|
navigationRootCoordinator.setSheetCoordinator(nil)
|
|
case .showRoomDirectory:
|
|
break // The test doesn't cover this.
|
|
}
|
|
}
|
|
.store(in: &cancellables)
|
|
|
|
retainedState.append(flowCoordinator)
|
|
flowCoordinator.start()
|
|
|
|
// Use a sheet on top the the placeholder so we can test the dismissal.
|
|
navigationRootCoordinator.setSheetCoordinator(navigationStackCoordinator)
|
|
return PlaceholderScreenCoordinator(hideBrandChrome: false)
|
|
case .createPoll:
|
|
let navigationStackCoordinator = NavigationStackCoordinator()
|
|
let coordinator = PollFormScreenCoordinator(parameters: .init(mode: .new(topic: nil),
|
|
maxNumberOfOptions: 10,
|
|
timelineController: TimelineControllerMock(.init()),
|
|
analytics: analytics,
|
|
userIndicatorController: UserIndicatorControllerMock()))
|
|
navigationStackCoordinator.setRootCoordinator(coordinator)
|
|
return navigationStackCoordinator
|
|
case .encryptionSettings, .encryptionSettingsOutOfSync:
|
|
let recoveryState: SecureBackupRecoveryState = id == .encryptionSettings ? .enabled : .incomplete
|
|
let clientProxy = ClientProxyMock(.init(userID: "@mock:client.com", recoveryState: recoveryState))
|
|
let userSession = UserSessionMock(.init(clientProxy: clientProxy))
|
|
|
|
let navigationStackCoordinator = NavigationStackCoordinator()
|
|
navigationStackCoordinator.setRootCoordinator(BlankFormCoordinator())
|
|
|
|
let coordinator = EncryptionSettingsFlowCoordinator(parameters: .init(userSession: userSession,
|
|
userIndicatorController: UserIndicatorControllerMock(),
|
|
navigationStackCoordinator: navigationStackCoordinator))
|
|
retainedState.append(coordinator)
|
|
coordinator.start()
|
|
|
|
return navigationStackCoordinator
|
|
case .encryptionReset:
|
|
let recoveryState: SecureBackupRecoveryState = id == .encryptionSettings ? .enabled : .incomplete
|
|
let clientProxy = ClientProxyMock(.init(userID: "@mock:client.com", recoveryState: recoveryState))
|
|
let userSession = UserSessionMock(.init(clientProxy: clientProxy))
|
|
|
|
let userIndicatorController = UserIndicatorController()
|
|
userIndicatorController.window = windowManager.overlayWindow
|
|
let navigationStackCoordinator = NavigationStackCoordinator()
|
|
|
|
let coordinator = EncryptionResetFlowCoordinator(parameters: .init(userSession: userSession,
|
|
appMediator: AppMediatorMock(.init()),
|
|
appHooks: AppHooks(),
|
|
userIndicatorController: userIndicatorController,
|
|
navigationStackCoordinator: navigationStackCoordinator,
|
|
windowManger: windowManager))
|
|
|
|
retainedState.append(coordinator)
|
|
coordinator.start()
|
|
|
|
return navigationStackCoordinator
|
|
case .linkNewDevice, .linkNewDeviceWithAppLockPIN:
|
|
let linkMobileProgressSubject: CurrentValueSubject<LinkNewDeviceService.LinkMobileProgress, QRCodeLoginError> = .init(.qrReady(LinkNewDeviceServiceMock.mockQRCodeImage))
|
|
let linkNewDeviceService = LinkNewDeviceServiceMock(.init(linkMobileProgressPublisher: linkMobileProgressSubject.asCurrentValuePublisher()))
|
|
|
|
let clientProxy = ClientProxyMock(.init())
|
|
clientProxy.linkNewDeviceServiceReturnValue = linkNewDeviceService
|
|
let userSession = UserSessionMock(.init(clientProxy: clientProxy))
|
|
|
|
let keychainController = KeychainController(service: .tests, accessGroup: InfoPlistReader.main.keychainAccessGroupIdentifier)
|
|
keychainController.resetSecrets()
|
|
|
|
let context = LAContextMock()
|
|
context.canEvaluatePolicyReturnValue = false // No device passcode in the simulator.
|
|
|
|
let appLockService = AppLockService(keychainController: keychainController, appSettings: appSettings, context: context)
|
|
|
|
// Set an App Lock PIN for the dedicated variant so linking requires it (and forced logout can be tested).
|
|
// Without a PIN the service is disabled, so verification is unavailable and linking proceeds.
|
|
if id == .linkNewDeviceWithAppLockPIN, case .failure = appLockService.setupPINCode("2023") {
|
|
fatalError("Failed to preset the PIN code.")
|
|
}
|
|
|
|
let navigationStackCoordinator = NavigationStackCoordinator()
|
|
let flowCoordinator = LinkNewDeviceFlowCoordinator(navigationStackCoordinator: navigationStackCoordinator,
|
|
appLockService: appLockService,
|
|
flowParameters: CommonFlowParameters(userSession: userSession,
|
|
availableSessionsPublisher: .init([.init(userSession: userSession)]),
|
|
bugReportService: BugReportServiceMock(.init()),
|
|
elementCallService: ElementCallServiceMock(.init()),
|
|
timelineControllerFactory: TimelineControllerFactoryMock(.init()),
|
|
emojiProvider: EmojiProvider(userSettings: userSession.userSettings),
|
|
linkMetadataProvider: LinkMetadataProvider(),
|
|
appMediator: AppMediatorMock(.init()),
|
|
appHooks: AppHooks(),
|
|
analytics: analytics,
|
|
userIndicatorController: UserIndicatorControllerMock(),
|
|
stateMachineFactory: StateMachineFactory()))
|
|
flowCoordinator.actionsPublisher
|
|
.sink { [weak self] action in
|
|
guard let self else { return }
|
|
switch action {
|
|
case .dismiss:
|
|
navigationRootCoordinator.setSheetCoordinator(nil)
|
|
case .requestOAuthAuthorisation, .forceLogout:
|
|
break
|
|
}
|
|
}
|
|
.store(in: &cancellables)
|
|
|
|
retainedState.append(flowCoordinator)
|
|
flowCoordinator.start()
|
|
|
|
// Use a sheet on top the the placeholder so we can test the dismissal.
|
|
navigationRootCoordinator.setSheetCoordinator(navigationStackCoordinator)
|
|
return PlaceholderScreenCoordinator(hideBrandChrome: false)
|
|
case .autoUpdatingTimeline:
|
|
let userID = "@mock:client.com"
|
|
let userSettings = appSettings.userSettings(for: userID)
|
|
userSettings.account.hasRunIdentityConfirmationOnboarding = true
|
|
userSettings.app.hasRunNotificationPermissionsOnboarding = true
|
|
userSettings.app.analyticsConsentState = .optedOut
|
|
let navigationSplitCoordinator = NavigationSplitCoordinator(placeholderCoordinator: PlaceholderScreenCoordinator(hideBrandChrome: false))
|
|
navigationRootCoordinator.setRootCoordinator(navigationSplitCoordinator)
|
|
|
|
let clientProxy = ClientProxyMock(.init(userID: userID, roomSummaryProvider: RoomSummaryProviderMock(.init(state: .loaded(.mockRooms)))))
|
|
let userSession = UserSessionMock(.init(clientProxy: clientProxy, userSettings: userSettings))
|
|
|
|
let roomProxy = JoinedRoomProxyMock(.init(id: "whatever", name: "okay", shouldUseAutoUpdatingTimeline: true))
|
|
|
|
clientProxy.roomForIdentifierReturnValue = .joined(roomProxy)
|
|
|
|
let timelineController = TimelineController(roomProxy: roomProxy,
|
|
timelineProxy: roomProxy.timeline,
|
|
initialFocussedEventID: nil,
|
|
timelineItemFactory: RoomTimelineItemFactory(userID: "@alice:matrix.org",
|
|
attributedStringBuilder: AttributedStringBuilder(mentionBuilder: MentionBuilder()),
|
|
stateEventStringBuilder: RoomStateEventStringBuilder(userID: "@alice:matrix.org")),
|
|
mediaProvider: MediaProviderMock(.init()),
|
|
userSettings: userSettings)
|
|
|
|
let flowCoordinator = ChatsTabFlowCoordinator(navigationSplitCoordinator: navigationSplitCoordinator,
|
|
flowParameters: CommonFlowParameters(userSession: userSession,
|
|
availableSessionsPublisher: .init([.init(userSession: userSession)]),
|
|
bugReportService: BugReportServiceMock(.init()),
|
|
elementCallService: ElementCallServiceMock(.init()),
|
|
timelineControllerFactory: TimelineControllerFactoryMock(.init(timelineController: timelineController)),
|
|
emojiProvider: EmojiProvider(userSettings: userSession.userSettings),
|
|
linkMetadataProvider: LinkMetadataProvider(),
|
|
appMediator: AppMediatorMock(.init()),
|
|
appHooks: AppHooks(),
|
|
analytics: analytics,
|
|
userIndicatorController: UserIndicatorControllerMock(),
|
|
stateMachineFactory: StateMachineFactory()))
|
|
|
|
flowCoordinator.start()
|
|
|
|
retainedState.append(flowCoordinator)
|
|
|
|
return nil
|
|
}
|
|
}()
|
|
|
|
// MARK: - Private
|
|
|
|
private func makeSignallingTimelineController(itemProvider: SignallingTimelineItemProviderMock,
|
|
roomProxy: JoinedRoomProxyMock) -> TimelineController {
|
|
let timelineProxy = TimelineProxyMock(.init(timelineItemProvider: itemProvider))
|
|
|
|
var pendingEditText: String?
|
|
|
|
timelineProxy.sendMessageHtmlInReplyToEventIDIntentionalMentionsClosure = { [weak itemProvider] message, _, _, _ in
|
|
itemProvider?.inject([.mockOwnMessage(message)])
|
|
return .success(())
|
|
}
|
|
|
|
timelineProxy.buildMessageContentForHtmlIntentionalMentionsClosure = { text, _, _ in
|
|
pendingEditText = text
|
|
return RoomMessageEventContentWithoutRelationSDKMock()
|
|
}
|
|
|
|
timelineProxy.editNewContentClosure = { [weak itemProvider] _, _ in
|
|
if let text = pendingEditText {
|
|
itemProvider?.replaceLastItem(with: .mockOwnMessage(text, isEdited: true))
|
|
pendingEditText = nil
|
|
}
|
|
return .success(())
|
|
}
|
|
|
|
return TimelineController(roomProxy: roomProxy,
|
|
timelineProxy: timelineProxy,
|
|
initialFocussedEventID: nil,
|
|
timelineItemFactory: RoomTimelineItemFactory(userID: "@alice:matrix.org",
|
|
attributedStringBuilder: AttributedStringBuilder(mentionBuilder: MentionBuilder()),
|
|
stateEventStringBuilder: RoomStateEventStringBuilder(userID: "@alice:matrix.org")),
|
|
mediaProvider: MediaProviderMock(.init()),
|
|
userSettings: .mock())
|
|
}
|
|
}
|