Updated item controller with wrapper handling

sources/VVPSDK.swift

@@ -406,12 +406,13 @@ public struct VVPSDK {
         }
 
         func setupVRMWithNewCore() {
+            let maxRedirectCount = 2
             let createRequest: (URL) -> (URLRequest) = {
                 .init(url: $0, timeoutInterval: hardTimeout)
             }
             let adStartProcessing = StartAdProcessingController(dispatch: dispatcher)
             let startGroupProcessing = StartVRMGroupProcessingController(dispatch: dispatcher)
-            let itemController = VRMItemController(dispatch: dispatcher)
+            let itemController = VRMItemController(maxRedirectCount: maxRedirectCount, dispatch: dispatcher)
             let itemFetchController = FetchVRMItemController(dispatch: dispatcher) { url in
                 return self.ephemeralSession.dataFuture(with: createRequest(url))
                            .map(Network.Parse.successResponseData)

sources/advertisements/VRM New Core/Controllers/VRMItemController.swift

@@ -6,29 +6,41 @@ import PlayerCore
 
 final class VRMItemController {
 
+    let maxRedirectCount: Int
     let dispatch: (PlayerCore.Action) -> Void
 
-    private var startedItems = Set<VRMCore.Item>()
+    private var startedCandidates = Set<ScheduledVRMItems.Candidate>()
+    private var wrapperError = Set<VRMCore.Item>()
 
-    init(dispatch: @escaping (PlayerCore.Action) -> Void ) {
+    init(maxRedirectCount: Int, dispatch: @escaping (PlayerCore.Action) -> Void ) {
+        self.maxRedirectCount = maxRedirectCount
         self.dispatch = dispatch
     }
 
     func process(with state: PlayerCore.State) {
         process(with: state.vrmScheduledItems.items)
     }
 
-    func process(with scheduledItems: Set<VRMCore.Item>) {
-        scheduledItems
-            .subtracting(startedItems)
-            .forEach { item in
-                startedItems.insert(item)
-                switch (item.source) {
-                case let .url(url):
-                    dispatch(VRMCore.startItemFetch(originalItem: item, url: url))
-                case let .vast(vastXML):
-                    dispatch(VRMCore.startItemParsing(originalItem: item, vastXML: vastXML))
+    func process(with scheduledItems: [VRMCore.Item: Set<ScheduledVRMItems.Candidate>]) {
+        scheduledItems.forEach { originalItem, queue in
+            guard queue.count <= maxRedirectCount else {
+                if wrapperError.contains(originalItem) == false {
+                    wrapperError.insert(originalItem)
+                    dispatch(VRMCore.tooManyIndirections(item: originalItem))
                 }
+                return
+            }
+
+            queue.subtracting(startedCandidates)
+                .forEach { candidate in
+                    startedCandidates.insert(candidate)
+                    switch (candidate.source) {
+                    case let .url(url):
+                        dispatch(VRMCore.startItemFetch(originalItem: originalItem, url: url))
+                    case let .vast(vastXML):
+                        dispatch(VRMCore.startItemParsing(originalItem: originalItem, vastXML: vastXML))
+                    }
+            }
         }
     }
 }

sources/advertisements/VRM New Core/Controllers/VRMItemControllerTest.swift

@@ -12,10 +12,15 @@ class VRMItemControllerTest: XCTestCase {
         $0.vastXML == $1.vastXML && $0.originalItem == $1.originalItem
     }
 
+    let wrapperErrorActionComparator = ActionComparator<VRMCore.TooManyIndirections> {
+        $0.item == $1.item
+    }
+
     let fetchActionComparator = ActionComparator<VRMCore.StartItemFetch> {
         $0.url == $1.url && $0.originalItem == $1.originalItem
     }
 
+    let maxRedirectCount = 2
     let url = URL(string: "http://test.com")!
     let vastXML = "VAST String"
     var vastItem: VRMCore.Item!
@@ -45,10 +50,10 @@ class VRMItemControllerTest: XCTestCase {
     func testStartItemsFetching() {
         let dispatch = recorder.hook("compareFetchActions", cmp: fetchActionComparator.compare)
 
-        sut = VRMItemController(dispatch: dispatch)
+        sut = VRMItemController(maxRedirectCount: maxRedirectCount, dispatch: dispatch)
 
         recorder.record {
-            sut.process(with: Set([urlItem]))
+            sut.process(with: [urlItem: Set([.init(source: urlItem.source)])])
         }
 
         recorder.verify {
@@ -59,10 +64,10 @@ class VRMItemControllerTest: XCTestCase {
     func testStartItemsParsing() {
         let dispatch = recorder.hook("testStartItemsParsing", cmp: parseActionComparator.compare)
 
-        sut = VRMItemController(dispatch: dispatch)
+        sut = VRMItemController(maxRedirectCount: maxRedirectCount, dispatch: dispatch)
 
         recorder.record {
-            sut.process(with: Set([vastItem]))
+            sut.process(with: [vastItem: Set([.init(source: vastItem.source)])])
         }
 
         recorder.verify {
@@ -73,11 +78,70 @@ class VRMItemControllerTest: XCTestCase {
     func testDoubleDispatch() {
         let dispatch = recorder.hook("testDoubleDispatch", cmp: parseActionComparator.compare)
 
-        sut = VRMItemController(dispatch: dispatch)
+        sut = VRMItemController(maxRedirectCount: maxRedirectCount, dispatch: dispatch)
+
+        recorder.record {
+            let scheduledQueue: [VRMCore.Item: Set<ScheduledVRMItems.Candidate>] = [vastItem: Set(arrayLiteral: .init(source: vastItem.source))]
+            sut.process(with: scheduledQueue)
+            sut.process(with: scheduledQueue)
+        }
+
+        recorder.verify {
+            sut.dispatch(VRMCore.startItemParsing(originalItem: vastItem, vastXML: vastXML))
+        }
+    }
+
+    func testProcessWrapper() {
+        var compare = parseActionComparator.compare
+        let dispatch = recorder.hook("testProcessWrapper", cmp: { compare($0,$1) })
+
+        sut = VRMItemController(maxRedirectCount: maxRedirectCount, dispatch: dispatch)
+        let first = ScheduledVRMItems.Candidate(source: vastItem.source)
+        let second = ScheduledVRMItems.Candidate(source: .url(url))
+
+        recorder.record {
+            sut.process(with: [vastItem: Set([first])])
+        }
+
+        recorder.verify {
+            sut.dispatch(VRMCore.startItemParsing(originalItem: vastItem, vastXML: vastXML))
+        }
+
+        compare = fetchActionComparator.compare
+
+        recorder.record {
+            sut.process(with: [vastItem: Set([first, second])])
+        }
+
+        recorder.verify {
+            sut.dispatch(VRMCore.startItemFetch(originalItem: vastItem, url: url))
+        }
+    }
+
+    func testMaxRedirectAndNextGroupProcess() {
+        var compare = wrapperErrorActionComparator.compare
+        let dispatch = recorder.hook("testMaxRedirect", cmp: { compare($0,$1) })
+
+        sut = VRMItemController(maxRedirectCount: maxRedirectCount, dispatch: dispatch)
+
+        let queueWithTooManyWrappers = Set<ScheduledVRMItems.Candidate>([.init(source: urlItem.source),
+                                                                         .init(source: .url(URL(string:"http://test1.com")!)),
+                                                                         .init(source: .url(URL(string:"http://test2.com")!))])
+        recorder.record {
+            sut.process(with: [urlItem: queueWithTooManyWrappers])
+            sut.process(with: [urlItem: queueWithTooManyWrappers])
+        }
+
+        recorder.verify {
+            sut.dispatch(VRMCore.tooManyIndirections(item: urlItem))
+        }
+
+        let correctQueue = Set<ScheduledVRMItems.Candidate>([.init(source: vastItem.source)])
+        compare = parseActionComparator.compare
 
         recorder.record {
-            sut.process(with: Set([vastItem]))
-            sut.process(with: Set([vastItem]))
+            sut.process(with: [urlItem: queueWithTooManyWrappers,
+                               vastItem: correctQueue])
         }
 
         recorder.verify {