Allow overriding previous job for SingleInstance constraint (#38)

Author: lucas34

Sources/SwiftQueue/Constraints+UniqueUUID.swift

@@ -11,7 +11,13 @@ internal class UniqueUUIDConstraint: JobConstraint {
 
     func willSchedule(queue: SwiftQueue, operation: SwiftQueueJob) throws {
         for op in queue.operations where op.name == operation.info.uuid {
-            throw TaskAlreadyExist()
+            if operation.info.override {
+                // Cancel previous job
+                queue.cancelOperations(uuid: operation.info.uuid)
+            } else {
+                // Cancel new job
+                throw TaskAlreadyExist()
+            }
         }
     }
 

Sources/SwiftQueue/Job.swift

@@ -16,9 +16,11 @@ public final class JobBuilder {
     }
 
     /// Allow only 1 job at the time with this ID scheduled or running
-    /// Same job scheduled with same id will result in onRemove(TaskAlreadyExist)
-    public func singleInstance(forId: String) -> JobBuilder {
+    /// Same job scheduled with same id will result in onRemove(TaskAlreadyExist) if override = false
+    /// If override = true the previous job will be canceled and the new job will be scheduled
+    public func singleInstance(forId: String, override: Bool = false) -> JobBuilder {
         info.uuid = forId
+        info.override = override
         return self
     }
 

Sources/SwiftQueue/JobInfo.swift

@@ -9,6 +9,8 @@ struct JobInfo {
     let type: String
 
     var uuid: String =  UUID().uuidString
+    var override = false
+
     var group: String = "GLOBAL"
     var tags = Set<String>()
     var delay: TimeInterval?
@@ -31,6 +33,7 @@ struct JobInfo {
     init?(dictionary: [String: Any]) {
         guard let type           = dictionary["type"] as? String,
               let uuid           = dictionary["uuid"] as? String,
+              let override       = dictionary["override"] as? Bool,
               let group          = dictionary["group"] as? String,
               let tags           = dictionary["tags"] as? [String],
               let delay          = dictionary["delay"] as? TimeInterval?,
@@ -52,6 +55,7 @@ struct JobInfo {
 
         self.type = type
         self.uuid = uuid
+        self.override = override
         self.group = group
         self.tags = Set(tags)
         self.delay = delay
@@ -70,6 +74,7 @@ struct JobInfo {
         var dict = [String: Any]()
         dict["type"]           = self.type
         dict["uuid"]           = self.uuid
+        dict["override"]       = self.override
         dict["group"]          = self.group
         dict["tags"]           = Array(self.tags)
         dict["delay"]          = self.delay

Sources/SwiftQueue/SwiftQueue.swift

@@ -94,6 +94,16 @@ internal final class SwiftQueue: OperationQueue {
         }
     }
 
+    func cancelOperations(uuid: String) {
+        operations.flatMap { operation -> SwiftQueueJob? in
+            operation as? SwiftQueueJob
+        }.filter {
+            $0.info.uuid == uuid
+        }.forEach {
+            $0.cancel()
+        }
+    }
+
     private func completed(_ job: SwiftQueueJob) {
         // Remove this operation from serialization
         if job.info.isPersisted, let sp = persister {

Tests/SwiftQueueTests/ConstraintUniqueUUIDTests.swift

@@ -17,30 +17,61 @@ class ConstraintUniqueUUIDTests: XCTestCase {
         let job2 = TestJob()
         let type2 = UUID().uuidString
 
-        let job3 = TestJob()
-        let type3 = UUID().uuidString
-
-        let creator = TestCreator([type1: job1, type2: job2, type3: job3])
+        let creator = TestCreator([type1: job1, type2: job2])
 
         let manager = SwiftQueueManager(creators: [creator])
         JobBuilder(type: type1)
                 .singleInstance(forId: id)
                 .delay(time: 3600)
                 .schedule(manager: manager)
 
-        JobBuilder(type: type2)
+        JobBuilder(type: type2).singleInstance(forId: id).schedule(manager: manager)
+
+        job2.await()
+
+        XCTAssertEqual(job2.onRunJobCalled, 0)
+        XCTAssertEqual(job2.onCompleteCalled, 0)
+        XCTAssertEqual(job2.onRetryCalled, 0)
+        XCTAssertEqual(job2.onCancelCalled, 1)
+
+        XCTAssertTrue(job2.lastError is TaskAlreadyExist)
+
+        manager.cancelAllOperations()
+        manager.waitUntilAllOperationsAreFinished()
+    }
+
+    func testUniqueIdConstraintShouldCancelTheFirst() {
+        let id = UUID().uuidString
+
+        let job1 = TestJob()
+        let type1 = UUID().uuidString
+
+        let job2 = TestJob()
+        let type2 = UUID().uuidString
+
+        let creator = TestCreator([type1: job1, type2: job2])
+
+        let manager = SwiftQueueManager(creators: [creator])
+        JobBuilder(type: type1)
                 .singleInstance(forId: id)
                 .delay(time: 3600)
                 .schedule(manager: manager)
 
-        JobBuilder(type: type3).singleInstance(forId: id).schedule(manager: manager)
+        JobBuilder(type: type2)
+                .singleInstance(forId: id, override: true)
+                .schedule(manager: manager)
+
+        job2.await()
 
-        job3.await()
+        XCTAssertEqual(job1.onRunJobCalled, 0)
+        XCTAssertEqual(job1.onCompleteCalled, 0)
+        XCTAssertEqual(job1.onRetryCalled, 0)
+        XCTAssertEqual(job1.onCancelCalled, 1)
 
-        XCTAssertEqual(job3.onRunJobCalled, 0)
-        XCTAssertEqual(job3.onCompleteCalled, 0)
-        XCTAssertEqual(job3.onRetryCalled, 0)
-        XCTAssertEqual(job3.onCancelCalled, 1)
+        XCTAssertEqual(job2.onRunJobCalled, 1)
+        XCTAssertEqual(job2.onCompleteCalled, 1)
+        XCTAssertEqual(job2.onRetryCalled, 0)
+        XCTAssertEqual(job2.onCancelCalled, 0)
 
         manager.cancelAllOperations()
         manager.waitUntilAllOperationsAreFinished()

Tests/SwiftQueueTests/SwiftQueueBuilderTests.swift

@@ -32,7 +32,7 @@ class SwiftQueueBuilderTests: XCTestCase {
 
         let manager = SwiftQueueManager(creators: [creator], persister: persister)
         JobBuilder(type: type)
-                .singleInstance(forId: taskID)
+                .singleInstance(forId: taskID, override: true)
                 .group(name: group)
                 .addTag(tag: tag)
                 .delay(time: delay)
@@ -53,6 +53,7 @@ class SwiftQueueBuilderTests: XCTestCase {
 
         XCTAssertEqual(actual?.name, taskID)
         XCTAssertEqual(jobInfo?.uuid, taskID)
+        XCTAssertEqual(jobInfo?.override, true)
         XCTAssertEqual(jobInfo?.type, type)
         XCTAssertEqual(jobInfo?.group, group)
         XCTAssertEqual(jobInfo?.tags.first, tag)

Tests/SwiftQueueTests/TestUtils.swift

@@ -12,6 +12,8 @@ class TestJob: Job {
 
     public var result: Error?
 
+    public var lastError: Error?
+
     public var onRunJobCalled = 0
     public var onRetryCalled = 0
     public var onCompleteCalled = 0
@@ -39,6 +41,7 @@ class TestJob: Job {
     }
 
     func onRetry(error: Error) -> RetryConstraint {
+        lastError = error
         onRetryCalled += 1
         return retryConstraint
     }
@@ -49,7 +52,8 @@ class TestJob: Job {
             onCompleteCalled += 1
             semaphore.signal()
 
-        case .fail:
+        case .fail(let error):
+            lastError = error
             onCancelCalled += 1
             semaphore.signal()
         }