249 lines
10 KiB
Swift
249 lines
10 KiB
Swift
//
|
|
// BlockStreamingTest.swift
|
|
// ZcashLightClientKit-Unit-Tests
|
|
//
|
|
// Created by Francisco Gindre on 5/25/21.
|
|
//
|
|
|
|
import XCTest
|
|
@testable import ZcashLightClientKit
|
|
class BlockStreamingTest: XCTestCase {
|
|
var queue: OperationQueue = {
|
|
let q = OperationQueue()
|
|
q.maxConcurrentOperationCount = 1
|
|
return q
|
|
}()
|
|
override func setUpWithError() throws {
|
|
// Put setup code here. This method is called before the invocation of each test method in the class.
|
|
logger = SampleLogger(logLevel: .debug)
|
|
}
|
|
|
|
override func tearDownWithError() throws {
|
|
// Put teardown code here. This method is called after the invocation of each test method in the class.
|
|
try? FileManager.default.removeItem(at: __dataDbURL())
|
|
}
|
|
|
|
func testExample() throws {
|
|
let expectation = XCTestExpectation(description: "blockstream expectation")
|
|
|
|
let service = LightWalletGRPCService(host: Constants.address,
|
|
port: 9067,
|
|
secure: true,
|
|
singleCallTimeout: Int64.max,
|
|
streamingCallTimeout: 1000)
|
|
|
|
|
|
let latestHeight = try service.latestBlockHeight()
|
|
|
|
let startHeight = latestHeight - 100_000
|
|
var blocks = [ZcashCompactBlock]()
|
|
service.blockStream(startHeight: startHeight, endHeight: latestHeight) { result in
|
|
expectation.fulfill()
|
|
switch result {
|
|
case .success(let status):
|
|
XCTAssertEqual(GRPCResult.ok, status)
|
|
case .failure(let error):
|
|
XCTFail("failed with error: \(error)")
|
|
}
|
|
} handler: { compactBlock in
|
|
print("received block \(compactBlock.height)")
|
|
blocks.append(compactBlock)
|
|
} progress: { progressReport in
|
|
print("progressHeight: \(progressReport.progressHeight) startHeight: \(progressReport.startHeight), targetHeight: \(progressReport.targetHeight)")
|
|
}
|
|
wait(for: [expectation], timeout: 1000)
|
|
}
|
|
|
|
|
|
func testStreamOperation() throws {
|
|
let expectation = XCTestExpectation(description: "blockstream expectation")
|
|
|
|
let service = LightWalletGRPCService(host: Constants.address,
|
|
port: 9067,
|
|
secure: true,
|
|
singleCallTimeout: 1000,
|
|
streamingCallTimeout: 1000)
|
|
let storage = try TestDbBuilder.inMemoryCompactBlockStorage()
|
|
|
|
let startHeight = try service.latestBlockHeight() - 100_000
|
|
let operation = CompactBlockStreamDownloadOperation(service: service,
|
|
storage: storage,
|
|
startHeight: startHeight,
|
|
progressDelegate: self)
|
|
|
|
operation.completionHandler = { (finished, cancelled) in
|
|
if cancelled {
|
|
XCTFail("operation cancelled")
|
|
}
|
|
expectation.fulfill()
|
|
}
|
|
|
|
operation.errorHandler = { error in
|
|
XCTFail("failed with error: \(error)")
|
|
expectation.fulfill()
|
|
}
|
|
|
|
queue.addOperation(operation)
|
|
|
|
wait(for: [expectation], timeout: 1000)
|
|
}
|
|
|
|
func testStreamOperationCancellation() throws {
|
|
let expectation = XCTestExpectation(description: "blockstream expectation")
|
|
|
|
let service = LightWalletGRPCService(host: Constants.address,
|
|
port: 9067,
|
|
secure: true,
|
|
singleCallTimeout: 10000,
|
|
streamingCallTimeout: 10000)
|
|
let storage = try TestDbBuilder.inMemoryCompactBlockStorage()
|
|
|
|
let startHeight = try service.latestBlockHeight() - 100_000
|
|
let operation = CompactBlockStreamDownloadOperation(service: service,
|
|
storage: storage,
|
|
startHeight: startHeight,
|
|
progressDelegate: self)
|
|
|
|
operation.completionHandler = { (finished, cancelled) in
|
|
XCTAssert(cancelled)
|
|
expectation.fulfill()
|
|
}
|
|
|
|
operation.errorHandler = { error in
|
|
XCTFail("failed with error: \(error)")
|
|
expectation.fulfill()
|
|
}
|
|
|
|
queue.addOperation(operation)
|
|
DispatchQueue.main.asyncAfter(deadline: .now() + 3, execute: {
|
|
self.queue.cancelAllOperations()
|
|
})
|
|
wait(for: [expectation], timeout: 1000)
|
|
}
|
|
|
|
func testStreamOperationTimeout() throws {
|
|
let expectation = XCTestExpectation(description: "blockstream expectation")
|
|
let errorExpectation = XCTestExpectation(description: "blockstream error expectation")
|
|
let service = LightWalletGRPCService(host: Constants.address,
|
|
port: 9067,
|
|
secure: true,
|
|
singleCallTimeout: 1000,
|
|
streamingCallTimeout: 3000)
|
|
let storage = try TestDbBuilder.inMemoryCompactBlockStorage()
|
|
|
|
let startHeight = try service.latestBlockHeight() - 100_000
|
|
let operation = CompactBlockStreamDownloadOperation(service: service,
|
|
storage: storage,
|
|
startHeight: startHeight,
|
|
progressDelegate: self)
|
|
|
|
operation.completionHandler = { (finished, cancelled) in
|
|
XCTAssert(finished)
|
|
|
|
expectation.fulfill()
|
|
}
|
|
|
|
operation.errorHandler = { error in
|
|
if let lwdError = error as? LightWalletServiceError {
|
|
switch lwdError {
|
|
case .timeOut:
|
|
XCTAssert(true)
|
|
default:
|
|
XCTFail("LWD Service erro found, but should have been a timeLimit reached Error")
|
|
}
|
|
} else {
|
|
XCTFail("Error should have been a timeLimit reached Error")
|
|
}
|
|
errorExpectation.fulfill()
|
|
}
|
|
|
|
queue.addOperation(operation)
|
|
let date = Date()
|
|
wait(for: [errorExpectation], timeout: 4)
|
|
let now = Date()
|
|
|
|
let elapsed = now.distance(to: date)
|
|
print("took \(elapsed) seconds")
|
|
}
|
|
|
|
func testPerformanceExample() throws {
|
|
// This is an example of a performance test case.
|
|
self.measure {
|
|
// Put the code you want to measure the time of here.
|
|
}
|
|
}
|
|
|
|
func testBatchOperation() throws {
|
|
let expectation = XCTestExpectation(description: "blockbatch expectation")
|
|
|
|
let service = LightWalletGRPCService(host: Constants.address,
|
|
port: 9067,
|
|
secure: true,
|
|
singleCallTimeout: 300000,
|
|
streamingCallTimeout: 10000)
|
|
let storage = try TestDbBuilder.diskCompactBlockStorage(at: __dataDbURL() )
|
|
let targetHeight = try service.latestBlockHeight()
|
|
let startHeight = targetHeight - 100_000
|
|
let operation = CompactBlockBatchDownloadOperation(service: service,
|
|
storage: storage,
|
|
startHeight: startHeight, targetHeight: targetHeight,
|
|
progressDelegate: self)
|
|
|
|
operation.completionHandler = { (finished, cancelled) in
|
|
if cancelled {
|
|
XCTFail("operation cancelled")
|
|
}
|
|
expectation.fulfill()
|
|
}
|
|
|
|
operation.errorHandler = { error in
|
|
XCTFail("failed with error: \(error)")
|
|
expectation.fulfill()
|
|
}
|
|
|
|
queue.addOperation(operation)
|
|
|
|
wait(for: [expectation], timeout: 300)
|
|
}
|
|
|
|
func testBatchOperationCancellation() throws {
|
|
let expectation = XCTestExpectation(description: "blockbatch expectation")
|
|
|
|
let service = LightWalletGRPCService(host: Constants.address,
|
|
port: 9067,
|
|
secure: true,
|
|
singleCallTimeout: 300000,
|
|
streamingCallTimeout: 10000)
|
|
let storage = try TestDbBuilder.diskCompactBlockStorage(at: __dataDbURL() )
|
|
let targetHeight = try service.latestBlockHeight()
|
|
let startHeight = targetHeight - 100_000
|
|
let operation = CompactBlockBatchDownloadOperation(service: service,
|
|
storage: storage,
|
|
startHeight: startHeight, targetHeight: targetHeight,
|
|
progressDelegate: self)
|
|
|
|
operation.completionHandler = { (finished, cancelled) in
|
|
XCTAssert(cancelled)
|
|
expectation.fulfill()
|
|
}
|
|
|
|
operation.errorHandler = { error in
|
|
XCTFail("failed with error: \(error)")
|
|
expectation.fulfill()
|
|
}
|
|
|
|
queue.addOperation(operation)
|
|
DispatchQueue.main.asyncAfter(deadline: .now() + 3, execute: {
|
|
self.queue.cancelAllOperations()
|
|
})
|
|
wait(for: [expectation], timeout: 1000)
|
|
}
|
|
}
|
|
|
|
extension BlockStreamingTest: CompactBlockProgressDelegate {
|
|
|
|
func progressUpdated(_ progress: CompactBlockProgress) {
|
|
// print("progressHeight: \(progress.progressHeight) startHeight: \(progress.startHeight), targetHeight: \(progress.targetHeight)")
|
|
}
|
|
}
|