Pocket Integration

Cartfile

@@ -3,3 +3,4 @@ github "keefertaylor/TezosCrypto" ~> 2.1
 github "mxcl/PromiseKit" ~> 6.8
 github "keefertaylor/Base58Swift" ~> 2.1
 github "keefertaylor/MnemonicKit" ~> 1.3
+github "pokt-network/pocket-swift-core-carthage"

Cartfile.resolved

@@ -1,8 +1,14 @@
+github "Quick/Nimble" "v8.0.4"
+github "Quick/Quick" "v2.2.0"
+github "RNCryptor/RNCryptor" "5.1.0"
+github "ReactiveX/RxSwift" "4.5.0"
 github "attaswift/BigInt" "v3.1.0"
 github "attaswift/SipHash" "v1.2.2"
 github "jedisct1/swift-sodium" "0.8.0"
+github "jimisaacs/SwiftKeychainWrapper" "65c16da7399dd539322203558160fa349a1e27d3"
 github "keefertaylor/Base58Swift" "2.1.9"
 github "keefertaylor/MnemonicKit" "1.3.10"
 github "keefertaylor/TezosCrypto" "2.1.5"
 github "krzyzanowskim/CryptoSwift" "0.14.0"
 github "mxcl/PromiseKit" "6.12.0"
+github "pokt-network/pocket-swift-core-carthage" "0.0.1"

Tests/TezosKit/PocketNetworkClientTest.swift

@@ -0,0 +1,200 @@
+// Copyright Keefer Taylor, 2019.
+
+@testable import TezosKit
+import XCTest
+
+class PocketNetworkClientTest: XCTestCase {
+    public var networkClient: NetworkClient?
+    public let fakeURLSession = FakeURLSession()
+    public let callbackQueue: DispatchQueue = DispatchQueue(label: "callbackQueue")
+    public var pocket_dev_id = ""
+    // Setup
+    public override func setUp() {
+        super.setUp()
+
+        if let path = Bundle(for: type(of: self)).path(forResource: "ci_config", ofType: "json") {
+            do {
+                let data = try Data(contentsOf: URL(fileURLWithPath: path), options: .mappedIfSafe)
+                let jsonResult = try JSONSerialization.jsonObject(with: data, options: .mutableLeaves)
+                if let jsonResult = jsonResult as? Dictionary<String, AnyObject>, let dev_id = jsonResult["POCKET_DEV_ID"] as? String {
+                    self.pocket_dev_id = dev_id
+                }
+            } catch {
+                print("Failed to retrieve the Pocket DevID with error: \(error)")
+                XCTFail()
+            }
+        }
+        // Initialize PocketNetwork Client
+        networkClient = PocketNetworkClient(
+            devID: self.pocket_dev_id,
+            netID: "MAINNET",
+            callbackQueue: callbackQueue,
+            responseHandler: RPCResponseHandler()
+        )
+    }
+    // test
+    public func testRetrieveNetworkVersion() {
+        let expectation = XCTestExpectation(description: "Completion is Called")
+        // RPC endpoint will resolve to a valid URL.
+        let header = Header.contentTypeApplicationJSON
+        let rpc = RPC(endpoint: "/network/version", headers: [header], responseAdapterClass: StringResponseAdapter.self, payload: nil)
+
+        networkClient?.send(rpc, completion: { (result) in
+            switch result {
+            case .failure:
+                XCTFail()
+            case .success:
+                expectation.fulfill()
+            }
+        })
+
+        wait(for: [expectation], timeout: 10)
+    }
+    public func testCallbackOnCorrectQueueForBadURL() {
+        let expectation = XCTestExpectation(description: "Completion is Called")
+        // RPC endpoint will not resolve to a valid URL.
+        let rpc = RPC(endpoint: "/    /\"test", responseAdapterClass: StringResponseAdapter.self)
+        networkClient?.send(rpc) { _ in
+            if #available(iOS 10, OSX 10.12, *) {
+                dispatchPrecondition(condition: .onQueue(self.callbackQueue))
+            }
+            expectation.fulfill()
+        }
+        wait(for: [expectation], timeout: 10)
+    }
+    public func testCallbackOnCorrectQueue() {
+        let expectation = XCTestExpectation(description: "Completion is Called")
+        let rpc = RPC(endpoint: "/test", responseAdapterClass: StringResponseAdapter.self)
+        networkClient?.send(rpc) { _ in
+            if #available(iOS 10, OSX 10.12, *) {
+                dispatchPrecondition(condition: .onQueue(self.callbackQueue))
+            }
+            expectation.fulfill()
+        }
+        wait(for: [expectation], timeout: 10)
+    }
+    public func testBadEndpointCompletesWithURL() {
+        let expectation = XCTestExpectation(description: "Completion is Called")
+        // RPC endpoint will not resolve to a valid URL.
+        let rpc = RPC(endpoint: "/    /\"test", responseAdapterClass: StringResponseAdapter.self)
+        networkClient?.send(rpc) { result in
+            switch result {
+            case .failure:
+                expectation.fulfill()
+            case .success:
+                XCTFail()
+            }
+        }
+        wait(for: [expectation], timeout: 20)
+    }
+    public func testBadHTTPResponseCompletesWithError() {
+        // Fake URL session has data but has an HTTP error code.
+        fakeURLSession.urlResponse = HTTPURLResponse(
+            url: URL(string: "http://keefertaylor.com")!,
+            statusCode: 400,
+            httpVersion: nil,
+            headerFields: nil
+        )
+        fakeURLSession.data = "SomeString".data(using: .utf8)
+        let expectation = XCTestExpectation(description: "Completion is Called")
+        let rpc = RPC(endpoint: "/test", responseAdapterClass: StringResponseAdapter.self)
+        networkClient?.send(rpc) { result in
+            switch result {
+            case .failure:
+                expectation.fulfill()
+            case .success:
+                XCTFail()
+            }
+        }
+        wait(for: [expectation], timeout: 20)
+    }
+    public func testErrorCompletesWithError() {
+        // Valid HTTP response and data, but error is returned.
+        fakeURLSession.urlResponse = HTTPURLResponse(
+            url: URL(string: "http://keefertaylor.com")!,
+            statusCode: 200,
+            httpVersion: nil,
+            headerFields: nil
+        )
+        fakeURLSession.data = "Result".data(using: .utf8)
+        fakeURLSession.error = TezosKitError(kind: .unknown, underlyingError: nil)
+        // Expectation
+        let expectation = XCTestExpectation(description: "Completion is Called")
+        let rpc = RPC(endpoint: "/test", responseAdapterClass: StringResponseAdapter.self)
+        networkClient?.send(rpc) { result in
+            switch result {
+            case .failure:
+                expectation.fulfill()
+            case .success:
+                XCTFail()
+            }
+        }
+        wait(for: [expectation], timeout: 20)
+    }
+    public func testNilDataCompletesWithError() {
+        // Valid HTTP response, but returned data is nil.
+        fakeURLSession.urlResponse = HTTPURLResponse(
+            url: URL(string: "http://keefertaylor.com")!,
+            statusCode: 200,
+            httpVersion: nil,
+            headerFields: nil
+        )
+        // Expectation
+        let expectation = XCTestExpectation(description: "Completion is Called")
+        let rpc = RPC(endpoint: "/test", responseAdapterClass: StringResponseAdapter.self)
+        networkClient?.send(rpc) { result in
+            switch result {
+            case .failure:
+                expectation.fulfill()
+            case .success:
+                XCTFail()
+            }
+        }
+        wait(for: [expectation], timeout: 10)
+    }
+    public func testInocrrectDataCompletesWithError() {
+        // Response is a string but RPC attempts to decode to an int.
+        fakeURLSession.urlResponse = HTTPURLResponse(
+            url: URL(string: "http://keefertaylor.com")!,
+            statusCode: 200,
+            httpVersion: nil,
+            headerFields: nil
+        )
+        // Expectation
+        let expectation = XCTestExpectation(description: "Completion is Called")
+        let rpc = RPC(endpoint: "/test", responseAdapterClass: IntegerResponseAdapter.self)
+        networkClient?.send(rpc) { result in
+            switch result {
+            case .failure:
+                expectation.fulfill()
+            case .success:
+                XCTFail()
+            }
+        }
+        wait(for: [expectation], timeout: 10)
+    }
+    public func testRequestCompletesWithResultAndNoError() {
+        // A valid response with not HTTP error.
+        let expectedString = "Expected!"
+        fakeURLSession.urlResponse = HTTPURLResponse(
+            url: URL(string: "http://keefertaylor.com")!,
+            statusCode: 200,
+            httpVersion: nil,
+            headerFields: nil
+        )
+        fakeURLSession.data = expectedString.data(using: .utf8)
+        // Expectation
+        let expectation = XCTestExpectation(description: "Completion is Called")
+        let rpc = RPC(endpoint: "/test", responseAdapterClass: StringResponseAdapter.self)
+        networkClient?.send(rpc) { result in
+            switch result {
+            case .failure:
+                XCTFail()
+            case .success(let data):
+                XCTAssertEqual(data, expectedString)
+                expectation.fulfill()
+            }
+        }
+        wait(for: [expectation], timeout: 10)
+    }
+}

TezosKit.podspec

@@ -15,24 +15,25 @@ Pod::Spec.new do |s|
   s.ios.deployment_target = "10.0"
   s.osx.deployment_target = "10.14"
   s.default_subspecs = 'TezosKitCore', 'TezosKitPromises'
-  
+
   s.subspec 'TezosKitCore' do |ss|
       ss.source_files = "TezosKit/**/*.swift"
       ss.frameworks = 'Foundation'
-    
+
       ss.ios.deployment_target = '10.0'
       ss.osx.deployment_target = '10.14'
 
       ss.dependency "BigInt", "~> 3.1"
       ss.dependency "MnemonicKit", "~> 1.3"
       ss.dependency "TezosCrypto", "~> 2.1"
       ss.dependency "Base58Swift", "~> 2.1"
+      ss.dependency "PocketSwift-Core"
   end
-  
+
   s.subspec 'TezosKitPromises' do |ss|
       ss.source_files = "Extensions/PromiseKit/*.swift"
       ss.frameworks = 'Foundation'
-    
+
       ss.ios.deployment_target = '10.0'
       ss.osx.deployment_target = '10.14'
 
@@ -42,5 +43,5 @@ Pod::Spec.new do |s|
 
   s.test_spec "Tests" do |test_spec|
     test_spec.source_files = ["Tests/*.swift", "Tests/TezosKit/*.swift", "Tests/Extensions/PromiseKit/*.swift"]
-  end    
+  end
 end