fixed: websocket delegate issue

Author: amirhossein7

Sources/web3swift/Web3/Web3+InfuraProviders.swift

@@ -44,6 +44,9 @@ public final class InfuraWebsocketProvider: WebsocketProvider {
     private var subscriptionIDforUnsubscribing: String? = nil
     private var filterTimer: Timer?
 
+    /// if set debugMode True then show websocket events logs in the console
+    public var debugMode: Bool = false
+    
     public init?(_ network: Networks,
                  delegate: Web3SocketDelegate,
                  projectId: String? = nil,
@@ -242,7 +245,48 @@ public final class InfuraWebsocketProvider: WebsocketProvider {
         try writeMessage(method: method, params: params)
     }
 
-    override public func websocketDidReceiveMessage(socket: WebSocketClient, text: String) {
+    /// override WebsocketDelegate
+    override public func didReceive(event: WebSocketEvent, client: WebSocket) {
+        switch event {
+        case .connected(let headers):
+            debugMode ? print("websocket is connected, headers:\n \(headers)") : nil
+            websocketConnected = true
+            delegate.socketConnected(headers)
+        case .disconnected(let reason, let code):
+            debugMode ? print("websocket is disconnected: \(reason) with code: \(code)") : nil
+            websocketConnected = false
+            delegate.gotError(error: Web3Error.connectionError)
+        case .text(let string):
+            debugMode ? print("received text: \(string)") : nil
+            websocketDidReceiveMessage(text: string)
+            break
+        case .binary(let data):
+            debugMode ? print("received text: \(String(data: data, encoding: .utf8) ?? "empty")") : nil
+            delegate.received(message: data)
+        case .ping(_):
+            debugMode ? print("ping") : nil
+            break
+        case .pong(_):
+            debugMode ? print("pong") : nil
+            break
+        case .viabilityChanged(_):
+            debugMode ? print("viabilityChanged") : nil
+            break
+        case .reconnectSuggested(_):
+            debugMode ? print("reconnectSuggested") : nil
+            break
+        case .cancelled:
+            debugMode ? print("cancelled") : nil
+            websocketConnected = false
+            delegate.gotError(error: Web3Error.nodeError(desc: "socket cancelled"))
+        case .error(let error):
+            debugMode ? print("error: \(String(describing: error))") : nil
+            websocketConnected = false
+            delegate.gotError(error: error!)
+        }
+    }
+    
+    private func websocketDidReceiveMessage(text: String) {
         if let data = text.data(using: String.Encoding.utf8),
             let dictionary = try? JSONSerialization.jsonObject(with: data, options: []) as? [String: Any] {
             if filterID == nil,

Sources/web3swift/Web3/Web3+WebsocketProvider.swift

@@ -86,17 +86,14 @@ public struct InfuraWebsocketRequest: Encodable {
 }
 
 public protocol Web3SocketDelegate {
+    func socketConnected(_ headers: [String:String])
     func received(message: Any)
     func gotError(error: Error)
 }
 
 /// The default websocket provider.
 public class WebsocketProvider: Web3Provider, IWebsocketProvider, WebSocketDelegate {
-    
-    public func didReceive(event: WebSocketEvent, client: WebSocket) {
-        
-    }
-    
+
     public func sendAsync(_ request: JSONRPCrequest, queue: DispatchQueue) -> Promise<JSONRPCresponse> {
         return Promise(error: Web3Error.inputError(desc: "Sending is unsupported for Websocket provider. Please, use \'sendMessage\'"))
     }
@@ -116,8 +113,9 @@ public class WebsocketProvider: Web3Provider, IWebsocketProvider, WebSocketDeleg
 
     public var socket: WebSocket
     public var delegate: Web3SocketDelegate
+    /// A flag that is true if socket connected or false if socket doesn't connected.
+    public var websocketConnected: Bool = false
 
-    private var websocketConnected: Bool = false
     private var writeTimer: Timer? = nil
     private var messagesStringToWrite: [String] = []
     private var messagesDataToWrite: [Data] = []
@@ -219,6 +217,10 @@ public class WebsocketProvider: Web3Provider, IWebsocketProvider, WebSocketDeleg
         socket.disconnect()
     }
 
+    public func isConnect() -> Bool {
+        return websocketConnected
+    }
+    
     public class func connectToSocket(_ endpoint: String,
                                       delegate: Web3SocketDelegate,
                                       projectId: String? = nil,
@@ -281,27 +283,34 @@ public class WebsocketProvider: Web3Provider, IWebsocketProvider, WebSocketDeleg
         }
     }
 
-    public func websocketDidReceiveMessage(socket: WebSocketClient, text: String) {
-        print("got some text: \(text)")
-        delegate.received(message: text)
-    }
-    
-    public func websocketDidReceiveData(socket: WebSocketClient, data: Data) {
-        print("got some data: \(data.count)")
-        delegate.received(message: data)
-    }
-    
-    public func websocketDidConnect(socket: WebSocketClient) {
-        print("websocket is connected")
-        websocketConnected = true
-    }
-    
-    public func websocketDidDisconnect(socket: WebSocketClient, error: Error?) {
-        print("websocket is disconnected with \(error?.localizedDescription ?? "no error")")
-        websocketConnected = false
-    }
-    
-    public func websocketDidReceivePong(socket: WebSocketClient, data: Data?) {
-        print("Got pong! Maybe some data: \(String(describing: data?.count))")
+    public func didReceive(event: WebSocketEvent, client: WebSocket) {
+        switch event {
+        case .connected(let headers):
+            websocketConnected = true
+            delegate.socketConnected(headers)
+        case .disconnected(let reason, let code):
+            print("socket disconnected: \(reason) , code: \(code)")
+            websocketConnected = false
+            delegate.gotError(error: Web3Error.connectionError)
+        case .text(let string):
+            delegate.received(message: string)
+            break
+        case .binary(let data):
+            delegate.received(message: data)
+        case .ping(_):
+            break
+        case .pong(_):
+            break
+        case .viabilityChanged(_):
+            break
+        case .reconnectSuggested(_):
+            break
+        case .cancelled:
+            websocketConnected = false
+            delegate.gotError(error: Web3Error.nodeError(desc: "socket cancelled"))
+        case .error(let error):
+            websocketConnected = false
+            delegate.gotError(error: error!)
+        }
     }
 }

Tests/web3swiftTests/infura_tests/web3swift_Websockets_Tests.swift

@@ -21,6 +21,21 @@ class SpyDelegate: Web3SocketDelegate {
     var asyncExpectation: XCTestExpectation?
     var fulfilled = false
 
+    func socketConnected(_ headers: [String:String]) {
+        somethingWithDelegateResult = headers
+        guard let expectation = asyncExpectation else {
+            XCTFail("SpyDelegate was not setup correctly. Missing XCTExpectation reference")
+            return
+        }
+        print("socket connected, headers: \(headers)")
+
+        if !fulfilled {
+            print("fullfilled")
+            fulfilled = true
+            expectation.fulfill()
+        }
+    }
+    
     func received(message: Any) {
         somethingWithDelegateResult = message
         guard let expectation = asyncExpectation else {
@@ -46,6 +61,28 @@ class web3swift_websocket_Tests: XCTestCase {
     let spyDelegate = SpyDelegate()
     var socketProvider: InfuraWebsocketProvider?
 
+    func testSocketConnection(){
+        guard let socketProvider = InfuraWebsocketProvider.connectToInfuraSocket(.Mainnet, delegate: spyDelegate) else {
+            return XCTFail()
+        }
+        self.socketProvider = socketProvider
+        
+        spyDelegate.asyncExpectation = expectation(description: "Delegate called")
+        
+        waitForExpectations(timeout: 1000) { error in
+            if let error = error {
+                XCTFail("waitForExpectationsWithTimeout errored: \(error)")
+            }
+            
+            guard self.spyDelegate.somethingWithDelegateResult != nil else {
+                XCTFail("Expected delegate to be called")
+                return
+            }
+            
+            XCTAssert(true)
+        }
+    }
+    
     func testSubscribeOnPendingTXs() {
         guard let socketProvider = InfuraWebsocketProvider.connectToInfuraSocket(.Mainnet, delegate: spyDelegate) else {
             return XCTFail()