Ecosystem/stack_wallet
1
0
Fork 0
mirror of https://github.com/cypherstack/stack_wallet.git synced 2024-11-16 17:27:39 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
stack_wallet/test/electrumx_test.dart

1779 lines
61 KiB
Dart
Raw Normal View History

build runner run updates
2024-04-24 21:00:36 +00:00
// import 'dart:io';
//
// import 'package:flutter_test/flutter_test.dart';
// import 'package:mockito/annotations.dart';
// import 'package:mockito/mockito.dart';
// import 'package:stackwallet/electrumx_rpc/electrumx_client.dart';
// import 'package:stackwallet/electrumx_rpc/rpc.dart';
// import 'package:stackwallet/services/event_bus/events/global/tor_connection_status_changed_event.dart';
// import 'package:stackwallet/services/tor_service.dart';
// import 'package:stackwallet/utilities/prefs.dart';
//
// import 'electrumx_test.mocks.dart';
// import 'sample_data/get_anonymity_set_sample_data.dart';
// import 'sample_data/get_used_serials_sample_data.dart';
// import 'sample_data/transaction_data_samples.dart';
//
// @GenerateMocks([JsonRPC, Prefs, TorService])
// void main() {
// group("factory constructors and getters", () {
// test("electrumxnode .from factory", () {
// final nodeA = ElectrumXNode(
// address: "some address",
// port: 1,
// name: "some name",
// id: "some ID",
// useSSL: true,
// );
//
// final nodeB = ElectrumXNode.from(nodeA);
//
// expect(nodeB.toString(), nodeA.toString());
// expect(nodeA == nodeB, false);
// });
//
// test("electrumx .from factory", () {
// final node = ElectrumXNode(
// address: "some address",
// port: 1,
// name: "some name",
// id: "some ID",
// useSSL: true,
// );
//
// final mockPrefs = MockPrefs();
// when(mockPrefs.useTor).thenAnswer((realInvocation) => false);
// final torService = MockTorService();
//
// final client = ElectrumXClient.from(
// node: node,
// failovers: [],
// prefs: mockPrefs,
// torService: torService,
// );
//
// expect(client.useSSL, node.useSSL);
// expect(client.host, node.address);
// expect(client.port, node.port);
// expect(client.rpcClient, null);
//
// verifyNoMoreInteractions(mockPrefs);
// });
// });
//
// test("Server error", () {
// final mockClient = MockJsonRPC();
// const command = "blockchain.transaction.get";
// const jsonArgs = '["",true]';
// when(
// mockClient.request(
// '{"jsonrpc": "2.0", "id": "some requestId",'
// '"method": "$command","params": $jsonArgs}',
// const Duration(seconds: 60),
// ),
// ).thenAnswer(
// (_) async => JsonRPCResponse(data: {
// "jsonrpc": "2.0",
// "error": {
// "code": 1,
// "message": "None should be a transaction hash",
// },
// "id": "some requestId",
// }),
// );
//
// final mockPrefs = MockPrefs();
// when(mockPrefs.useTor).thenAnswer((realInvocation) => false);
// final torService = MockTorService();
// when(mockPrefs.wifiOnly).thenAnswer((_) => false);
//
// final client = ElectrumXClient(
// host: "some server",
// port: 0,
// useSSL: true,
// client: mockClient,
// failovers: [],
// prefs: mockPrefs,
// torService: torService,
// );
//
// expect(() => client.getTransaction(requestID: "some requestId", txHash: ''),
// throwsA(isA<Exception>()));
//
// verify(mockPrefs.wifiOnly).called(1);
// verifyNoMoreInteractions(mockPrefs);
// });
//
// group("getBlockHeadTip", () {
// test("getBlockHeadTip success", () async {
// final mockClient = MockJsonRPC();
// const command = "blockchain.headers.subscribe";
// const jsonArgs = '[]';
// when(
// mockClient.request(
// '{"jsonrpc": "2.0", "id": "some requestId",'
// '"method": "$command","params": $jsonArgs}',
// const Duration(seconds: 60),
// ),
// ).thenAnswer(
// (_) async => JsonRPCResponse(data: {
// "jsonrpc": "2.0",
// "result": {"height": 520481, "hex": "some block hex string"},
// "id": "some requestId"
// }),
// );
//
// final mockPrefs = MockPrefs();
// when(mockPrefs.useTor).thenAnswer((realInvocation) => false);
// final torService = MockTorService();
// when(mockPrefs.wifiOnly).thenAnswer((_) => false);
// final client = ElectrumXClient(
// host: "some server",
// port: 0,
// useSSL: true,
// client: mockClient,
// prefs: mockPrefs,
// torService: torService,
// failovers: []);
//
// final result =
// await (client.getBlockHeadTip(requestID: "some requestId"));
//
// expect(result["height"], 520481);
//
// verify(mockPrefs.wifiOnly).called(1);
// verify(mockPrefs.useTor).called(1);
// verifyNoMoreInteractions(mockPrefs);
// });
//
// test("getBlockHeadTip throws/fails", () {
// final mockClient = MockJsonRPC();
// const command = "blockchain.headers.subscribe";
// const jsonArgs = '[]';
// when(
// mockClient.request(
// '{"jsonrpc": "2.0", "id": "some requestId",'
// '"method": "$command","params": $jsonArgs}',
// const Duration(seconds: 60),
// ),
// ).thenThrow(Exception());
//
// final mockPrefs = MockPrefs();
// when(mockPrefs.useTor).thenAnswer((realInvocation) => false);
// final torService = MockTorService();
// when(mockPrefs.wifiOnly).thenAnswer((_) => false);
// final client = ElectrumXClient(
// host: "some server",
// port: 0,
// useSSL: true,
// client: mockClient,
// prefs: mockPrefs,
// torService: torService,
// failovers: []);
//
// expect(() => client.getBlockHeadTip(requestID: "some requestId"),
// throwsA(isA<Exception>()));
//
// verify(mockPrefs.wifiOnly).called(1);
// verifyNoMoreInteractions(mockPrefs);
// });
// });
//
// group("ping", () {
// test("ping success", () async {
// final mockClient = MockJsonRPC();
// const command = "server.ping";
// const jsonArgs = '[]';
// when(
// mockClient.request(
// '{"jsonrpc": "2.0", "id": "some requestId",'
// '"method": "$command","params": $jsonArgs}',
// const Duration(seconds: 2),
// ),
// ).thenAnswer(
// (_) async => JsonRPCResponse(data: {
// "jsonrpc": "2.0",
// "result": null,
// "id": "some requestId",
// }),
// );
//
// final mockPrefs = MockPrefs();
// when(mockPrefs.useTor).thenAnswer((realInvocation) => false);
// final torService = MockTorService();
// when(mockPrefs.wifiOnly).thenAnswer((_) => false);
// final client = ElectrumXClient(
// host: "some server",
// port: 0,
// useSSL: true,
// client: mockClient,
// prefs: mockPrefs,
// torService: torService,
// failovers: []);
//
// final result = await client.ping(requestID: "some requestId");
//
// expect(result, true);
//
// verify(mockPrefs.wifiOnly).called(1);
// verify(mockPrefs.useTor).called(1);
// verifyNoMoreInteractions(mockPrefs);
// });
//
// test("ping throws/fails", () {
// final mockClient = MockJsonRPC();
// const command = "server.ping";
// const jsonArgs = '[]';
// when(
// mockClient.request(
// '{"jsonrpc": "2.0", "id": "some requestId",'
// '"method": "$command","params": $jsonArgs}',
// const Duration(seconds: 2),
// ),
// ).thenThrow(Exception());
//
// final mockPrefs = MockPrefs();
// when(mockPrefs.useTor).thenAnswer((realInvocation) => false);
// final torService = MockTorService();
// when(mockPrefs.wifiOnly).thenAnswer((_) => false);
// final client = ElectrumXClient(
// host: "some server",
// port: 0,
// useSSL: true,
// client: mockClient,
// prefs: mockPrefs,
// torService: torService,
// failovers: []);
//
// expect(() => client.ping(requestID: "some requestId"),
// throwsA(isA<Exception>()));
//
// verify(mockPrefs.wifiOnly).called(1);
// verifyNoMoreInteractions(mockPrefs);
// });
// });
//
// group("getServerFeatures", () {
// test("getServerFeatures success", () async {
// final mockClient = MockJsonRPC();
// const command = "server.features";
// const jsonArgs = '[]';
// when(
// mockClient.request(
// '{"jsonrpc": "2.0", "id": "some requestId",'
// '"method": "$command","params": $jsonArgs}',
// const Duration(seconds: 60),
// ),
// ).thenAnswer(
// (_) async => JsonRPCResponse(data: {
// "jsonrpc": "2.0",
// "result": {
// "genesis_hash":
// "000000000933ea01ad0ee984209779baaec3ced90fa3f408719526f8d77f4943",
// "hosts": {
// "0.0.0.0": {"tcp_port": 51001, "ssl_port": 51002}
// },
// "protocol_max": "1.0",
// "protocol_min": "1.0",
// "pruning": null,
// "server_version": "ElectrumX 1.0.17",
// "hash_function": "sha256"
// },
// "id": "some requestId"
// }),
// );
//
// final mockPrefs = MockPrefs();
// when(mockPrefs.useTor).thenAnswer((realInvocation) => false);
// final torService = MockTorService();
// when(mockPrefs.wifiOnly).thenAnswer((_) => false);
// final client = ElectrumXClient(
// host: "some server",
// port: 0,
// useSSL: true,
// client: mockClient,
// prefs: mockPrefs,
// torService: torService,
// failovers: []);
//
// final result =
// await client.getServerFeatures(requestID: "some requestId");
//
// expect(result, {
// "genesis_hash":
// "000000000933ea01ad0ee984209779baaec3ced90fa3f408719526f8d77f4943",
// "hosts": {
// "0.0.0.0": {"tcp_port": 51001, "ssl_port": 51002}
// },
// "protocol_max": "1.0",
// "protocol_min": "1.0",
// "pruning": null,
// "server_version": "ElectrumX 1.0.17",
// "hash_function": "sha256",
// });
//
// verify(mockPrefs.wifiOnly).called(1);
// verify(mockPrefs.useTor).called(1);
// verifyNoMoreInteractions(mockPrefs);
// });
//
// test("getServerFeatures throws/fails", () {
// final mockClient = MockJsonRPC();
// const command = "server.features";
// const jsonArgs = '[]';
// when(
// mockClient.request(
// '{"jsonrpc": "2.0", "id": "some requestId",'
// '"method": "$command","params": $jsonArgs}',
// const Duration(seconds: 60),
// ),
// ).thenThrow(Exception());
//
// final mockPrefs = MockPrefs();
// when(mockPrefs.useTor).thenAnswer((realInvocation) => false);
// final torService = MockTorService();
// when(mockPrefs.wifiOnly).thenAnswer((_) => false);
// final client = ElectrumXClient(
// host: "some server",
// port: 0,
// useSSL: true,
// client: mockClient,
// prefs: mockPrefs,
// torService: torService,
// failovers: []);
//
// expect(() => client.getServerFeatures(requestID: "some requestId"),
// throwsA(isA<Exception>()));
//
// verify(mockPrefs.wifiOnly).called(1);
// verifyNoMoreInteractions(mockPrefs);
// });
// });
//
// group("broadcastTransaction", () {
// test("broadcastTransaction success", () async {
// final mockClient = MockJsonRPC();
// const command = "blockchain.transaction.broadcast";
// const jsonArgs = '["some raw transaction string"]';
// when(
// mockClient.request(
// '{"jsonrpc": "2.0", "id": "some requestId",'
// '"method": "$command","params": $jsonArgs}',
// const Duration(seconds: 60),
// ),
// ).thenAnswer(
// (_) async => JsonRPCResponse(data: {
// "jsonrpc": "2.0",
// "result": "the txid of the rawtx",
// "id": "some requestId"
// }),
// );
//
// final mockPrefs = MockPrefs();
// when(mockPrefs.useTor).thenAnswer((realInvocation) => false);
// final torService = MockTorService();
// when(mockPrefs.wifiOnly).thenAnswer((_) => false);
// final client = ElectrumXClient(
// host: "some server",
// port: 0,
// useSSL: true,
// client: mockClient,
// prefs: mockPrefs,
// torService: torService,
// failovers: []);
//
// final result = await client.broadcastTransaction(
// rawTx: "some raw transaction string", requestID: "some requestId");
//
// expect(result, "the txid of the rawtx");
//
// verify(mockPrefs.wifiOnly).called(1);
// verify(mockPrefs.useTor).called(1);
// verifyNoMoreInteractions(mockPrefs);
// });
//
// test("broadcastTransaction throws/fails", () {
// final mockClient = MockJsonRPC();
// const command = "blockchain.transaction.broadcast";
// const jsonArgs = '["some raw transaction string"]';
// when(
// mockClient.request(
// '{"jsonrpc": "2.0", "id": "some requestId",'
// '"method": "$command","params": $jsonArgs}',
// const Duration(seconds: 60),
// ),
// ).thenThrow(Exception());
//
// final mockPrefs = MockPrefs();
// when(mockPrefs.useTor).thenAnswer((realInvocation) => false);
// final torService = MockTorService();
// when(mockPrefs.wifiOnly).thenAnswer((_) => false);
// final client = ElectrumXClient(
// host: "some server",
// port: 0,
// useSSL: true,
// client: mockClient,
// prefs: mockPrefs,
// torService: torService,
// failovers: []);
//
// expect(
// () => client.broadcastTransaction(
// rawTx: "some raw transaction string",
// requestID: "some requestId"),
// throwsA(isA<Exception>()));
//
// verify(mockPrefs.wifiOnly).called(1);
// verifyNoMoreInteractions(mockPrefs);
// });
// });
//
// group("getBalance", () {
// test("getBalance success", () async {
// final mockClient = MockJsonRPC();
// const command = "blockchain.scripthash.get_balance";
// const jsonArgs = '["dummy hash"]';
// when(
// mockClient.request(
// '{"jsonrpc": "2.0", "id": "some requestId",'
// '"method": "$command","params": $jsonArgs}',
// const Duration(seconds: 60),
// ),
// ).thenAnswer(
// (_) async => JsonRPCResponse(data: {
// "jsonrpc": "2.0",
// "result": {
// "confirmed": 103873966,
// "unconfirmed": 23684400,
// },
// "id": "some requestId"
// }),
// );
//
// final mockPrefs = MockPrefs();
// when(mockPrefs.useTor).thenAnswer((realInvocation) => false);
// final torService = MockTorService();
// when(mockPrefs.wifiOnly).thenAnswer((_) => false);
// final client = ElectrumXClient(
// host: "some server",
// port: 0,
// useSSL: true,
// client: mockClient,
// prefs: mockPrefs,
// torService: torService,
// failovers: []);
//
// final result = await client.getBalance(
// scripthash: "dummy hash", requestID: "some requestId");
//
// expect(result, {"confirmed": 103873966, "unconfirmed": 23684400});
//
// verify(mockPrefs.wifiOnly).called(1);
// verify(mockPrefs.useTor).called(1);
// verifyNoMoreInteractions(mockPrefs);
// });
//
// test("getBalance throws/fails", () {
// final mockClient = MockJsonRPC();
// const command = "blockchain.scripthash.get_balance";
// const jsonArgs = '["dummy hash"]';
// when(
// mockClient.request(
// '{"jsonrpc": "2.0", "id": "some requestId",'
// '"method": "$command","params": $jsonArgs}',
// const Duration(seconds: 60),
// ),
// ).thenThrow(Exception());
//
// final mockPrefs = MockPrefs();
// when(mockPrefs.useTor).thenAnswer((realInvocation) => false);
// final torService = MockTorService();
// when(mockPrefs.wifiOnly).thenAnswer((_) => false);
// final client = ElectrumXClient(
// host: "some server",
// port: 0,
// useSSL: true,
// client: mockClient,
// prefs: mockPrefs,
// torService: torService,
// failovers: []);
//
// expect(
// () => client.getBalance(
// scripthash: "dummy hash", requestID: "some requestId"),
// throwsA(isA<Exception>()));
//
// verify(mockPrefs.wifiOnly).called(1);
// verifyNoMoreInteractions(mockPrefs);
// });
// });
//
// group("getHistory", () {
// test("getHistory success", () async {
// final mockClient = MockJsonRPC();
// const command = "blockchain.scripthash.get_history";
// const jsonArgs = '["dummy hash"]';
// when(
// mockClient.request(
// '{"jsonrpc": "2.0", "id": "some requestId",'
// '"method": "$command","params": $jsonArgs}',
// const Duration(minutes: 5),
// ),
// ).thenAnswer(
// (_) async => JsonRPCResponse(data: {
// "jsonrpc": "2.0",
// "result": [
// {
// "height": 200004,
// "tx_hash":
// "acc3758bd2a26f869fcc67d48ff30b96464d476bca82c1cd6656e7d506816412"
// },
// {
// "height": 215008,
// "tx_hash":
// "f3e1bf48975b8d6060a9de8884296abb80be618dc00ae3cb2f6cee3085e09403"
// }
// ],
// "id": "some requestId"
// }),
// );
//
// final mockPrefs = MockPrefs();
// when(mockPrefs.useTor).thenAnswer((realInvocation) => false);
// final torService = MockTorService();
// when(mockPrefs.wifiOnly).thenAnswer((_) => false);
// final client = ElectrumXClient(
// host: "some server",
// port: 0,
// useSSL: true,
// client: mockClient,
// prefs: mockPrefs,
// torService: torService,
// failovers: []);
//
// final result = await client.getHistory(
// scripthash: "dummy hash", requestID: "some requestId");
//
// expect(result, [
// {
// "height": 200004,
// "tx_hash":
// "acc3758bd2a26f869fcc67d48ff30b96464d476bca82c1cd6656e7d506816412"
// },
// {
// "height": 215008,
// "tx_hash":
// "f3e1bf48975b8d6060a9de8884296abb80be618dc00ae3cb2f6cee3085e09403"
// }
// ]);
//
// verify(mockPrefs.wifiOnly).called(1);
// verify(mockPrefs.useTor).called(1);
// verifyNoMoreInteractions(mockPrefs);
// });
//
// test("getHistory throws/fails", () {
// final mockClient = MockJsonRPC();
// const command = "blockchain.scripthash.get_history";
// const jsonArgs = '["dummy hash"]';
// when(
// mockClient.request(
// '{"jsonrpc": "2.0", "id": "some requestId",'
// '"method": "$command","params": $jsonArgs}',
// const Duration(minutes: 5),
// ),
// ).thenThrow(Exception());
//
// final mockPrefs = MockPrefs();
// when(mockPrefs.useTor).thenAnswer((realInvocation) => false);
// final torService = MockTorService();
// when(mockPrefs.wifiOnly).thenAnswer((_) => false);
// final client = ElectrumXClient(
// host: "some server",
// port: 0,
// useSSL: true,
// client: mockClient,
// prefs: mockPrefs,
// torService: torService,
// failovers: []);
//
// expect(
// () => client.getHistory(
// scripthash: "dummy hash", requestID: "some requestId"),
// throwsA(isA<Exception>()));
//
// verify(mockPrefs.wifiOnly).called(1);
// verifyNoMoreInteractions(mockPrefs);
// });
// });
//
// group("getUTXOs", () {
// test("getUTXOs success", () async {
// final mockClient = MockJsonRPC();
// const command = "blockchain.scripthash.listunspent";
// const jsonArgs = '["dummy hash"]';
// when(
// mockClient.request(
// '{"jsonrpc": "2.0", "id": "some requestId",'
// '"method": "$command","params": $jsonArgs}',
// const Duration(seconds: 60),
// ),
// ).thenAnswer(
// (_) async => JsonRPCResponse(data: {
// "jsonrpc": "2.0",
// "result": [
// {
// "tx_pos": 0,
// "value": 45318048,
// "tx_hash":
// "9f2c45a12db0144909b5db269415f7319179105982ac70ed80d76ea79d923ebf",
// "height": 437146
// },
// {
// "tx_pos": 0,
// "value": 919195,
// "tx_hash":
// "3d2290c93436a3e964cfc2f0950174d8847b1fbe3946432c4784e168da0f019f",
// "height": 441696
// }
// ],
// "id": "some requestId"
// }),
// );
//
// final mockPrefs = MockPrefs();
// when(mockPrefs.useTor).thenAnswer((realInvocation) => false);
// final torService = MockTorService();
// when(mockPrefs.wifiOnly).thenAnswer((_) => false);
// final client = ElectrumXClient(
// host: "some server",
// port: 0,
// useSSL: true,
// client: mockClient,
// prefs: mockPrefs,
// torService: torService,
// failovers: []);
//
// final result = await client.getUTXOs(
// scripthash: "dummy hash", requestID: "some requestId");
//
// expect(result, [
// {
// "tx_pos": 0,
// "value": 45318048,
// "tx_hash":
// "9f2c45a12db0144909b5db269415f7319179105982ac70ed80d76ea79d923ebf",
// "height": 437146
// },
// {
// "tx_pos": 0,
// "value": 919195,
// "tx_hash":
// "3d2290c93436a3e964cfc2f0950174d8847b1fbe3946432c4784e168da0f019f",
// "height": 441696
// }
// ]);
//
// verify(mockPrefs.wifiOnly).called(1);
// verify(mockPrefs.useTor).called(1);
// verifyNoMoreInteractions(mockPrefs);
// });
//
// test("getUTXOs throws/fails", () {
// final mockClient = MockJsonRPC();
// const command = "blockchain.scripthash.listunspent";
// const jsonArgs = '["dummy hash"]';
// when(
// mockClient.request(
// '{"jsonrpc": "2.0", "id": "some requestId",'
// '"method": "$command","params": $jsonArgs}',
// const Duration(seconds: 60),
// ),
// ).thenThrow(Exception());
//
// final mockPrefs = MockPrefs();
// when(mockPrefs.useTor).thenAnswer((realInvocation) => false);
// final torService = MockTorService();
// when(mockPrefs.wifiOnly).thenAnswer((_) => false);
// final client = ElectrumXClient(
// host: "some server",
// port: 0,
// useSSL: true,
// client: mockClient,
// prefs: mockPrefs,
// torService: torService,
// failovers: []);
//
// expect(
// () => client.getUTXOs(
// scripthash: "dummy hash", requestID: "some requestId"),
// throwsA(isA<Exception>()));
//
// verify(mockPrefs.wifiOnly).called(1);
// verifyNoMoreInteractions(mockPrefs);
// });
// });
//
// group("getTransaction", () {
// test("getTransaction success", () async {
// final mockClient = MockJsonRPC();
// const command = "blockchain.transaction.get";
// const jsonArgs = '["${SampleGetTransactionData.txHash0}",true]';
// when(
// mockClient.request(
// '{"jsonrpc": "2.0", "id": "some requestId",'
// '"method": "$command","params": $jsonArgs}',
// const Duration(seconds: 60),
// ),
// ).thenAnswer(
// (_) async => JsonRPCResponse(data: {
// "jsonrpc": "2.0",
// "result": SampleGetTransactionData.txData0,
// "id": "some requestId"
// }),
// );
//
// final mockPrefs = MockPrefs();
// when(mockPrefs.useTor).thenAnswer((realInvocation) => false);
// final torService = MockTorService();
// when(mockPrefs.wifiOnly).thenAnswer((_) => false);
// final client = ElectrumXClient(
// host: "some server",
// port: 0,
// useSSL: true,
// client: mockClient,
// prefs: mockPrefs,
// torService: torService,
// failovers: []);
//
// final result = await client.getTransaction(
// txHash: SampleGetTransactionData.txHash0,
// verbose: true,
// requestID: "some requestId");
//
// expect(result, SampleGetTransactionData.txData0);
//
// verify(mockPrefs.wifiOnly).called(1);
// verify(mockPrefs.useTor).called(1);
// verifyNoMoreInteractions(mockPrefs);
// });
//
// test("getTransaction throws/fails", () {
// final mockClient = MockJsonRPC();
// const command = "blockchain.transaction.get";
// const jsonArgs = '["${SampleGetTransactionData.txHash0}",true]';
// when(
// mockClient.request(
// '{"jsonrpc": "2.0", "id": "some requestId",'
// '"method": "$command","params": $jsonArgs}',
// const Duration(seconds: 60),
// ),
// ).thenThrow(Exception());
//
// final mockPrefs = MockPrefs();
// when(mockPrefs.useTor).thenAnswer((realInvocation) => false);
// final torService = MockTorService();
// when(mockPrefs.wifiOnly).thenAnswer((_) => false);
// final client = ElectrumXClient(
// host: "some server",
// port: 0,
// useSSL: true,
// client: mockClient,
// prefs: mockPrefs,
// torService: torService,
// failovers: []);
//
// expect(
// () => client.getTransaction(
// txHash: SampleGetTransactionData.txHash0,
// requestID: "some requestId"),
// throwsA(isA<Exception>()));
//
// verify(mockPrefs.wifiOnly).called(1);
// verifyNoMoreInteractions(mockPrefs);
// });
// });
//
// group("getAnonymitySet", () {
// test("getAnonymitySet success", () async {
// final mockClient = MockJsonRPC();
// const command = "lelantus.getanonymityset";
// const jsonArgs = '["1",""]';
// when(
// mockClient.request(
// '{"jsonrpc": "2.0", "id": "some requestId",'
// '"method": "$command","params": $jsonArgs}',
// const Duration(seconds: 60),
// ),
// ).thenAnswer(
// (_) async => JsonRPCResponse(data: {
// "jsonrpc": "2.0",
// "result": GetAnonymitySetSampleData.data,
// "id": "some requestId"
// }),
// );
//
// final mockPrefs = MockPrefs();
// when(mockPrefs.useTor).thenAnswer((realInvocation) => false);
// final torService = MockTorService();
// when(mockPrefs.wifiOnly).thenAnswer((_) => false);
// final client = ElectrumXClient(
// host: "some server",
// port: 0,
// useSSL: true,
// client: mockClient,
// prefs: mockPrefs,
// torService: torService,
// failovers: []);
//
// final result = await client.getLelantusAnonymitySet(
// groupId: "1", blockhash: "", requestID: "some requestId");
//
// expect(result, GetAnonymitySetSampleData.data);
//
// verify(mockPrefs.wifiOnly).called(1);
// verify(mockPrefs.useTor).called(1);
// verifyNoMoreInteractions(mockPrefs);
// });
//
// test("getAnonymitySet throws/fails", () {
// final mockClient = MockJsonRPC();
// const command = "lelantus.getanonymityset";
// const jsonArgs = '["1",""]';
// when(
// mockClient.request(
// '{"jsonrpc": "2.0", "id": "some requestId",'
// '"method": "$command","params": $jsonArgs}',
// const Duration(seconds: 60),
// ),
// ).thenThrow(Exception());
//
// final mockPrefs = MockPrefs();
// when(mockPrefs.useTor).thenAnswer((realInvocation) => false);
// final torService = MockTorService();
// when(mockPrefs.wifiOnly).thenAnswer((_) => false);
// final client = ElectrumXClient(
// host: "some server",
// port: 0,
// useSSL: true,
// client: mockClient,
// prefs: mockPrefs,
// torService: torService,
// failovers: []);
//
// expect(
// () => client.getLelantusAnonymitySet(
// groupId: "1", requestID: "some requestId"),
// throwsA(isA<Exception>()));
//
// verify(mockPrefs.wifiOnly).called(1);
// verifyNoMoreInteractions(mockPrefs);
// });
// });
//
// group("getMintData", () {
// test("getMintData success", () async {
// final mockClient = MockJsonRPC();
// const command = "lelantus.getmintmetadata";
// const jsonArgs = '["some mints"]';
// when(
// mockClient.request(
// '{"jsonrpc": "2.0", "id": "some requestId",'
// '"method": "$command","params": $jsonArgs}',
// const Duration(seconds: 60),
// ),
// ).thenAnswer(
// (_) async => JsonRPCResponse(data: {
// "jsonrpc": "2.0",
// "result": "mint meta data",
// "id": "some requestId"
// }),
// );
//
// final mockPrefs = MockPrefs();
// when(mockPrefs.useTor).thenAnswer((realInvocation) => false);
// final torService = MockTorService();
// when(mockPrefs.wifiOnly).thenAnswer((_) => false);
// final client = ElectrumXClient(
// host: "some server",
// port: 0,
// useSSL: true,
// client: mockClient,
// prefs: mockPrefs,
// torService: torService,
// failovers: []);
//
// final result = await client.getLelantusMintData(
// mints: "some mints", requestID: "some requestId");
//
// expect(result, "mint meta data");
//
// verify(mockPrefs.wifiOnly).called(1);
// verify(mockPrefs.useTor).called(1);
// verifyNoMoreInteractions(mockPrefs);
// });
//
// test("getMintData throws/fails", () {
// final mockClient = MockJsonRPC();
// const command = "lelantus.getmintmetadata";
// const jsonArgs = '["some mints"]';
// when(
// mockClient.request(
// '{"jsonrpc": "2.0", "id": "some requestId",'
// '"method": "$command","params": $jsonArgs}',
// const Duration(seconds: 60),
// ),
// ).thenThrow(Exception());
//
// final mockPrefs = MockPrefs();
// when(mockPrefs.useTor).thenAnswer((realInvocation) => false);
// final torService = MockTorService();
// when(mockPrefs.wifiOnly).thenAnswer((_) => false);
// final client = ElectrumXClient(
// host: "some server",
// port: 0,
// useSSL: true,
// client: mockClient,
// prefs: mockPrefs,
// torService: torService,
// failovers: []);
//
// expect(
// () => client.getLelantusMintData(
// mints: "some mints", requestID: "some requestId"),
// throwsA(isA<Exception>()));
//
// verify(mockPrefs.wifiOnly).called(1);
// verifyNoMoreInteractions(mockPrefs);
// });
// });
//
// group("getUsedCoinSerials", () {
// test("getUsedCoinSerials success", () async {
// final mockClient = MockJsonRPC();
// const command = "lelantus.getusedcoinserials";
// const jsonArgs = '["0"]';
// when(
// mockClient.request(
// '{"jsonrpc": "2.0", "id": "some requestId",'
// '"method": "$command","params": $jsonArgs}',
// const Duration(minutes: 2),
// ),
// ).thenAnswer(
// (_) async => JsonRPCResponse(data: {
// "jsonrpc": "2.0",
// "result": GetUsedSerialsSampleData.serials,
// "id": "some requestId"
// }),
// );
//
// final mockPrefs = MockPrefs();
// when(mockPrefs.useTor).thenAnswer((realInvocation) => false);
// final torService = MockTorService();
// when(mockPrefs.wifiOnly).thenAnswer((_) => false);
// final client = ElectrumXClient(
// host: "some server",
// port: 0,
// useSSL: true,
// client: mockClient,
// prefs: mockPrefs,
// torService: torService,
// failovers: []);
//
// final result = await client.getLelantusUsedCoinSerials(
// requestID: "some requestId", startNumber: 0);
//
// expect(result, GetUsedSerialsSampleData.serials);
//
// verify(mockPrefs.wifiOnly).called(3);
// verify(mockPrefs.useTor).called(3);
// verifyNoMoreInteractions(mockPrefs);
// });
//
// test("getUsedCoinSerials throws/fails", () {
// final mockClient = MockJsonRPC();
// const command = "lelantus.getusedcoinserials";
// const jsonArgs = '["0"]';
// when(
// mockClient.request(
// '{"jsonrpc": "2.0", "id": "some requestId",'
// '"method": "$command","params": $jsonArgs}',
// const Duration(minutes: 2),
// ),
// ).thenThrow(Exception());
//
// final mockPrefs = MockPrefs();
// when(mockPrefs.useTor).thenAnswer((realInvocation) => false);
// final torService = MockTorService();
// when(mockPrefs.wifiOnly).thenAnswer((_) => false);
// final client = ElectrumXClient(
// host: "some server",
// port: 0,
// useSSL: true,
// client: mockClient,
// prefs: mockPrefs,
// torService: torService,
// failovers: []);
//
// expect(
// () => client.getLelantusUsedCoinSerials(
// requestID: "some requestId", startNumber: 0),
// throwsA(isA<Exception>()));
//
// verify(mockPrefs.wifiOnly).called(1);
// verifyNoMoreInteractions(mockPrefs);
// });
// });
//
// group("getLatestCoinId", () {
// test("getLatestCoinId success", () async {
// final mockClient = MockJsonRPC();
// const command = "lelantus.getlatestcoinid";
// const jsonArgs = '[]';
// when(
// mockClient.request(
// '{"jsonrpc": "2.0", "id": "some requestId",'
// '"method": "$command","params": $jsonArgs}',
// const Duration(seconds: 60),
// ),
// ).thenAnswer(
// (_) async => JsonRPCResponse(data: {
// "jsonrpc": "2.0",
// "result": 1,
// "id": "some requestId",
// }),
// );
//
// final mockPrefs = MockPrefs();
// when(mockPrefs.useTor).thenAnswer((realInvocation) => false);
// final torService = MockTorService();
// when(mockPrefs.wifiOnly).thenAnswer((_) => false);
// final client = ElectrumXClient(
// host: "some server",
// port: 0,
// useSSL: true,
// client: mockClient,
// prefs: mockPrefs,
// torService: torService,
// failovers: []);
//
// final result =
// await client.getLelantusLatestCoinId(requestID: "some requestId");
//
// expect(result, 1);
//
// verify(mockPrefs.wifiOnly).called(1);
// verify(mockPrefs.useTor).called(1);
// verifyNoMoreInteractions(mockPrefs);
// });
//
// test("getLatestCoinId throws/fails", () {
// final mockClient = MockJsonRPC();
// const command = "lelantus.getlatestcoinid";
// const jsonArgs = '[]';
// when(
// mockClient.request(
// '{"jsonrpc": "2.0", "id": "some requestId",'
// '"method": "$command","params": $jsonArgs}',
// const Duration(seconds: 60),
// ),
// ).thenThrow(Exception());
//
// final mockPrefs = MockPrefs();
// when(mockPrefs.useTor).thenAnswer((realInvocation) => false);
// final torService = MockTorService();
// when(mockPrefs.wifiOnly).thenAnswer((_) => false);
// final client = ElectrumXClient(
// host: "some server",
// port: 0,
// useSSL: true,
// client: mockClient,
// prefs: mockPrefs,
// torService: torService,
// failovers: []);
//
// expect(
// () => client.getLelantusLatestCoinId(
// requestID: "some requestId",
// ),
// throwsA(isA<Exception>()));
//
// verify(mockPrefs.wifiOnly).called(1);
// verifyNoMoreInteractions(mockPrefs);
// });
// });
//
// group("getCoinsForRecovery", () {
// test("getCoinsForRecovery success", () async {
// final mockClient = MockJsonRPC();
// const command = "lelantus.getanonymityset";
// const jsonArgs = '["1",""]';
// when(
// mockClient.request(
// '{"jsonrpc": "2.0", "id": "some requestId",'
// '"method": "$command","params": $jsonArgs}',
// const Duration(seconds: 60),
// ),
// ).thenAnswer(
// (_) async => JsonRPCResponse(data: {
// "jsonrpc": "2.0",
// "result": GetAnonymitySetSampleData.data,
// "id": "some requestId"
// }),
// );
//
// final mockPrefs = MockPrefs();
// when(mockPrefs.useTor).thenAnswer((realInvocation) => false);
// final torService = MockTorService();
// when(mockPrefs.wifiOnly).thenAnswer((_) => false);
// final client = ElectrumXClient(
// host: "some server",
// port: 0,
// useSSL: true,
// client: mockClient,
// prefs: mockPrefs,
// torService: torService,
// failovers: []);
//
// final result = await client.getLelantusAnonymitySet(
// groupId: "1", blockhash: "", requestID: "some requestId");
//
// expect(result, GetAnonymitySetSampleData.data);
//
// verify(mockPrefs.wifiOnly).called(1);
// verify(mockPrefs.useTor).called(1);
// verifyNoMoreInteractions(mockPrefs);
// });
//
// test("getAnonymitySet throws/fails", () {
// final mockClient = MockJsonRPC();
// const command = "lelantus.getanonymityset";
// const jsonArgs = '["1",""]';
// when(
// mockClient.request(
// '{"jsonrpc": "2.0", "id": "some requestId",'
// '"method": "$command","params": $jsonArgs}',
// const Duration(seconds: 60),
// ),
// ).thenThrow(Exception());
//
// final mockPrefs = MockPrefs();
// when(mockPrefs.useTor).thenAnswer((realInvocation) => false);
// final torService = MockTorService();
// when(mockPrefs.wifiOnly).thenAnswer((_) => false);
// final client = ElectrumXClient(
// host: "some server",
// port: 0,
// useSSL: true,
// client: mockClient,
// prefs: mockPrefs,
// torService: torService,
// failovers: []);
//
// expect(
// () => client.getLelantusAnonymitySet(
// groupId: "1",
// requestID: "some requestId",
// ),
// throwsA(isA<Exception>()));
//
// verify(mockPrefs.wifiOnly).called(1);
// verifyNoMoreInteractions(mockPrefs);
// });
// });
//
// group("getMintData", () {
// test("getMintData success", () async {
// final mockClient = MockJsonRPC();
// const command = "lelantus.getmintmetadata";
// const jsonArgs = '["some mints"]';
// when(
// mockClient.request(
// '{"jsonrpc": "2.0", "id": "some requestId",'
// '"method": "$command","params": $jsonArgs}',
// const Duration(seconds: 60),
// ),
// ).thenAnswer(
// (_) async => JsonRPCResponse(data: {
// "jsonrpc": "2.0",
// "result": "mint meta data",
// "id": "some requestId"
// }),
// );
//
// final mockPrefs = MockPrefs();
// when(mockPrefs.useTor).thenAnswer((realInvocation) => false);
// final torService = MockTorService();
// when(mockPrefs.wifiOnly).thenAnswer((_) => false);
// final client = ElectrumXClient(
// host: "some server",
// port: 0,
// useSSL: true,
// client: mockClient,
// prefs: mockPrefs,
// torService: torService,
// failovers: []);
//
// final result = await client.getLelantusMintData(
// mints: "some mints", requestID: "some requestId");
//
// expect(result, "mint meta data");
//
// verify(mockPrefs.wifiOnly).called(1);
// verify(mockPrefs.useTor).called(1);
// verifyNoMoreInteractions(mockPrefs);
// });
//
// test("getMintData throws/fails", () {
// final mockClient = MockJsonRPC();
// const command = "lelantus.getmintmetadata";
// const jsonArgs = '["some mints"]';
// when(
// mockClient.request(
// '{"jsonrpc": "2.0", "id": "some requestId",'
// '"method": "$command","params": $jsonArgs}',
// const Duration(seconds: 60),
// ),
// ).thenThrow(Exception());
//
// final mockPrefs = MockPrefs();
// when(mockPrefs.useTor).thenAnswer((realInvocation) => false);
// final torService = MockTorService();
// when(mockPrefs.wifiOnly).thenAnswer((_) => false);
// final client = ElectrumXClient(
// host: "some server",
// port: 0,
// useSSL: true,
// client: mockClient,
// prefs: mockPrefs,
// torService: torService,
// failovers: []);
//
// expect(
// () => client.getLelantusMintData(
// mints: "some mints",
// requestID: "some requestId",
// ),
// throwsA(isA<Exception>()));
//
// verify(mockPrefs.wifiOnly).called(1);
// verifyNoMoreInteractions(mockPrefs);
// });
// });
//
// group("getUsedCoinSerials", () {
// test("getUsedCoinSerials success", () async {
// final mockClient = MockJsonRPC();
// const command = "lelantus.getusedcoinserials";
// const jsonArgs = '["0"]';
// when(
// mockClient.request(
// '{"jsonrpc": "2.0", "id": "some requestId",'
// '"method": "$command","params": $jsonArgs}',
// const Duration(minutes: 2),
// ),
// ).thenAnswer(
// (_) async => JsonRPCResponse(data: {
// "jsonrpc": "2.0",
// "result": GetUsedSerialsSampleData.serials,
// "id": "some requestId"
// }),
// );
//
// final mockPrefs = MockPrefs();
// when(mockPrefs.useTor).thenAnswer((realInvocation) => false);
// final torService = MockTorService();
// when(mockPrefs.wifiOnly).thenAnswer((_) => false);
// final client = ElectrumXClient(
// host: "some server",
// port: 0,
// useSSL: true,
// client: mockClient,
// prefs: mockPrefs,
// torService: torService,
// failovers: []);
//
// final result = await client.getLelantusUsedCoinSerials(
// requestID: "some requestId", startNumber: 0);
//
// expect(result, GetUsedSerialsSampleData.serials);
//
// verify(mockPrefs.wifiOnly).called(3);
// verify(mockPrefs.useTor).called(3);
// verifyNoMoreInteractions(mockPrefs);
// });
//
// test("getUsedCoinSerials throws/fails", () {
// final mockClient = MockJsonRPC();
// const command = "lelantus.getusedcoinserials";
// const jsonArgs = '["0"]';
// when(
// mockClient.request(
// '{"jsonrpc": "2.0", "id": "some requestId",'
// '"method": "$command","params": $jsonArgs}',
// const Duration(minutes: 2),
// ),
// ).thenThrow(Exception());
//
// final mockPrefs = MockPrefs();
// when(mockPrefs.useTor).thenAnswer((realInvocation) => false);
// final torService = MockTorService();
// when(mockPrefs.wifiOnly).thenAnswer((_) => false);
// final client = ElectrumXClient(
// host: "some server",
// port: 0,
// useSSL: true,
// client: mockClient,
// prefs: mockPrefs,
// torService: torService,
// failovers: []);
//
// expect(
// () => client.getLelantusUsedCoinSerials(
// requestID: "some requestId", startNumber: 0),
// throwsA(isA<Exception>()));
//
// verify(mockPrefs.wifiOnly).called(1);
// verifyNoMoreInteractions(mockPrefs);
// });
// });
//
// group("getLatestCoinId", () {
// test("getLatestCoinId success", () async {
// final mockClient = MockJsonRPC();
// const command = "lelantus.getlatestcoinid";
// const jsonArgs = '[]';
// when(
// mockClient.request(
// '{"jsonrpc": "2.0", "id": "some requestId",'
// '"method": "$command","params": $jsonArgs}',
// const Duration(seconds: 60),
// ),
// ).thenAnswer(
// (_) async => JsonRPCResponse(data: {
// "jsonrpc": "2.0",
// "result": 1,
// "id": "some requestId",
// }),
// );
//
// final mockPrefs = MockPrefs();
// when(mockPrefs.useTor).thenAnswer((realInvocation) => false);
// final torService = MockTorService();
// when(mockPrefs.wifiOnly).thenAnswer((_) => false);
// final client = ElectrumXClient(
// host: "some server",
// port: 0,
// useSSL: true,
// client: mockClient,
// prefs: mockPrefs,
// torService: torService,
// failovers: []);
//
// final result =
// await client.getLelantusLatestCoinId(requestID: "some requestId");
//
// expect(result, 1);
//
// verify(mockPrefs.wifiOnly).called(1);
// verify(mockPrefs.useTor).called(1);
// verifyNoMoreInteractions(mockPrefs);
// });
//
// test("getLatestCoinId throws/fails", () {
// final mockClient = MockJsonRPC();
// const command = "lelantus.getlatestcoinid";
// const jsonArgs = '[]';
// when(
// mockClient.request(
// '{"jsonrpc": "2.0", "id": "some requestId",'
// '"method": "$command","params": $jsonArgs}',
// const Duration(seconds: 60),
// ),
// ).thenThrow(Exception());
//
// final mockPrefs = MockPrefs();
// when(mockPrefs.useTor).thenAnswer((realInvocation) => false);
// final torService = MockTorService();
// when(mockPrefs.wifiOnly).thenAnswer((_) => false);
// final client = ElectrumXClient(
// host: "some server",
// port: 0,
// useSSL: true,
// client: mockClient,
// prefs: mockPrefs,
// torService: torService,
// failovers: []);
//
// expect(() => client.getLelantusLatestCoinId(requestID: "some requestId"),
// throwsA(isA<Exception>()));
//
// verify(mockPrefs.wifiOnly).called(1);
// verifyNoMoreInteractions(mockPrefs);
// });
// });
//
// group("getFeeRate", () {
// test("getFeeRate success", () async {
// final mockClient = MockJsonRPC();
// const command = "blockchain.getfeerate";
// const jsonArgs = '[]';
// when(
// mockClient.request(
// '{"jsonrpc": "2.0", "id": "some requestId",'
// '"method": "$command","params": $jsonArgs}',
// const Duration(seconds: 60),
// ),
// ).thenAnswer(
// (_) async => JsonRPCResponse(data: {
// "jsonrpc": "2.0",
// "result": {
// "rate": 1000,
// },
// "id": "some requestId"
// }),
// );
//
// final mockPrefs = MockPrefs();
// when(mockPrefs.useTor).thenAnswer((realInvocation) => false);
// final torService = MockTorService();
// when(mockPrefs.wifiOnly).thenAnswer((_) => false);
// final client = ElectrumXClient(
// host: "some server",
// port: 0,
// useSSL: true,
// client: mockClient,
// prefs: mockPrefs,
// torService: torService,
// failovers: []);
//
// final result = await client.getFeeRate(requestID: "some requestId");
//
// expect(result, {"rate": 1000});
//
// verify(mockPrefs.wifiOnly).called(1);
// verify(mockPrefs.useTor).called(1);
// verifyNoMoreInteractions(mockPrefs);
// });
//
// test("getFeeRate throws/fails", () {
// final mockClient = MockJsonRPC();
// const command = "blockchain.getfeerate";
// const jsonArgs = '[]';
// when(
// mockClient.request(
// '{"jsonrpc": "2.0", "id": "some requestId",'
// '"method": "$command","params": $jsonArgs}',
// const Duration(seconds: 60),
// ),
// ).thenThrow(Exception());
//
// final mockPrefs = MockPrefs();
// when(mockPrefs.useTor).thenAnswer((realInvocation) => false);
// final torService = MockTorService();
// when(mockPrefs.wifiOnly).thenAnswer((_) => false);
// final client = ElectrumXClient(
// host: "some server",
// port: 0,
// useSSL: true,
// client: mockClient,
// prefs: mockPrefs,
// torService: torService,
// failovers: []);
//
// expect(() => client.getFeeRate(requestID: "some requestId"),
// throwsA(isA<Exception>()));
//
// verify(mockPrefs.wifiOnly).called(1);
// verifyNoMoreInteractions(mockPrefs);
// });
// });
//
// test("rpcClient is null throws with bad server info", () {
// final mockPrefs = MockPrefs();
// when(mockPrefs.useTor).thenAnswer((realInvocation) => false);
// final torService = MockTorService();
// when(mockPrefs.wifiOnly).thenAnswer((_) => false);
// final client = ElectrumXClient(
// client: null,
// port: -10,
// host: "_ :sa %",
// useSSL: false,
// prefs: mockPrefs,
// torService: torService,
// failovers: [],
// );
//
// expect(() => client.getFeeRate(), throwsA(isA<Exception>()));
//
// verify(mockPrefs.wifiOnly).called(1);
// verifyNoMoreInteractions(mockPrefs);
// });
//
// group("Tor tests", () {
// // useTor is false, so no TorService calls should be made.
// test("Tor not in use", () async {
// final mockClient = MockJsonRPC();
// const command = "blockchain.transaction.get";
// const jsonArgs = '["${SampleGetTransactionData.txHash0}",true]';
// when(mockClient.request(
// '{"jsonrpc": "2.0", "id": "some requestId","method": "$command","params": $jsonArgs}',
// const Duration(seconds: 60),
// )).thenAnswer((_) async => JsonRPCResponse(data: {
// "jsonrpc": "2.0",
// "result": SampleGetTransactionData.txData0,
// "id": "some requestId",
// }));
//
// final mockPrefs = MockPrefs();
// when(mockPrefs.useTor).thenAnswer((_) => false);
// when(mockPrefs.torKillSwitch)
// .thenAnswer((_) => false); // Or true, shouldn't matter.
// when(mockPrefs.wifiOnly).thenAnswer((_) => false);
// final mockTorService = MockTorService();
// when(mockTorService.status)
// .thenAnswer((_) => TorConnectionStatus.disconnected);
//
// final client = ElectrumXClient(
// host: "some server",
// port: 0,
// useSSL: true,
// client: mockClient,
// failovers: [],
// prefs: mockPrefs,
// torService: mockTorService,
// );
//
// final result = await client.getTransaction(
// txHash: SampleGetTransactionData.txHash0,
// verbose: true,
// requestID: "some requestId");
//
// expect(result, SampleGetTransactionData.txData0);
//
// verify(mockPrefs.wifiOnly).called(1);
// verify(mockPrefs.useTor).called(1);
// verifyNever(mockPrefs.torKillSwitch);
// verifyNoMoreInteractions(mockPrefs);
// verifyNever(mockTorService.status);
// verifyNoMoreInteractions(mockTorService);
// });
//
// // useTor is true, but TorService is not enabled and the killswitch is off, so a clearnet call should be made.
// test("Tor in use but Tor unavailable and killswitch off", () async {
// final mockClient = MockJsonRPC();
// const command = "blockchain.transaction.get";
// const jsonArgs = '["${SampleGetTransactionData.txHash0}",true]';
// when(mockClient.request(
// '{"jsonrpc": "2.0", "id": "some requestId","method": "$command","params": $jsonArgs}',
// const Duration(seconds: 60),
// )).thenAnswer((_) async => JsonRPCResponse(data: {
// "jsonrpc": "2.0",
// "result": SampleGetTransactionData.txData0,
// "id": "some requestId",
// }));
//
// final mockPrefs = MockPrefs();
// when(mockPrefs.useTor).thenAnswer((_) => true);
// when(mockPrefs.torKillSwitch).thenAnswer((_) => false);
// when(mockPrefs.wifiOnly).thenAnswer((_) => false);
//
// final mockTorService = MockTorService();
// when(mockTorService.status)
// .thenAnswer((_) => TorConnectionStatus.disconnected);
// when(mockTorService.getProxyInfo()).thenAnswer((_) => (
// host: InternetAddress('1.2.3.4'),
// port: -1
// )); // Port is set to -1 until Tor is enabled.
//
// final client = ElectrumXClient(
// host: "some server",
// port: 0,
// useSSL: true,
// client: mockClient,
// prefs: mockPrefs,
// torService: mockTorService,
// failovers: []);
//
// final result = await client.getTransaction(
// txHash: SampleGetTransactionData.txHash0,
// verbose: true,
// requestID: "some requestId");
//
// expect(result, SampleGetTransactionData.txData0);
//
// verify(mockPrefs.wifiOnly).called(1);
// verify(mockPrefs.useTor).called(1);
// verify(mockPrefs.torKillSwitch).called(1);
// verifyNoMoreInteractions(mockPrefs);
// verify(mockTorService.status).called(1);
// verifyNever(mockTorService.getProxyInfo());
// verifyNoMoreInteractions(mockTorService);
// });
//
// // useTor is true and TorService is enabled, so a TorService call should be made.
// test("Tor in use and available", () async {
// final mockClient = MockJsonRPC();
// const command = "blockchain.transaction.get";
// const jsonArgs = '["${SampleGetTransactionData.txHash0}",true]';
// when(mockClient.request(
// '{"jsonrpc": "2.0", "id": "some requestId","method": "$command","params": $jsonArgs}',
// const Duration(seconds: 60),
// )).thenAnswer((_) async => JsonRPCResponse(data: {
// "jsonrpc": "2.0",
// "result": SampleGetTransactionData.txData0,
// "id": "some requestId",
// }));
// when(mockClient.proxyInfo)
// .thenAnswer((_) => (host: InternetAddress('1.2.3.4'), port: 42));
//
// final mockPrefs = MockPrefs();
// when(mockPrefs.useTor).thenAnswer((_) => true);
// when(mockPrefs.torKillSwitch).thenAnswer((_) => false); // Or true.
// when(mockPrefs.wifiOnly).thenAnswer((_) => false);
//
// final mockTorService = MockTorService();
// when(mockTorService.status)
// .thenAnswer((_) => TorConnectionStatus.connected);
// when(mockTorService.getProxyInfo())
// .thenAnswer((_) => (host: InternetAddress('1.2.3.4'), port: 42));
//
// final client = ElectrumXClient(
// host: "some server",
// port: 0,
// useSSL: true,
// client: mockClient,
// prefs: mockPrefs,
// torService: mockTorService,
// failovers: []);
//
// final result = await client.getTransaction(
// txHash: SampleGetTransactionData.txHash0,
// verbose: true,
// requestID: "some requestId");
//
// expect(result, SampleGetTransactionData.txData0);
//
// verify(mockClient.proxyInfo).called(1);
// verify(mockPrefs.wifiOnly).called(1);
// verify(mockPrefs.useTor).called(1);
// verifyNever(mockPrefs.torKillSwitch);
// verifyNoMoreInteractions(mockPrefs);
// verify(mockTorService.status).called(1);
// verify(mockTorService.getProxyInfo()).called(1);
// verifyNoMoreInteractions(mockTorService);
// });
//
// // useTor is true, but TorService is not enabled and the killswitch is on, so no TorService calls should be made.
// test("killswitch enabled", () async {
// final mockClient = MockJsonRPC();
// const command = "blockchain.transaction.get";
// const jsonArgs = '["",true]';
// when(
// mockClient.request(
// '{"jsonrpc": "2.0", "id": "some requestId",'
// '"method": "$command","params": $jsonArgs}',
// const Duration(seconds: 60),
// ),
// ).thenAnswer(
// (_) async => JsonRPCResponse(data: {
// "jsonrpc": "2.0",
// "error": {
// "code": 1,
// "message": "None should be a transaction hash",
// },
// "id": "some requestId",
// }),
// );
//
// final mockPrefs = MockPrefs();
// when(mockPrefs.useTor).thenAnswer((_) => true);
// when(mockPrefs.torKillSwitch).thenAnswer((_) => true);
// when(mockPrefs.wifiOnly).thenAnswer((_) => false);
// final mockTorService = MockTorService();
// when(mockTorService.status)
// .thenAnswer((_) => TorConnectionStatus.disconnected);
//
// final client = ElectrumXClient(
// host: "some server",
// port: 0,
// useSSL: true,
// client: mockClient,
// failovers: [],
// prefs: mockPrefs,
// torService: mockTorService,
// );
//
// try {
// var result = await client.getTransaction(
// requestID: "some requestId", txHash: '');
// } catch (e) {
// expect(e, isA<Exception>());
// expect(
// e.toString(),
// equals(
// "Exception: Tor preference and killswitch set but Tor is not enabled, not connecting to ElectrumX"));
// }
//
// verify(mockPrefs.wifiOnly).called(1);
// verify(mockPrefs.useTor).called(1);
// verify(mockPrefs.torKillSwitch).called(1);
// verifyNoMoreInteractions(mockPrefs);
// verify(mockTorService.status).called(1);
// verifyNoMoreInteractions(mockTorService);
// });
//
// // useTor is true but Tor is not enabled, but because the killswitch is off, a clearnet call should be made.
// test("killswitch disabled", () async {
// final mockClient = MockJsonRPC();
// const command = "blockchain.transaction.get";
// const jsonArgs = '["${SampleGetTransactionData.txHash0}",true]';
// when(
// mockClient.request(
// '{"jsonrpc": "2.0", "id": "some requestId",'
// '"method": "$command","params": $jsonArgs}',
// const Duration(seconds: 60),
// ),
// ).thenAnswer(
// (_) async => JsonRPCResponse(data: {
// "jsonrpc": "2.0",
// "result": SampleGetTransactionData.txData0,
// "id": "some requestId"
// }),
// );
//
// final mockPrefs = MockPrefs();
// when(mockPrefs.useTor).thenAnswer((_) => true);
// when(mockPrefs.torKillSwitch).thenAnswer((_) => false);
// when(mockPrefs.wifiOnly).thenAnswer((_) => false);
// final mockTorService = MockTorService();
// when(mockTorService.status)
// .thenAnswer((_) => TorConnectionStatus.disconnected);
//
// final client = ElectrumXClient(
// host: "some server",
// port: 0,
// useSSL: true,
// client: mockClient,
// failovers: [],
// prefs: mockPrefs,
// torService: mockTorService,
// );
//
// final result = await client.getTransaction(
// txHash: SampleGetTransactionData.txHash0,
// verbose: true,
// requestID: "some requestId");
//
// expect(result, SampleGetTransactionData.txData0);
//
// verify(mockPrefs.wifiOnly).called(1);
// verify(mockPrefs.useTor).called(1);
// verify(mockPrefs.torKillSwitch).called(1);
// verifyNoMoreInteractions(mockPrefs);
// verify(mockTorService.status).called(1);
// verifyNoMoreInteractions(mockTorService);
// });
// });
// }
Reference in a new issue Copy permalink