mirror of
https://github.com/cypherstack/stack_wallet.git
synced 2024-12-24 12:29:37 +00:00
1778 lines
61 KiB
Dart
1778 lines
61 KiB
Dart
// 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);
|
|
// });
|
|
// });
|
|
// }
|