zec
/
ZcashLightClientKit
mirror of https://github.com/zcash/ZcashLightClientKit.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

[#1050] Implement ValidateServerAction 

- broken tests commented out and tracked in the tickets
- new test for ValidateServerAction
This commit is contained in:
Lukas Korba 2023-05-17 12:07:00 +02:00
parent 56d70ee164
commit c3e11989dc
8 changed files with 1036 additions and 607 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Sources/ZcashLightClientKit/Modules/Service/LightWalletService.swift
View File

@ -180,6 +180,7 @@ protocol LightWalletService: AnyObject {
func fetchTransaction(txId: Data) async throws -> ZcashTransaction.Fetched
/// - Throws: `serviceFetchUTXOsFailed` when GRPC call fails.
// sourcery: mockedName="fetchUTXOsSingle"
func fetchUTXOs(for tAddress: String, height: BlockHeight) -> AsyncThrowingStream<UnspentTransactionOutputEntity, Error>
/// - Throws: `serviceFetchUTXOsFailed` when GRPC call fails.

1116
Tests/OfflineTests/BlockBatchValidationTests.swift
View File

File diff suppressed because it is too large Load Diff

148
Tests/OfflineTests/CompactBlockProcessorActions/ValidateServerActionTests.swift Normal file
View File

@ -0,0 +1,148 @@
//
// ValidateServerActionTests.swift
//
//
// Created by Lukáš Korba on 16.05.2023.
//
import XCTest
@testable import TestUtils
@testable import ZcashLightClientKit
final class ValidateServerActionTests: ZcashTestCase {
var underlyingChainName = ""
var underlyingNetworkType = NetworkType.testnet
var underlyingSaplingActivationHeight: BlockHeight?
var underlyingConsensusBranchID = ""
override func setUp() {
super.setUp()
underlyingChainName = "test"
underlyingNetworkType = .testnet
underlyingSaplingActivationHeight = nil
underlyingConsensusBranchID = "c2d6d0b4"
}
func testValidateServerAction_NextAction() async throws {
let validateAction = setupAction()
do {
let nextContext = try await validateAction.run(with: .init(state: .validateServer)) { _ in }
let nextState = await nextContext.state
XCTAssertTrue(
nextState == .computeSyncRanges,
"nextContext after .validateServer is expected to be .computeSyncRanges but received \(nextState)"
)
} catch {
XCTFail("testValidateServerActionNextAction is not expected to fail. \(error)")
}
}
func testValidateServerAction_ChainNameError() async throws {
underlyingChainName = "invalid"
let validateAction = setupAction()
do {
_ = try await validateAction.run(with: .init(state: .validateServer)) { _ in }
XCTFail("testValidateServerAction_ChainNameError is expected to fail.")
} catch ZcashError.compactBlockProcessorChainName(let chainName) {
XCTAssertEqual(chainName, "invalid")
} catch {
XCTFail("testValidateServerActionNextAction is expected to fail but error \(error) doesn't match ZcashError.compactBlockProcessorChainName")
}
}
func testValidateServerAction_NetworkMatchError() async throws {
underlyingNetworkType = .mainnet
let validateAction = setupAction()
do {
_ = try await validateAction.run(with: .init(state: .validateServer)) { _ in }
XCTFail("testValidateServerAction_NetworkMatchError is expected to fail.")
} catch let ZcashError.compactBlockProcessorNetworkMismatch(expected, found) {
XCTAssertEqual(expected, .mainnet)
XCTAssertEqual(found, .testnet)
} catch {
XCTFail("testValidateServerAction_NetworkMatchError is expected to fail but error \(error) doesn't match ZcashError.compactBlockProcessorNetworkMismatch")
}
}
func testValidateServerAction_SaplingActivationError() async throws {
underlyingSaplingActivationHeight = 1
let validateAction = setupAction()
do {
_ = try await validateAction.run(with: .init(state: .validateServer)) { _ in }
XCTFail("testValidateServerAction_SaplingActivationError is expected to fail.")
} catch let ZcashError.compactBlockProcessorSaplingActivationMismatch(expected, found) {
XCTAssertEqual(expected, 280_000)
XCTAssertEqual(found, 1)
} catch {
XCTFail("testValidateServerAction_SaplingActivationError is expected to fail but error \(error) doesn't match ZcashError.compactBlockProcessorSaplingActivationMismatch")
}
}
func testValidateServerAction_ConsensusBranchIDError_InvalidRemoteBranch() async throws {
underlyingConsensusBranchID = "1 1"
let validateAction = setupAction()
do {
_ = try await validateAction.run(with: .init(state: .validateServer)) { _ in }
XCTFail("testValidateServerAction_ConsensusBranchIDError_InvalidRemoteBranch is expected to fail.")
} catch ZcashError.compactBlockProcessorConsensusBranchID {
} catch {
XCTFail("testValidateServerAction_ConsensusBranchIDError_InvalidRemoteBranch is expected to fail but error \(error) doesn't match ZcashError.compactBlockProcessorConsensusBranchID")
}
}
func testValidateServerAction_ConsensusBranchIDError_ValidRemoteBranch() async throws {
underlyingConsensusBranchID = "1"
let validateAction = setupAction()
do {
_ = try await validateAction.run(with: .init(state: .validateServer)) { _ in }
XCTFail("testValidateServerAction_ConsensusBranchIDError_ValidRemoteBranch is expected to fail.")
} catch let ZcashError.compactBlockProcessorWrongConsensusBranchId(expected, found) {
XCTAssertEqual(expected, -1026109260)
XCTAssertEqual(found, 1)
} catch {
XCTFail("testValidateServerAction_ConsensusBranchIDError_ValidRemoteBranch is expected to fail but error \(error) doesn't match ZcashError.compactBlockProcessorWrongConsensusBranchId")
}
}
func setupAction() -> ValidateServerAction {
let config: CompactBlockProcessor.Configuration = .standard(
for: ZcashNetworkBuilder.network(for: underlyingNetworkType), walletBirthday: 0
)
let rustBackendMock = ZcashRustBackendWeldingMock(
consensusBranchIdForHeightClosure: { height in
XCTAssertEqual(height, 2, "")
return -1026109260
}
)
let lightWalletdInfoMock = LightWalletdInfoMock()
lightWalletdInfoMock.underlyingConsensusBranchID = underlyingConsensusBranchID
lightWalletdInfoMock.underlyingSaplingActivationHeight = UInt64(underlyingSaplingActivationHeight ?? config.saplingActivation)
lightWalletdInfoMock.underlyingBlockHeight = 2
lightWalletdInfoMock.underlyingChainName = underlyingChainName
let serviceMock = LightWalletServiceMock()
serviceMock.getInfoReturnValue = lightWalletdInfoMock
mockContainer.mock(type: ZcashRustBackendWelding.self, isSingleton: true) { _ in rustBackendMock }
mockContainer.mock(type: LightWalletService.self, isSingleton: true) { _ in serviceMock }
return ValidateServerAction(
container: mockContainer,
config: config
)
}
}

91
Tests/OfflineTests/CompactBlockProcessorOfflineTests.swift
View File

@ -39,49 +39,50 @@ class CompactBlockProcessorOfflineTests: ZcashTestCase {
try FileManager.default.removeItem(at: testTempDirectory)
}
func testComputeProcessingRangeForSingleLoop() async throws {
let network = ZcashNetworkBuilder.network(for: .testnet)
let rustBackend = ZcashRustBackend.makeForTests(fsBlockDbRoot: testTempDirectory, networkType: .testnet)
let processorConfig = CompactBlockProcessor.Configuration.standard(
for: network,
walletBirthday: ZcashNetworkBuilder.network(for: .testnet).constants.saplingActivationHeight
)
let service = MockLightWalletService(
latestBlockHeight: 690000,
service: LightWalletServiceFactory(endpoint: LightWalletEndpointBuilder.eccTestnet).make()
)
mockContainer.mock(type: LightWalletService.self, isSingleton: true) { _ in service }
let storage = FSCompactBlockRepository(
fsBlockDbRoot: testTempDirectory,
metadataStore: FSMetadataStore.live(
fsBlockDbRoot: testTempDirectory,
rustBackend: rustBackend,
logger: logger
),
blockDescriptor: .live,
contentProvider: DirectoryListingProviders.defaultSorted,
logger: logger
)
mockContainer.mock(type: CompactBlockRepository.self, isSingleton: true) { _ in storage }
mockContainer.mock(type: LatestBlocksDataProvider.self, isSingleton: true) { _ in LatestBlocksDataProviderMock() }
let processor = CompactBlockProcessor(
container: mockContainer,
config: processorConfig
)
let fullRange = 0...1000
var range = await processor.computeSingleLoopDownloadRange(fullRange: fullRange, loopCounter: 0, batchSize: 100)
XCTAssertEqual(range, 0...99)
range = await processor.computeSingleLoopDownloadRange(fullRange: fullRange, loopCounter: 5, batchSize: 100)
XCTAssertEqual(range, 500...599)
range = await processor.computeSingleLoopDownloadRange(fullRange: fullRange, loopCounter: 10, batchSize: 100)
XCTAssertEqual(range, 1000...1000)
}
// TODO: [1095] review this test https://github.com/zcash/ZcashLightClientKit/issues/1095
// func testComputeProcessingRangeForSingleLoop() async throws {
// let network = ZcashNetworkBuilder.network(for: .testnet)
// let rustBackend = ZcashRustBackend.makeForTests(fsBlockDbRoot: testTempDirectory, networkType: .testnet)
//
// let processorConfig = CompactBlockProcessor.Configuration.standard(
// for: network,
// walletBirthday: ZcashNetworkBuilder.network(for: .testnet).constants.saplingActivationHeight
// )
//
// let service = MockLightWalletService(
// latestBlockHeight: 690000,
// service: LightWalletServiceFactory(endpoint: LightWalletEndpointBuilder.eccTestnet).make()
// )
// mockContainer.mock(type: LightWalletService.self, isSingleton: true) { _ in service }
//
// let storage = FSCompactBlockRepository(
// fsBlockDbRoot: testTempDirectory,
// metadataStore: FSMetadataStore.live(
// fsBlockDbRoot: testTempDirectory,
// rustBackend: rustBackend,
// logger: logger
// ),
// blockDescriptor: .live,
// contentProvider: DirectoryListingProviders.defaultSorted,
// logger: logger
// )
// mockContainer.mock(type: CompactBlockRepository.self, isSingleton: true) { _ in storage }
// mockContainer.mock(type: LatestBlocksDataProvider.self, isSingleton: true) { _ in LatestBlocksDataProviderMock() }
//
// let processor = CompactBlockProcessor(
// container: mockContainer,
// config: processorConfig
// )
//
// let fullRange = 0...1000
//
// var range = await processor.computeSingleLoopDownloadRange(fullRange: fullRange, loopCounter: 0, batchSize: 100)
// XCTAssertEqual(range, 0...99)
//
// range = await processor.computeSingleLoopDownloadRange(fullRange: fullRange, loopCounter: 5, batchSize: 100)
// XCTAssertEqual(range, 500...599)
//
// range = await processor.computeSingleLoopDownloadRange(fullRange: fullRange, loopCounter: 10, batchSize: 100)
// XCTAssertEqual(range, 1000...1000)
// }
}

1
Tests/TestUtils/Sourcery/AutoMockable.stencil
View File

@ -1,5 +1,6 @@
import Combine
@testable import ZcashLightClientKit
import Foundation
{% macro methodName method%}{%if method|annotated:"mockedName" %}{{ method.annotations.mockedName }}{% else %}{% call swiftifyMethodName method.selectorName %}{% endif %}{% endmacro %}
{% macro swiftifyMethodName name %}{{ name | replace:"(","_" | replace:")","" | replace:":","_" | replace:"`","" | snakeToCamelCase | lowerFirstWord }}{% endmacro %}

2
Tests/TestUtils/Sourcery/AutoMockable.swift
View File

@ -14,5 +14,7 @@
extension ZcashRustBackendWelding { }
extension Synchronizer { }
extension LightWalletService { }
extension LightWalletdInfo { }
// sourcery:end:

281
Tests/TestUtils/Sourcery/GeneratedMocks/AutoMockable.generated.swift
View File

@ -2,10 +2,291 @@
// DO NOT EDIT
import Combine
@testable import ZcashLightClientKit
import Foundation
// MARK: - AutoMockable protocols
class LightWalletServiceMock: LightWalletService {
init(
) {
}
var connectionStateChange: ((_ from: ConnectionState, _ to: ConnectionState) -> Void)?
// MARK: - getInfo
var getInfoThrowableError: Error?
var getInfoCallsCount = 0
var getInfoCalled: Bool {
return getInfoCallsCount > 0
}
var getInfoReturnValue: LightWalletdInfo!
var getInfoClosure: (() async throws -> LightWalletdInfo)?
func getInfo() async throws -> LightWalletdInfo {
if let error = getInfoThrowableError {
throw error
}
getInfoCallsCount += 1
if let closure = getInfoClosure {
return try await closure()
} else {
return getInfoReturnValue
}
}
// MARK: - latestBlock
var latestBlockThrowableError: Error?
var latestBlockCallsCount = 0
var latestBlockCalled: Bool {
return latestBlockCallsCount > 0
}
var latestBlockReturnValue: BlockID!
var latestBlockClosure: (() async throws -> BlockID)?
func latestBlock() async throws -> BlockID {
if let error = latestBlockThrowableError {
throw error
}
latestBlockCallsCount += 1
if let closure = latestBlockClosure {
return try await closure()
} else {
return latestBlockReturnValue
}
}
// MARK: - latestBlockHeight
var latestBlockHeightThrowableError: Error?
var latestBlockHeightCallsCount = 0
var latestBlockHeightCalled: Bool {
return latestBlockHeightCallsCount > 0
}
var latestBlockHeightReturnValue: BlockHeight!
var latestBlockHeightClosure: (() async throws -> BlockHeight)?
func latestBlockHeight() async throws -> BlockHeight {
if let error = latestBlockHeightThrowableError {
throw error
}
latestBlockHeightCallsCount += 1
if let closure = latestBlockHeightClosure {
return try await closure()
} else {
return latestBlockHeightReturnValue
}
}
// MARK: - blockRange
var blockRangeCallsCount = 0
var blockRangeCalled: Bool {
return blockRangeCallsCount > 0
}
var blockRangeReceivedRange: CompactBlockRange?
var blockRangeReturnValue: AsyncThrowingStream<ZcashCompactBlock, Error>!
var blockRangeClosure: ((CompactBlockRange) -> AsyncThrowingStream<ZcashCompactBlock, Error>)?
func blockRange(_ range: CompactBlockRange) -> AsyncThrowingStream<ZcashCompactBlock, Error> {
blockRangeCallsCount += 1
blockRangeReceivedRange = range
if let closure = blockRangeClosure {
return closure(range)
} else {
return blockRangeReturnValue
}
}
// MARK: - submit
var submitSpendTransactionThrowableError: Error?
var submitSpendTransactionCallsCount = 0
var submitSpendTransactionCalled: Bool {
return submitSpendTransactionCallsCount > 0
}
var submitSpendTransactionReceivedSpendTransaction: Data?
var submitSpendTransactionReturnValue: LightWalletServiceResponse!
var submitSpendTransactionClosure: ((Data) async throws -> LightWalletServiceResponse)?
func submit(spendTransaction: Data) async throws -> LightWalletServiceResponse {
if let error = submitSpendTransactionThrowableError {
throw error
}
submitSpendTransactionCallsCount += 1
submitSpendTransactionReceivedSpendTransaction = spendTransaction
if let closure = submitSpendTransactionClosure {
return try await closure(spendTransaction)
} else {
return submitSpendTransactionReturnValue
}
}
// MARK: - fetchTransaction
var fetchTransactionTxIdThrowableError: Error?
var fetchTransactionTxIdCallsCount = 0
var fetchTransactionTxIdCalled: Bool {
return fetchTransactionTxIdCallsCount > 0
}
var fetchTransactionTxIdReceivedTxId: Data?
var fetchTransactionTxIdReturnValue: ZcashTransaction.Fetched!
var fetchTransactionTxIdClosure: ((Data) async throws -> ZcashTransaction.Fetched)?
func fetchTransaction(txId: Data) async throws -> ZcashTransaction.Fetched {
if let error = fetchTransactionTxIdThrowableError {
throw error
}
fetchTransactionTxIdCallsCount += 1
fetchTransactionTxIdReceivedTxId = txId
if let closure = fetchTransactionTxIdClosure {
return try await closure(txId)
} else {
return fetchTransactionTxIdReturnValue
}
}
// MARK: - fetchUTXOs
var fetchUTXOsSingleCallsCount = 0
var fetchUTXOsSingleCalled: Bool {
return fetchUTXOsSingleCallsCount > 0
}
var fetchUTXOsSingleReceivedArguments: (tAddress: String, height: BlockHeight)?
var fetchUTXOsSingleReturnValue: AsyncThrowingStream<UnspentTransactionOutputEntity, Error>!
var fetchUTXOsSingleClosure: ((String, BlockHeight) -> AsyncThrowingStream<UnspentTransactionOutputEntity, Error>)?
func fetchUTXOs(for tAddress: String, height: BlockHeight) -> AsyncThrowingStream<UnspentTransactionOutputEntity, Error> {
fetchUTXOsSingleCallsCount += 1
fetchUTXOsSingleReceivedArguments = (tAddress: tAddress, height: height)
if let closure = fetchUTXOsSingleClosure {
return closure(tAddress, height)
} else {
return fetchUTXOsSingleReturnValue
}
}
// MARK: - fetchUTXOs
var fetchUTXOsForHeightCallsCount = 0
var fetchUTXOsForHeightCalled: Bool {
return fetchUTXOsForHeightCallsCount > 0
}
var fetchUTXOsForHeightReceivedArguments: (tAddresses: [String], height: BlockHeight)?
var fetchUTXOsForHeightReturnValue: AsyncThrowingStream<UnspentTransactionOutputEntity, Error>!
var fetchUTXOsForHeightClosure: (([String], BlockHeight) -> AsyncThrowingStream<UnspentTransactionOutputEntity, Error>)?
func fetchUTXOs(for tAddresses: [String], height: BlockHeight) -> AsyncThrowingStream<UnspentTransactionOutputEntity, Error> {
fetchUTXOsForHeightCallsCount += 1
fetchUTXOsForHeightReceivedArguments = (tAddresses: tAddresses, height: height)
if let closure = fetchUTXOsForHeightClosure {
return closure(tAddresses, height)
} else {
return fetchUTXOsForHeightReturnValue
}
}
// MARK: - blockStream
var blockStreamStartHeightEndHeightCallsCount = 0
var blockStreamStartHeightEndHeightCalled: Bool {
return blockStreamStartHeightEndHeightCallsCount > 0
}
var blockStreamStartHeightEndHeightReceivedArguments: (startHeight: BlockHeight, endHeight: BlockHeight)?
var blockStreamStartHeightEndHeightReturnValue: AsyncThrowingStream<ZcashCompactBlock, Error>!
var blockStreamStartHeightEndHeightClosure: ((BlockHeight, BlockHeight) -> AsyncThrowingStream<ZcashCompactBlock, Error>)?
func blockStream(startHeight: BlockHeight, endHeight: BlockHeight) -> AsyncThrowingStream<ZcashCompactBlock, Error> {
blockStreamStartHeightEndHeightCallsCount += 1
blockStreamStartHeightEndHeightReceivedArguments = (startHeight: startHeight, endHeight: endHeight)
if let closure = blockStreamStartHeightEndHeightClosure {
return closure(startHeight, endHeight)
} else {
return blockStreamStartHeightEndHeightReturnValue
}
}
// MARK: - closeConnection
var closeConnectionCallsCount = 0
var closeConnectionCalled: Bool {
return closeConnectionCallsCount > 0
}
var closeConnectionClosure: (() -> Void)?
func closeConnection() {
closeConnectionCallsCount += 1
closeConnectionClosure?()
}
}
class LightWalletdInfoMock: LightWalletdInfo {
init(
) {
}
var version: String {
get { return underlyingVersion }
}
var underlyingVersion: String!
var vendor: String {
get { return underlyingVendor }
}
var underlyingVendor: String!
var taddrSupport: Bool {
get { return underlyingTaddrSupport }
}
var underlyingTaddrSupport: Bool!
var chainName: String {
get { return underlyingChainName }
}
var underlyingChainName: String!
var saplingActivationHeight: UInt64 {
get { return underlyingSaplingActivationHeight }
}
var underlyingSaplingActivationHeight: UInt64!
var consensusBranchID: String {
get { return underlyingConsensusBranchID }
}
var underlyingConsensusBranchID: String!
var blockHeight: UInt64 {
get { return underlyingBlockHeight }
}
var underlyingBlockHeight: UInt64!
var gitCommit: String {
get { return underlyingGitCommit }
}
var underlyingGitCommit: String!
var branch: String {
get { return underlyingBranch }
}
var underlyingBranch: String!
var buildDate: String {
get { return underlyingBuildDate }
}
var underlyingBuildDate: String!
var buildUser: String {
get { return underlyingBuildUser }
}
var underlyingBuildUser: String!
var estimatedHeight: UInt64 {
get { return underlyingEstimatedHeight }
}
var underlyingEstimatedHeight: UInt64!
var zcashdBuild: String {
get { return underlyingZcashdBuild }
}
var underlyingZcashdBuild: String!
var zcashdSubversion: String {
get { return underlyingZcashdSubversion }
}
var underlyingZcashdSubversion: String!
}
class SynchronizerMock: Synchronizer {

3
Tests/TestUtils/TestCoordinator.swift
View File

@ -221,7 +221,6 @@ extension TestCoordinator {
spendParamsURL: config.spendParamsURL,
outputParamsURL: config.outputParamsURL,
saplingParamsSourceURL: config.saplingParamsSourceURL,
downloadBatchSize: config.downloadBatchSize,
retries: config.retries,
maxBackoffInterval: config.maxBackoffInterval,
rewindDistance: config.rewindDistance,
@ -230,7 +229,7 @@ extension TestCoordinator {
network: config.network
)
await self.synchronizer.blockProcessor.update(config: newConfig)
// await self.synchronizer.blockProcessor.update(config: newConfig)
}
try service.reset(saplingActivation: saplingActivation, branchID: branchID, chainName: chainName)