Update auth-related code and add new test for encoding channel name

in auth request

Author: hamchapman

Source/PusherConnection.swift

@@ -488,7 +488,7 @@ open class PusherConnection: NSObject {
             } else if let eData =  jsonObject["data"] as? [String: AnyObject] {
                 globalChannel.handleErrorEvent(name: eventName, data: eData)
             }
-    }
+        }
     }
 
     /**
@@ -506,68 +506,68 @@ open class PusherConnection: NSObject {
             subscribeToNormalChannel(channel)
             return true
         } else {
-            if let socketID = self.socketId {
-                switch self.options.authMethod {
-                    case .noMethod:
-                        let errorMessage = "Authentication method required for private / presence channels but none provided."
-                        let error = NSError(domain: "com.pusher.PusherSwift", code: 0, userInfo: [NSLocalizedFailureReasonErrorKey: errorMessage])
+            guard let socketId = self.socketId else {
+                print("socketId value not found. You may not be connected.")
+                return false
+            }
 
-                        print(errorMessage)
+            switch self.options.authMethod {
+            case .noMethod:
+                let errorMessage = "Authentication method required for private / presence channels but none provided."
+                let error = NSError(domain: "com.pusher.PusherSwift", code: 0, userInfo: [NSLocalizedFailureReasonErrorKey: errorMessage])
 
-                        handleAuthorizationError(forChannel: channel.name, response: nil, data: nil, error: error)
+                print(errorMessage)
 
-                        return false
-                    case .endpoint(authEndpoint: let authEndpoint):
-                        let request = requestForAuthValue(from: authEndpoint, socketID: socketID, channel: channel)
-                        sendAuthorisationRequest(request: request, channel: channel, callback: callback)
-                        return true
+                handleAuthorizationError(forChannel: channel.name, response: nil, data: nil, error: error)
 
-                    case .authRequestBuilder(authRequestBuilder: let builder):
-                        if let request = builder.requestFor?(socketID: socketID, channel: channel) {
-                            sendAuthorisationRequest(request: request as URLRequest, channel: channel, callback: callback)
+                return false
+            case .endpoint(authEndpoint: let authEndpoint):
+                let request = requestForAuthValue(from: authEndpoint, socketId: socketId, channelName: channel.name)
+                sendAuthorisationRequest(request: request, channel: channel, callback: callback)
+                return true
 
-                            return true
-                        } else if let request = builder.requestFor?(socketID: socketID, channelName: channel.name) {
-                            sendAuthorisationRequest(request: request, channel: channel, callback: callback)
+            case .authRequestBuilder(authRequestBuilder: let builder):
+                if let request = builder.requestFor?(socketID: socketId, channel: channel) {
+                    sendAuthorisationRequest(request: request as URLRequest, channel: channel, callback: callback)
 
-                            return true
-                        } else {
-                            let errorMessage = "Authentication request could not be built"
-                            let error = NSError(domain: "com.pusher.PusherSwift", code: 0, userInfo: [NSLocalizedFailureReasonErrorKey: errorMessage])
+                    return true
+                } else if let request = builder.requestFor?(socketID: socketId, channelName: channel.name) {
+                    sendAuthorisationRequest(request: request, channel: channel, callback: callback)
 
-                            handleAuthorizationError(forChannel: channel.name, response: nil, data: nil, error: error)
+                    return true
+                } else {
+                    let errorMessage = "Authentication request could not be built"
+                    let error = NSError(domain: "com.pusher.PusherSwift", code: 0, userInfo: [NSLocalizedFailureReasonErrorKey: errorMessage])
 
-                            return false
-                        }
-                    case .inline(secret: let secret):
-                        var msg = ""
-                        var channelData = ""
-                        if channel.type == .presence {
-                            channelData = getUserDataJSON()
-                            msg = "\(self.socketId!):\(channel.name):\(channelData)"
-                        } else {
-                            msg = "\(self.socketId!):\(channel.name)"
-                        }
+                    handleAuthorizationError(forChannel: channel.name, response: nil, data: nil, error: error)
 
-                        let secretBuff: [UInt8] = Array(secret.utf8)
-                        let msgBuff: [UInt8] = Array(msg.utf8)
+                    return false
+                }
+            case .inline(secret: let secret):
+                var msg = ""
+                var channelData = ""
+                if channel.type == .presence {
+                    channelData = getUserDataJSON()
+                    msg = "\(self.socketId!):\(channel.name):\(channelData)"
+                } else {
+                    msg = "\(self.socketId!):\(channel.name)"
+                }
 
-                        if let hmac = try? HMAC(key: secretBuff, variant: .sha256).authenticate(msgBuff) {
-                            let signature = Data(bytes: hmac).toHexString()
-                            let auth = "\(self.key):\(signature)".lowercased()
+                let secretBuff: [UInt8] = Array(secret.utf8)
+                let msgBuff: [UInt8] = Array(msg.utf8)
 
-                            if channel.type == .private {
-                                self.handlePrivateChannelAuth(authValue: auth, channel: channel, callback: callback)
-                            } else {
-                                self.handlePresenceChannelAuth(authValue: auth, channel: channel, channelData: channelData, callback: callback)
-                            }
-                        }
+                if let hmac = try? HMAC(key: secretBuff, variant: .sha256).authenticate(msgBuff) {
+                    let signature = Data(bytes: hmac).toHexString()
+                    let auth = "\(self.key):\(signature)".lowercased()
 
-                        return true
+                    if channel.type == .private {
+                        self.handlePrivateChannelAuth(authValue: auth, channel: channel, callback: callback)
+                    } else {
+                        self.handlePresenceChannelAuth(authValue: auth, channel: channel, channelData: channelData, callback: callback)
+                    }
                 }
-            } else {
-                print("socketId value not found. You may not be connected.")
-                return false
+
+                return true
             }
         }
     }
@@ -614,18 +614,18 @@ open class PusherConnection: NSObject {
      Creates an authentication request for the given authEndpoint
 
         - parameter endpoint: The authEndpoint to which the request will be made
-        - parameter socketID: The socketId of the connection's websocket
+        - parameter socketId: The socketId of the connection's websocket
         - parameter channel:  The PusherChannel to authenticate subsciption for
 
         - returns: URLRequest object to be used by the function making the auth request
     */
-    fileprivate func requestForAuthValue(from endpoint: String, socketID: String, channel: PusherChannel) -> URLRequest {
+    fileprivate func requestForAuthValue(from endpoint: String, socketId: String, channelName: String) -> URLRequest {
         let allowedCharacterSet = CharacterSet(charactersIn: "!*'();:@&=+$,/?%#[] ").inverted
-        let encodedChannelName = channel.name.addingPercentEncoding(withAllowedCharacters: allowedCharacterSet)
+        let encodedChannelName = channelName.addingPercentEncoding(withAllowedCharacters: allowedCharacterSet) ?? channelName
 
         var request = URLRequest(url: URL(string: endpoint)!)
         request.httpMethod = "POST"
-        request.httpBody = "socket_id=\(socketID)&channel_name=\(encodedChannelName!)".data(using: String.Encoding.utf8)
+        request.httpBody = "socket_id=\(socketId)&channel_name=\(encodedChannelName)".data(using: String.Encoding.utf8)
 
         return request
     }

Tests/AuthenticationTests.swift

@@ -59,6 +59,29 @@ class AuthenticationTests: XCTestCase {
         waitForExpectations(timeout: 0.5)
     }
 
+    func testSubscribingToAPrivateChannelShouldMakeARequestToTheAuthEndpointWithAnEncodedChannelName() {
+        let ex = expectation(description: "the channel should be subscribed to successfully")
+        let channelName = "private-reservations-for-venue@venue_id=399edd2d-3f4a-43k9-911c-9e4b6bdf0f16;date=2017-01-13"
+
+        let dummyDelegate = DummyDelegate()
+        dummyDelegate.ex = ex
+        dummyDelegate.testingChannelName = channelName
+        pusher.delegate = dummyDelegate
+
+        if case .endpoint(authEndpoint: let authEndpoint) = pusher.connection.options.authMethod {
+            let jsonData = "{\"auth\":\"testKey123:12345678gfder78ikjbg\"}".data(using: String.Encoding.utf8, allowLossyConversion: false)!
+            let urlResponse = HTTPURLResponse(url: URL(string: "\(authEndpoint)?channel_name=private-reservations-for-venue%40venue_id%3D399ccd2d-3f4a-43c9-803c-9e4b6bdf0f16%3Bdate%3D2017-01-13&socket_id=45481.3166671")!, statusCode: 200, httpVersion: nil, headerFields: nil)
+            MockSession.mockResponse = (jsonData, urlResponse: urlResponse, error: nil)
+            pusher.connection.URLSession = MockSession.shared
+        }
+
+        let chan = pusher.subscribe(channelName)
+        XCTAssertFalse(chan.subscribed, "the channel should not be subscribed")
+        pusher.connect()
+
+        waitForExpectations(timeout: 0.5)
+    }
+
     func testSubscribingToAPrivateChannelShouldCreateAuthSignatureInternally() {
         let options = PusherClientOptions(
             authMethod: .inline(secret: "secret")

Tests/Mocks.swift

@@ -114,6 +114,14 @@ open class MockWebSocket: WebSocket {
                     self.delegate?.websocketDidReceiveMessage(socket: self, text: "{\"event\":\"pusher_internal:subscription_succeeded\",\"channel\":\"private-test-channel\",\"data\":\"{}\"}")
                 }
             )
+        } else if stringContainsElements(string, elements: ["private-reservations-for-venue@venue_id=399edd2d-3f4a-43k9-911c-9e4b6bdf0f16;date=2017-01-13", "pusher:subscribe", "testKey123:12345678gfder78ikjbg"]) {
+            let _ = stubber.stub(
+                functionName: "writeString",
+                args: [string],
+                functionToCall: {
+                    self.delegate?.websocketDidReceiveMessage(socket: self, text: "{\"event\":\"pusher_internal:subscription_succeeded\",\"channel\":\"private-reservations-for-venue@venue_id=399edd2d-3f4a-43k9-911c-9e4b6bdf0f16;date=2017-01-13\",\"data\":\"{}\"}")
+                }
+            )
         } else if stringContainsElements(string, elements: ["test-channel", "pusher:unsubscribe"]) {
             let _ = stubber.stub(
                 functionName: "writeString",