feat(event): 이벤트 상세 딥링크와 OneLink를 연결한다
This commit is contained in:
Yu Sung
@@ -0,0 +1,432 @@
|
||||
import Foundation
|
||||
|
||||
#if EVENT_LINK_SDK_DOUBLE
|
||||
public enum DeepLinkStatus { case found, notFound, failure }
|
||||
public struct DeepLink {
|
||||
public let clickEvent: [String: Any]
|
||||
public init(_ clickEvent: [String: Any]) { self.clickEvent = clickEvent }
|
||||
}
|
||||
public struct DeepLinkResult {
|
||||
public let status: DeepLinkStatus
|
||||
public let deepLink: DeepLink?
|
||||
public init(status: DeepLinkStatus, deepLink: DeepLink? = nil) {
|
||||
self.status = status
|
||||
self.deepLink = deepLink
|
||||
}
|
||||
}
|
||||
public final class AppsFlyerLib {
|
||||
private static let instance = AppsFlyerLib()
|
||||
public static func shared() -> AppsFlyerLib { instance }
|
||||
public var resolvedURLs: [URL] = []
|
||||
public var pushPayloads: [[AnyHashable: Any]] = []
|
||||
public func performOnAppAttribution(with url: URL) { resolvedURLs.append(url) }
|
||||
public func handlePushNotification(_ userInfo: [AnyHashable: Any]) { pushPayloads.append(userInfo) }
|
||||
}
|
||||
#else
|
||||
import Combine
|
||||
import AppsFlyerLib
|
||||
|
||||
typealias ObservableObject = Combine.ObservableObject
|
||||
typealias Published = Combine.Published
|
||||
|
||||
enum AppStep {
|
||||
case splash, main, notificationList, message, audition
|
||||
case eventDetail(eventId: Int)
|
||||
case contentDetail(contentId: Int)
|
||||
case seriesDetail(seriesId: Int)
|
||||
case giftDetail(applicationNo: String)
|
||||
case userCreatorChatRoom(roomId: Int)
|
||||
case creatorChannelCommunityPostDetail(postId: Int)
|
||||
case liveDetail(roomId: Int, onClickParticipant: () -> Void, onClickReservation: () -> Void,
|
||||
onClickStart: () -> Void, onClickCancel: () -> Void)
|
||||
}
|
||||
struct EventItem {}
|
||||
enum OrderType { case KEEP }
|
||||
enum MainChatFilter { case all }
|
||||
enum HomeViewModel { enum CurrentTab { case home } }
|
||||
final class ContentPlayManager {
|
||||
static let shared = ContentPlayManager()
|
||||
func stopAudio() {}
|
||||
}
|
||||
final class ContentPlayerPlayManager {
|
||||
static let shared = ContentPlayerPlayManager()
|
||||
func resetPlayer() {}
|
||||
}
|
||||
extension Notification.Name {
|
||||
static let requestLiveRoomQuitForExternalNavigation = Notification.Name("test-live-quit")
|
||||
}
|
||||
let APPSCHEME = "soda"
|
||||
|
||||
@main
|
||||
enum EventDeepLinkCheck {
|
||||
static var assertions = 0
|
||||
static let state = AppState.shared
|
||||
static let sdk = AppsFlyerLib.shared()
|
||||
|
||||
static func check(_ condition: @autoclosure () -> Bool, _ message: String) {
|
||||
assertions += 1
|
||||
if !condition() {
|
||||
fputs("FAIL: \(message)\n", stderr)
|
||||
exit(1)
|
||||
}
|
||||
}
|
||||
|
||||
static func settle() {
|
||||
RunLoop.main.run(until: Date().addingTimeInterval(0.02))
|
||||
}
|
||||
|
||||
static func reset() {
|
||||
state.cancelExternalNavigation()
|
||||
state.isShowPlayer = false
|
||||
state.pendingDeepLinkAction = nil
|
||||
state.setAppStep(step: .main)
|
||||
settle()
|
||||
sdk.resolvedURLs = []
|
||||
sdk.pushPayloads = []
|
||||
}
|
||||
|
||||
static func isEvent(_ id: Int) -> Bool {
|
||||
if case .eventDetail(let eventId) = state.appStep { return eventId == id }
|
||||
return false
|
||||
}
|
||||
|
||||
static func checkURIs() {
|
||||
for scheme in ["voiceon", "voiceon-test"] {
|
||||
for id in [1, 4_294_967_296, Int.max] {
|
||||
reset()
|
||||
check(AppDeepLinkHandler.handle(urlString: "\(scheme)://event-detail/\(id)"), "event URI accepted: \(scheme), \(id)")
|
||||
settle()
|
||||
check(isEvent(id), "public event detail uses complete 64-bit ID")
|
||||
check(state.navigationPath.count == 1, "one event destination")
|
||||
}
|
||||
}
|
||||
reset()
|
||||
check(AppDeepLinkHandler.handle(urlString: "voiceon:///event-detail/42"), "existing hostless path convention accepted")
|
||||
settle()
|
||||
check(isEvent(42), "hostless event path opens event")
|
||||
|
||||
for root in [AppStep.main, .splash] {
|
||||
for identifier in ["", "abc", "0", "-1", "1.5", "9223372036854775808", "+1", "%20", "%20%31"] {
|
||||
for route in ["voiceon://event-detail/", "voiceon-test:///event-detail/"] {
|
||||
reset()
|
||||
state.setAppStep(step: root)
|
||||
settle()
|
||||
state.pendingDeepLinkAction = .content(contentId: 99)
|
||||
check(!AppDeepLinkHandler.handle(urlString: route + identifier + "?content_id=42&message_id=1"), "invalid reserved event ID cannot fall through: \(identifier)")
|
||||
settle()
|
||||
check(state.navigationPath.isEmpty, "invalid ID preserves current route")
|
||||
if case .content(let contentId)? = state.pendingDeepLinkAction {
|
||||
check(contentId == 99, "invalid ID preserves pending destination")
|
||||
} else { check(false, "invalid ID erased pending destination") }
|
||||
}
|
||||
}
|
||||
}
|
||||
for url in ["voiceon://event/42", "voiceon://?event_id=42", "soda://event-detail/42",
|
||||
"voiceon://event-detail/42/extra?content_id=7", "voiceon://event-detail?message_id=1"] {
|
||||
check(!AppDeepLinkHandler.handle(urlString: url), "event aliases and noncontract scheme rejected")
|
||||
}
|
||||
reset()
|
||||
check(AppDeepLinkHandler.handle(urlString: "soda://content/7"), "existing APPSCHEME route retained")
|
||||
settle()
|
||||
if case .contentDetail(let id) = state.appStep { check(id == 7, "legacy app scheme still navigates") }
|
||||
else { check(false, "legacy app scheme route lost") }
|
||||
print("PASS: exact event URI, 64-bit ID, reserved invalid path and legacy scheme")
|
||||
}
|
||||
|
||||
static func checkOneLinkInputs() {
|
||||
for source in [AppDeepLinkSource.external, .notificationList] {
|
||||
for url in ["https://voiceon.onelink.me/local/synthetic-short",
|
||||
"https://voiceon.onelink.me/local?deep_link_value=event-detail&deep_link_sub5=42",
|
||||
"https://VOICEON.ONELINK.ME:443/local/synthetic-short"] {
|
||||
reset()
|
||||
check(AppDeepLinkHandler.handle(urlString: url, source: source), "OneLink accepted through common ingress")
|
||||
settle()
|
||||
check(sdk.resolvedURLs.map(\.absoluteString) == [url], "original OneLink forwarded to SDK exactly once")
|
||||
check(sdk.pushPayloads.isEmpty, "notification list does not fabricate push")
|
||||
check(state.navigationPath.isEmpty && state.pendingDeepLinkAction == nil, "OneLink query cannot bypass UDL")
|
||||
}
|
||||
}
|
||||
for url in ["http://voiceon.onelink.me/a", "https://voiceon.onelink.me.evil.invalid/a",
|
||||
"https://evilvoiceon.onelink.me/a", "https://voiceon.onelink.me@evil.invalid/a",
|
||||
"https://user@voiceon.onelink.me/a", "https://user:pass@voiceon.onelink.me/a",
|
||||
"https://voiceon.onelink.me:444/a", "https://voiceon.onelink.me./a",
|
||||
"https://other.onelink.me/a", "ftp://voiceon.onelink.me/a"] {
|
||||
reset()
|
||||
check(!AppDeepLinkHandler.handle(urlString: url), "untrusted OneLink rejected: \(url)")
|
||||
settle()
|
||||
check(sdk.resolvedURLs.isEmpty, "rejected URL never sent to SDK")
|
||||
check(state.navigationPath.isEmpty, "rejected URL never navigates")
|
||||
}
|
||||
print("PASS: short/long original SDK delegation, no query bypass, exact HTTPS origin")
|
||||
}
|
||||
|
||||
static func found(_ id: Any, value: String = "event-detail") -> DeepLinkResult {
|
||||
DeepLinkResult(status: .found, deepLink: DeepLink(["deep_link_value": value, "deep_link_sub5": id]))
|
||||
}
|
||||
|
||||
static func checkCallbacksAndPending() {
|
||||
for id in [1, 4_294_967_296, Int.max] {
|
||||
reset()
|
||||
check(AppDeepLinkHandler.handleEventDeepLink(result: found(String(id))), "positive 64-bit UDL ID accepted")
|
||||
settle()
|
||||
check(isEvent(id), "UDL preserves full ID")
|
||||
}
|
||||
reset()
|
||||
state.setAppStep(step: .splash)
|
||||
settle()
|
||||
let data = Data(#"{"deep_link_value":"event-detail","deep_link_sub5":"4294967296","deep_link_sub1":"marketing-pid","deep_link_sub2":"source","deep_link_sub3":"medium","deep_link_sub4":"campaign"}"#.utf8)
|
||||
let decoded = try! JSONSerialization.jsonObject(with: data) as! [String: Any]
|
||||
check(AppDeepLinkHandler.handleEventDeepLink(result: DeepLinkResult(status: .found, deepLink: DeepLink(decoded))), "decoded UDL event accepted")
|
||||
settle()
|
||||
check(state.navigationPath.isEmpty, "cold UDL only stores pending action")
|
||||
for result in [DeepLinkResult(status: .notFound), DeepLinkResult(status: .failure),
|
||||
DeepLinkResult(status: .failure, deepLink: DeepLink(decoded)),
|
||||
DeepLinkResult(status: .found),
|
||||
DeepLinkResult(status: .found, deepLink: DeepLink(["deep_link_value": "event-detail"]))] {
|
||||
check(!AppDeepLinkHandler.handleEventDeepLink(result: result), "failure/notFound/missing object ignored without request correlation")
|
||||
}
|
||||
for id: Any in ["", "bad", "0", "-1", "9223372036854775808", "+1", 42] {
|
||||
check(!AppDeepLinkHandler.handleEventDeepLink(result: found(id)), "UDL validates positive string ID")
|
||||
}
|
||||
for value in ["event", "EVENT-DETAIL", " event-detail", "content", "series", "live", "channel"] {
|
||||
check(!AppDeepLinkHandler.handleEventDeepLink(result: found("42", value: value)), "only exact UDL event kind owned by event path")
|
||||
}
|
||||
settle()
|
||||
if case .eventDetail(let id)? = state.pendingDeepLinkAction {
|
||||
check(id == 4_294_967_296, "invalid callbacks preserve valid pending event")
|
||||
} else { check(false, "UDL pending event missing") }
|
||||
check(AppDeepLinkHandler.handle(urlString: "voiceon://event-detail/41"), "later pending event accepted")
|
||||
check(AppDeepLinkHandler.handle(urlString: "voiceon://event-detail/42"), "latest pending event accepted")
|
||||
settle()
|
||||
if case .eventDetail(let id)? = state.pendingDeepLinkAction { check(id == 42, "single pending slot keeps latest event") }
|
||||
else { check(false, "latest pending event missing") }
|
||||
let action = state.consumePendingDeepLinkAction()!
|
||||
check(state.pendingDeepLinkAction == nil, "splash consumes existing single pending slot")
|
||||
state.setAppStep(step: .main)
|
||||
settle()
|
||||
AppDeepLinkHandler.apply(action: action)
|
||||
AppDeepLinkHandler.apply(action: action)
|
||||
settle()
|
||||
check(isEvent(42) && state.navigationPath.count == 1, "public splash apply does not require token and deduplicates")
|
||||
AppDeepLinkHandler.apply(action: .eventDetail(eventId: 0))
|
||||
AppDeepLinkHandler.apply(action: .eventDetail(eventId: -1))
|
||||
settle()
|
||||
check(isEvent(42) && state.navigationPath.count == 1, "invalid action cannot overwrite current event")
|
||||
print("PASS: decoded UDL, early failures, invalid callbacks, public splash pending/latest intent")
|
||||
}
|
||||
|
||||
static func checkNavigationLifecycle() {
|
||||
reset()
|
||||
state.setAppStep(step: .notificationList)
|
||||
settle()
|
||||
for _ in 0..<20 {
|
||||
check(AppDeepLinkHandler.handle(urlString: "voiceon://event-detail/42", source: .notificationList), "burst event accepted")
|
||||
check(AppDeepLinkHandler.handleEventDeepLink(result: found("42")), "burst UDL accepted")
|
||||
}
|
||||
settle()
|
||||
check(isEvent(42) && state.navigationPath.count == 2, "queued and current duplicate delivery opens only one event without resetting warm root")
|
||||
check(AppDeepLinkHandler.handleEventDeepLink(result: found("42")), "current duplicate recognized")
|
||||
settle()
|
||||
check(state.navigationPath.count == 2, "current event not stacked again")
|
||||
state.back()
|
||||
settle()
|
||||
if case .notificationList = state.appStep { check(true, "back returns to notification list") }
|
||||
else { check(false, "warm route reset notification list") }
|
||||
check(AppDeepLinkHandler.handleEventDeepLink(result: found("42")), "same event deliberately reopened after back")
|
||||
settle()
|
||||
check(isEvent(42) && state.navigationPath.count == 2, "completed guard does not permanently block reopen")
|
||||
|
||||
reset()
|
||||
state.isShowPlayer = true
|
||||
for _ in 0..<10 { _ = AppDeepLinkHandler.handle(urlString: "voiceon://event-detail/43") }
|
||||
settle()
|
||||
check(state.isShowLeaveLiveNavigationDialog && state.navigationPath.isEmpty, "live confirmation waits without navigation")
|
||||
state.cancelExternalNavigation()
|
||||
state.isShowPlayer = false
|
||||
settle()
|
||||
check(state.navigationPath.isEmpty, "cancel then live exit cannot apply stale event")
|
||||
_ = AppDeepLinkHandler.handle(urlString: "voiceon://event-detail/43")
|
||||
settle()
|
||||
check(isEvent(43) && state.navigationPath.count == 1, "same event works after cancellation")
|
||||
|
||||
reset()
|
||||
state.isShowPlayer = true
|
||||
_ = AppDeepLinkHandler.handle(urlString: "voiceon://event-detail/44")
|
||||
_ = AppDeepLinkHandler.handle(urlString: "voiceon://event-detail/45")
|
||||
settle()
|
||||
var quitRequests = 0
|
||||
let observer = NotificationCenter.default.addObserver(forName: .requestLiveRoomQuitForExternalNavigation,
|
||||
object: nil, queue: nil) { _ in quitRequests += 1 }
|
||||
state.confirmExternalNavigation()
|
||||
check(quitRequests == 1 && state.navigationPath.isEmpty, "confirmation requests existing live exit before navigation")
|
||||
state.isShowPlayer = false
|
||||
_ = AppDeepLinkHandler.handleEventDeepLink(result: found("45"))
|
||||
settle()
|
||||
NotificationCenter.default.removeObserver(observer)
|
||||
check(isEvent(45) && state.navigationPath.count == 1, "latest live intent and queued callback navigate once after exit")
|
||||
|
||||
state.isShowPlayer = true
|
||||
_ = AppDeepLinkHandler.handle(urlString: "voiceon://event-detail/44")
|
||||
settle()
|
||||
_ = AppDeepLinkHandler.handle(urlString: "voiceon://event-detail/45")
|
||||
settle()
|
||||
state.isShowPlayer = false
|
||||
settle()
|
||||
check(isEvent(45) && state.navigationPath.count == 1, "latest intent for already-current event replaces live pending without stacking current event")
|
||||
|
||||
reset()
|
||||
state.isShowPlayer = true
|
||||
_ = AppDeepLinkHandler.handle(urlString: "voiceon://event-detail/46")
|
||||
settle()
|
||||
state.requestExternalNavigation(navigationAction: {
|
||||
state.setAppStep(step: .contentDetail(contentId: 7))
|
||||
}, cancelAction: {})
|
||||
state.isShowPlayer = false
|
||||
settle()
|
||||
check(state.navigationPath.count == 1 && !isEvent(46), "other external navigation replaces pending event")
|
||||
state.back()
|
||||
settle()
|
||||
_ = AppDeepLinkHandler.handle(urlString: "voiceon://event-detail/46")
|
||||
settle()
|
||||
check(isEvent(46), "superseded live event releases in-flight guard for deliberate reopen")
|
||||
print("PASS: real async AppState burst/current/back/reopen, live wait/cancel/confirm/latest intent")
|
||||
}
|
||||
|
||||
static func checkMixedQueuedEvents(repeatLatest: Bool) {
|
||||
reset()
|
||||
state.setAppStep(step: .eventDetail(eventId: 45))
|
||||
settle()
|
||||
let originalPath = state.navigationPath
|
||||
let ids = repeatLatest ? [44, 45, 44] : [44, 45]
|
||||
for id in ids {
|
||||
check(AppDeepLinkHandler.handle(urlString: "voiceon://event-detail/\(id)"), "mixed queued event accepted")
|
||||
}
|
||||
settle()
|
||||
if repeatLatest {
|
||||
check(isEvent(44) && state.navigationPath.count == originalPath.count + 1,
|
||||
"current 45 then queued 44->45->44 appends latest 44 exactly once")
|
||||
state.back()
|
||||
settle()
|
||||
check(isEvent(45), "mixed latest event retains original 45 beneath one new destination")
|
||||
} else {
|
||||
check(isEvent(45) && state.navigationPath == originalPath,
|
||||
"current 45 then queued 44->45 preserves 45 and original stack")
|
||||
}
|
||||
state.back()
|
||||
settle()
|
||||
check(AppDeepLinkHandler.handle(urlString: "voiceon://event-detail/45"), "event reopens after skipped mixed intent")
|
||||
settle()
|
||||
check(isEvent(45), "obsolete/no-op completion releases event guard")
|
||||
print("PASS: atomic mixed queued events \(ids)")
|
||||
}
|
||||
|
||||
static func checkCurrentEventBehindLive() {
|
||||
reset()
|
||||
state.setAppStep(step: .eventDetail(eventId: 45))
|
||||
settle()
|
||||
let originalPath = state.navigationPath
|
||||
state.isShowPlayer = true
|
||||
check(AppDeepLinkHandler.handle(urlString: "voiceon://event-detail/45"), "current event link accepted behind live")
|
||||
settle()
|
||||
check(state.isShowLeaveLiveNavigationDialog, "current event behind live still requests leave confirmation")
|
||||
state.cancelExternalNavigation()
|
||||
settle()
|
||||
check(state.isShowPlayer && state.navigationPath == originalPath, "cancel keeps live and current event stack unchanged")
|
||||
|
||||
check(AppDeepLinkHandler.handle(urlString: "voiceon://event-detail/45"), "same current event can reopen confirmation after cancel")
|
||||
settle()
|
||||
check(state.isShowLeaveLiveNavigationDialog, "cancel released event guard for next live request")
|
||||
var quitRequests = 0
|
||||
let observer = NotificationCenter.default.addObserver(forName: .requestLiveRoomQuitForExternalNavigation,
|
||||
object: nil, queue: nil) { _ in quitRequests += 1 }
|
||||
state.confirmExternalNavigation()
|
||||
check(quitRequests == 1 && state.isShowPlayer && state.navigationPath == originalPath,
|
||||
"current event confirmation requests live exit before any route change")
|
||||
state.isShowPlayer = false
|
||||
settle()
|
||||
NotificationCenter.default.removeObserver(observer)
|
||||
check(isEvent(45) && state.navigationPath == originalPath, "confirmed live exit reveals existing event without duplicate push")
|
||||
state.back()
|
||||
settle()
|
||||
_ = AppDeepLinkHandler.handle(urlString: "voiceon://event-detail/45")
|
||||
settle()
|
||||
check(isEvent(45) && state.navigationPath.count == 1, "current event skip on live exit releases guard for later reopen")
|
||||
print("PASS: current event behind live confirm/cancel/reopen without duplicate destination")
|
||||
}
|
||||
|
||||
static func checkPushOwnership() {
|
||||
let https = "https://voiceon.onelink.me/local/synthetic-short"
|
||||
for link in [https, "https://voiceon.onelink.me/local?deep_link_value=event-detail&deep_link_sub5=42"] {
|
||||
reset()
|
||||
let payload: [AnyHashable: Any] = ["deep_link": link, "room_id": "99", "aps": ["alert": "synthetic"], "fixture": "original"]
|
||||
check(AppDeepLinkHandler.handlePushDeepLink(userInfo: payload), "HTTPS push consumed")
|
||||
settle()
|
||||
check(sdk.pushPayloads.count == 1, "HTTPS push SDK invoked once")
|
||||
check(NSDictionary(dictionary: sdk.pushPayloads[0]).isEqual(NSDictionary(dictionary: payload)), "SDK receives actual unchanged userInfo")
|
||||
check(sdk.resolvedURLs.isEmpty && state.navigationPath.isEmpty, "push does not also resolve URL or bypass UDL")
|
||||
check(AppDeepLinkHandler.handleEventDeepLink(result: found("42")), "push UDL accepted")
|
||||
settle()
|
||||
check(isEvent(42), "push UDL enters common event navigation")
|
||||
}
|
||||
reset()
|
||||
check(AppDeepLinkHandler.handlePushDeepLink(userInfo: ["deep_link": " voiceon://event-detail/42 ", "room_id": "99"]), "URI push consumed")
|
||||
settle()
|
||||
check(isEvent(42) && sdk.pushPayloads.isEmpty && sdk.resolvedURLs.isEmpty, "URI push routes directly without SDK")
|
||||
|
||||
for link in ["unknown://other", "https://voiceon.onelink.me.evil.invalid/a", "http://voiceon.onelink.me/a", "https://voiceon.onelink.me:444/a", "voiceon://event-detail/0"] {
|
||||
reset()
|
||||
check(AppDeepLinkHandler.handlePushDeepLink(userInfo: ["deep_link": link, "room_id": "99"]), "unknown nonempty deep_link retains no-legacy-fallback behavior")
|
||||
settle()
|
||||
check(sdk.pushPayloads.isEmpty && sdk.resolvedURLs.isEmpty && state.navigationPath.isEmpty, "unknown push produces no new side effects")
|
||||
}
|
||||
for payload: [AnyHashable: Any] in [["room_id": "99"], ["deep_link": "", "content_id": "7"], ["deep_link": " \n", "channel_id": "8", "message_id": "9"]] {
|
||||
check(!AppDeepLinkHandler.handlePushDeepLink(userInfo: payload), "empty/missing deep_link returns ownership to unchanged legacy flow")
|
||||
}
|
||||
for url: Any in ["voiceon://event-detail/42", https, NSURL(string: https)!, "https://[", " \n"] {
|
||||
reset()
|
||||
check(AppDeepLinkHandler.handlePushDeepLink(userInfo: ["notifly_message_type": "push-notification", "url": url,
|
||||
"deep_link": "voiceon://event-detail/43", "room_id": "99"]), "Notifly URL owns payload including NSURL or malformed nonempty string")
|
||||
settle()
|
||||
check(sdk.pushPayloads.isEmpty && sdk.resolvedURLs.isEmpty && state.navigationPath.isEmpty, "Notifly does not also app-route/AF-route/legacy-route")
|
||||
}
|
||||
reset()
|
||||
check(!AppDeepLinkHandler.handlePushDeepLink(userInfo: ["notifly_message_type": "push-notification", "url": ""]), "empty Notifly URL is not a URL-opening owner")
|
||||
check(!AppDeepLinkHandler.handlePushDeepLink(userInfo: ["notifly_message_type": "other", "url": https]), "other Notifly type does not claim URL ownership")
|
||||
check(AppDeepLinkHandler.handlePushDeepLink(userInfo: ["notifly_message_type": "push-notification", "deep_link": "voiceon://event-detail/42"]), "Notifly marker without URL does not discard standard URI")
|
||||
settle()
|
||||
check(isEvent(42), "marker without URL uses standard URI path")
|
||||
reset()
|
||||
_ = AppDeepLinkHandler.handle(urlString: "voiceon://event-detail/42")
|
||||
settle()
|
||||
check(isEvent(42), "Notifly SDK-opened URI reaches unchanged common ingress")
|
||||
reset()
|
||||
_ = AppDeepLinkHandler.handle(urlString: https)
|
||||
check(sdk.resolvedURLs.map(\.absoluteString) == [https], "Notifly SDK-opened OneLink reaches common UDL resolver")
|
||||
|
||||
reset()
|
||||
state.setAppStep(step: .splash)
|
||||
settle()
|
||||
check(AppDeepLinkHandler.handle(urlString: https, source: .notificationList), "cold notification-list OneLink uses common resolver")
|
||||
check(AppDeepLinkHandler.handleEventDeepLink(result: found("47")), "notification-list decoded event accepted")
|
||||
settle()
|
||||
if case .eventDetail(let id)? = state.pendingDeepLinkAction { check(id == 47, "notification-list UDL honors splash pending gate") }
|
||||
else { check(false, "notification-list UDL lost pending event") }
|
||||
check(state.navigationPath.isEmpty && sdk.pushPayloads.isEmpty, "cold notification list neither navigates early nor fabricates push")
|
||||
print("PASS: production push policy original payload, URI/SDK/Notifly one owner, legacy fallback")
|
||||
}
|
||||
|
||||
static func main() {
|
||||
check(Int.max == 9_223_372_036_854_775_807, "Int must preserve signed 64-bit IDs")
|
||||
let groups = Set(CommandLine.arguments.dropFirst())
|
||||
if groups.isEmpty || groups.contains("uri") { checkURIs() }
|
||||
if groups.isEmpty || groups.contains("onelink") { checkOneLinkInputs() }
|
||||
if groups.isEmpty || groups.contains("callback") { checkCallbacksAndPending() }
|
||||
if groups.isEmpty || groups.contains("lifecycle") { checkNavigationLifecycle() }
|
||||
if groups.isEmpty || groups.contains("mixed-current") { checkMixedQueuedEvents(repeatLatest: false) }
|
||||
if groups.isEmpty || groups.contains("mixed-repeat") { checkMixedQueuedEvents(repeatLatest: true) }
|
||||
if groups.isEmpty || groups.contains("current-live") { checkCurrentEventBehindLive() }
|
||||
if groups.isEmpty || groups.contains("push") { checkPushOwnership() }
|
||||
print("PASS EventDeepLinkCheck assertions=\(assertions)")
|
||||
}
|
||||
}
|
||||
#endif
|
||||
Reference in New Issue
Block a user