             }
         }
         
+        for operation in internalQueue.operations {
+            guard operation !== finishingOperation && operation !== startingOperation else { continue }
+            
+            completeOperation.addDependency(operation)
+        }
+        
+        completeOperations.append(completeOperation)
         finishingOperation.addDependency(completeOperation)
         internalQueue.addOperation(completeOperation)
+        return self
     }
     
     /// resume all the operations in the queue
-    public final func resume() {
+    @discardableResult
+    public final func resume() -> TaskOperation {
         assert(state == .suspended)
         
         state = .running
         internalQueue.isSuspended = false
-        
-        guard canResume else {
-            cancel()
-            return
-        }
-        
         for observer in taskObservers {
             observer.taskOperationDidResume(self)
         }
         
-        guard internalQueue.operations.contains(finishingOperation) == false else { return }
-        
-        internalQueue.addOperation(finishingOperation)
+        return self
     }
     
     /// suspends all the operations in the current queue
-    public final func suspend() {
+    @discardableResult
+    public final func suspend() -> TaskOperation {
         assert(state == .running)
         
         state = .suspended

    // MARK: Instance methods methods
    
    /// cancels all the current operation in the internal queue
    override open func cancel() {
        assert(state != .cancelled)
        
        state = .cancelled

open class TaskOperation: OperationKit.Operation {
    
    fileprivate let internalQueue = OperationKit.OperationQueue()
    fileprivate var completeOperations: [BlockOperation] = []
    fileprivate let startingOperation = BlockOperation(block: {})
    fileprivate let finishingOperation = BlockOperation(block: {})
    private let lock = NSLock()
    private var _state: State = .suspended
    
    fileprivate var aggregatedErrors = [Error]()
    
    /// the allowed states for the Task
    public enum State {
