Merge pull request #795 from Alamofire/feature/manager_initialization

Feature - Manager Initialization

Source/Manager.swift

@@ -114,10 +114,12 @@ public class Manager {
     // MARK: - Lifecycle
 
     /**
-        Initializes the `Manager` instance with the given configuration and server trust policy.
+        Initializes the `Manager` instance with the specified configuration, delegate and server trust policy.
 
         - parameter configuration:            The configuration used to construct the managed session. 
                                               `NSURLSessionConfiguration.defaultSessionConfiguration()` by default.
+        - parameter delegate:                 The delegate used when initializing the session. `SessionDelegate()` by
+                                              default.
         - parameter serverTrustPolicyManager: The server trust policy manager to use for evaluating all server trust 
                                               challenges. `nil` by default.
 
@@ -125,13 +127,42 @@ public class Manager {
     */
     public init(
         configuration: NSURLSessionConfiguration = NSURLSessionConfiguration.defaultSessionConfiguration(),
+        delegate: SessionDelegate = SessionDelegate(),
         serverTrustPolicyManager: ServerTrustPolicyManager? = nil)
     {
-        self.delegate = SessionDelegate()
-        self.session = NSURLSession(configuration: configuration, delegate: self.delegate, delegateQueue: nil)
-        self.session.serverTrustPolicyManager = serverTrustPolicyManager
+        self.delegate = delegate
+        self.session = NSURLSession(configuration: configuration, delegate: delegate, delegateQueue: nil)
 
-        self.delegate.sessionDidFinishEventsForBackgroundURLSession = { [weak self] session in
+        commonInit(serverTrustPolicyManager: serverTrustPolicyManager)
+    }
+
+    /**
+        Initializes the `Manager` instance with the specified session, delegate and server trust policy.
+
+        - parameter session:                  The URL session.
+        - parameter delegate:                 The delegate of the URL session. Must equal the URL session's delegate.
+        - parameter serverTrustPolicyManager: The server trust policy manager to use for evaluating all server trust
+                                              challenges. `nil` by default.
+
+        - returns: The new `Manager` instance if the URL session's delegate matches the delegate parameter.
+    */
+    public init?(
+        session: NSURLSession,
+        delegate: SessionDelegate,
+        serverTrustPolicyManager: ServerTrustPolicyManager? = nil)
+    {
+        self.delegate = delegate
+        self.session = session
+
+        guard delegate === session.delegate else { return nil }
+
+        commonInit(serverTrustPolicyManager: serverTrustPolicyManager)
+    }
+
+    private func commonInit(serverTrustPolicyManager serverTrustPolicyManager: ServerTrustPolicyManager?) {
+        session.serverTrustPolicyManager = serverTrustPolicyManager
+
+        delegate.sessionDidFinishEventsForBackgroundURLSession = { [weak self] session in
             guard let strongSelf = self else { return }
             dispatch_async(dispatch_get_main_queue()) { strongSelf.backgroundCompletionHandler?() }
         }
@@ -219,6 +250,15 @@ public class Manager {
             }
         }
 
+        /**
+            Initializes the `SessionDelegate` instance.
+
+            - returns: The new `SessionDelegate` instance.
+        */
+        public override init() {
+            super.init()
+        }
+
         // MARK: - NSURLSessionDelegate
 
         // MARK: Override Closures

Tests/ManagerTests.swift

@@ -20,11 +20,117 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 
-import Alamofire
+@testable import Alamofire
 import Foundation
 import XCTest
 
 class ManagerTestCase: BaseTestCase {
+
+    // MARK: Initialization Tests
+
+    func testInitializerWithDefaultArguments() {
+        // Given, When
+        let manager = Manager()
+
+        // Then
+        XCTAssertNotNil(manager.session.delegate, "session delegate should not be nil")
+        XCTAssertTrue(manager.delegate === manager.session.delegate, "manager delegate should equal session delegate")
+        XCTAssertNil(manager.session.serverTrustPolicyManager, "session server trust policy manager should be nil")
+    }
+
+    func testInitializerWithSpecifiedArguments() {
+        // Given
+        let configuration = NSURLSessionConfiguration.defaultSessionConfiguration()
+        let delegate = Manager.SessionDelegate()
+        let serverTrustPolicyManager = ServerTrustPolicyManager(policies: [:])
+
+        // When
+        let manager = Manager(
+            configuration: configuration,
+            delegate: delegate,
+            serverTrustPolicyManager: serverTrustPolicyManager
+        )
+
+        // Then
+        XCTAssertNotNil(manager.session.delegate, "session delegate should not be nil")
+        XCTAssertTrue(manager.delegate === manager.session.delegate, "manager delegate should equal session delegate")
+        XCTAssertNotNil(manager.session.serverTrustPolicyManager, "session server trust policy manager should not be nil")
+    }
+
+    func testThatFailableInitializerSucceedsWithDefaultArguments() {
+        // Given
+        let delegate = Manager.SessionDelegate()
+        let session: NSURLSession = {
+            let configuration = NSURLSessionConfiguration.defaultSessionConfiguration()
+            return NSURLSession(configuration: configuration, delegate: delegate, delegateQueue: nil)
+        }()
+
+        // When
+        let manager = Manager(session: session, delegate: delegate)
+
+        // Then
+        if let manager = manager {
+            XCTAssertTrue(manager.delegate === manager.session.delegate, "manager delegate should equal session delegate")
+            XCTAssertNil(manager.session.serverTrustPolicyManager, "session server trust policy manager should be nil")
+        } else {
+            XCTFail("manager should not be nil")
+        }
+    }
+
+    func testThatFailableInitializerSucceedsWithSpecifiedArguments() {
+        // Given
+        let delegate = Manager.SessionDelegate()
+        let session: NSURLSession = {
+            let configuration = NSURLSessionConfiguration.defaultSessionConfiguration()
+            return NSURLSession(configuration: configuration, delegate: delegate, delegateQueue: nil)
+        }()
+
+        let serverTrustPolicyManager = ServerTrustPolicyManager(policies: [:])
+
+        // When
+        let manager = Manager(session: session, delegate: delegate, serverTrustPolicyManager: serverTrustPolicyManager)
+
+        // Then
+        if let manager = manager {
+            XCTAssertTrue(manager.delegate === manager.session.delegate, "manager delegate should equal session delegate")
+            XCTAssertNotNil(manager.session.serverTrustPolicyManager, "session server trust policy manager should not be nil")
+        } else {
+            XCTFail("manager should not be nil")
+        }
+    }
+
+    func testThatFailableInitializerFailsWithWhenDelegateDoesNotEqualSessionDelegate() {
+        // Given
+        let delegate = Manager.SessionDelegate()
+        let session: NSURLSession = {
+            let configuration = NSURLSessionConfiguration.defaultSessionConfiguration()
+            return NSURLSession(configuration: configuration, delegate: Manager.SessionDelegate(), delegateQueue: nil)
+        }()
+
+        // When
+        let manager = Manager(session: session, delegate: delegate)
+
+        // Then
+        XCTAssertNil(manager, "manager should be nil")
+    }
+
+    func testThatFailableInitializerFailsWhenSessionDelegateIsNil() {
+        // Given
+        let delegate = Manager.SessionDelegate()
+        let session: NSURLSession = {
+            let configuration = NSURLSessionConfiguration.defaultSessionConfiguration()
+            return NSURLSession(configuration: configuration, delegate: nil, delegateQueue: nil)
+        }()
+
+        // When
+        let manager = Manager(session: session, delegate: delegate)
+
+        // Then
+        XCTAssertNil(manager, "manager should be nil")
+    }
+
+    // MARK: Start Requests Immediately Tests
+
     func testSetStartRequestsImmediatelyToFalseAndResumeRequest() {
         // Given
         let manager = Alamofire.Manager()
@@ -52,6 +158,8 @@ class ManagerTestCase: BaseTestCase {
         XCTAssertTrue(response?.statusCode == 200, "response status code should be 200")
     }
 
+    // MARK: Deinitialization Tests
+
     func testReleasingManagerWithPendingRequestDeinitializesSuccessfully() {
         // Given
         var manager: Manager? = Alamofire.Manager()