async def setUp(self): await super(TestTrustchainStatsEndpoint, self).setUp() self.mock_ipv8 = MockIPv8(u"low", TrustChainCommunity, working_directory=self.session.config.get_state_dir()) self.session.trustchain_community = self.mock_ipv8.overlay self.session.wallets['MB'] = TrustchainWallet(self.session.trustchain_community)
def create_node(self): dum1_wallet = DummyWallet1() dum2_wallet = DummyWallet2() dum1_wallet.MONITOR_DELAY = 0 dum2_wallet.MONITOR_DELAY = 0 wallets = {'DUM1': dum1_wallet, 'DUM2': dum2_wallet} mock_ipv8 = MockIPv8(u"curve25519", MarketCommunity, create_trustchain=True, create_dht=True, is_matchmaker=True, wallets=wallets, use_database=False, working_directory=u":memory:") tc_wallet = TrustchainWallet(mock_ipv8.trustchain) mock_ipv8.overlay.wallets['MB'] = tc_wallet return mock_ipv8
def create_node(self): mock_ipv8 = MockIPv8( u"curve25519", TriblerTunnelCommunity, socks_listen_ports=[], exitnode_cache=mkdtemp(suffix="_tribler_test_cache") / 'cache.dat') mock_ipv8.overlay.settings.max_circuits = 1 # Load the TrustChain community mock_ipv8.trustchain = TrustChainCommunity( mock_ipv8.my_peer, mock_ipv8.endpoint, mock_ipv8.network, working_directory=u":memory:") mock_ipv8.overlay.bandwidth_wallet = TrustchainWallet( mock_ipv8.trustchain) mock_ipv8.overlay.dht_provider = MockDHTProvider( Peer(mock_ipv8.overlay.my_peer.key, mock_ipv8.overlay.my_estimated_wan)) return mock_ipv8
def create_node(self): dum1_wallet = DummyWallet1() dum2_wallet = DummyWallet2() dum1_wallet.MONITOR_DELAY = 0 dum2_wallet.MONITOR_DELAY = 0 wallets = {'DUM1': dum1_wallet, 'DUM2': dum2_wallet} mock_ipv8 = MockIPv8("curve25519", MarketCommunity, create_dht=True, is_matchmaker=True, wallets=wallets, use_database=self.use_database(), working_directory=self.get_db_location()) trustchain = TrustChainCommunity(mock_ipv8.my_peer, mock_ipv8.endpoint, mock_ipv8.network, working_directory=":memory:") mock_ipv8.overlay.trustchain = trustchain mock_ipv8.overlay.initialize_trustchain() tc_wallet = TrustchainWallet(mock_ipv8.overlay.trustchain) mock_ipv8.overlay.wallets['MB'] = tc_wallet mock_ipv8.overlay.settings.max_concurrent_trades = 0 mock_ipv8.overlay.clearing_policies = [] return mock_ipv8
def create_node(self): dum1_wallet = DummyWallet1() dum2_wallet = DummyWallet2() dum1_wallet.MONITOR_DELAY = 0 dum2_wallet.MONITOR_DELAY = 0 wallets = {'DUM1': dum1_wallet, 'DUM2': dum2_wallet} mock_ipv8 = MockIPv8(u"curve25519", MarketCommunity, create_trustchain=True, create_dht=True, is_matchmaker=True, wallets=wallets, use_database=self.use_database(), working_directory=self.get_db_location()) tc_wallet = TrustchainWallet(mock_ipv8.trustchain) mock_ipv8.overlay.wallets['MB'] = tc_wallet mock_ipv8.overlay.settings.single_trade = False mock_ipv8.overlay.clearing_policies = [] return mock_ipv8
def load_ipv8_overlays(self): if self.config.get_testnet(): peer = Peer(self.trustchain_testnet_keypair) else: peer = Peer(self.trustchain_keypair) discovery_community = DiscoveryCommunity(peer, self.ipv8.endpoint, self.ipv8.network) discovery_community.resolve_dns_bootstrap_addresses() self.ipv8.overlays.append(discovery_community) self.ipv8.strategies.append((RandomChurn(discovery_community), -1)) self.ipv8.strategies.append( (PeriodicSimilarity(discovery_community), -1)) self.ipv8.strategies.append((RandomWalk(discovery_community), 20)) # TrustChain Community if self.config.get_trustchain_enabled(): from ipv8.attestation.trustchain.community import TrustChainCommunity, \ TrustChainTestnetCommunity community_cls = TrustChainTestnetCommunity if self.config.get_testnet( ) else TrustChainCommunity self.trustchain_community = community_cls( peer, self.ipv8.endpoint, self.ipv8.network, working_directory=self.config.get_state_dir()) self.ipv8.overlays.append(self.trustchain_community) self.ipv8.strategies.append( (EdgeWalk(self.trustchain_community), 20)) tc_wallet = TrustchainWallet(self.trustchain_community) self.wallets[tc_wallet.get_identifier()] = tc_wallet # DHT Community if self.config.get_dht_enabled(): from ipv8.dht.discovery import DHTDiscoveryCommunity self.dht_community = DHTDiscoveryCommunity(peer, self.ipv8.endpoint, self.ipv8.network) self.ipv8.overlays.append(self.dht_community) self.ipv8.strategies.append((RandomWalk(self.dht_community), 20)) self.ipv8.strategies.append((PingChurn(self.dht_community), -1)) # Tunnel Community if self.config.get_tunnel_community_enabled(): from tribler_core.modules.tunnel.community.triblertunnel_community import TriblerTunnelCommunity,\ TriblerTunnelTestnetCommunity from tribler_core.modules.tunnel.community.discovery import GoldenRatioStrategy community_cls = TriblerTunnelTestnetCommunity if self.config.get_testnet() else \ TriblerTunnelCommunity random_slots = self.config.get_tunnel_community_random_slots() competing_slots = self.config.get_tunnel_community_competing_slots( ) dht_provider = DHTCommunityProvider(self.dht_community, self.config.get_ipv8_port()) settings = TunnelSettings() settings.min_circuits = 3 settings.max_circuits = 10 self.tunnel_community = community_cls( peer, self.ipv8.endpoint, self.ipv8.network, tribler_session=self, dht_provider=dht_provider, ipv8=self.ipv8, bandwidth_wallet=self.wallets["MB"], random_slots=random_slots, competing_slots=competing_slots, settings=settings) self.ipv8.overlays.append(self.tunnel_community) self.ipv8.strategies.append( (RandomWalk(self.tunnel_community), 20)) self.ipv8.strategies.append( (GoldenRatioStrategy(self.tunnel_community), -1)) # Market Community if self.config.get_market_community_enabled( ) and self.config.get_dht_enabled(): from anydex.core.community import MarketCommunity, MarketTestnetCommunity community_cls = MarketTestnetCommunity if self.config.get_testnet( ) else MarketCommunity self.market_community = community_cls( peer, self.ipv8.endpoint, self.ipv8.network, trustchain=self.trustchain_community, dht=self.dht_community, wallets=self.wallets, working_directory=self.config.get_state_dir(), record_transactions=self.config.get_record_transactions()) self.ipv8.overlays.append(self.market_community) self.ipv8.strategies.append( (RandomWalk(self.market_community), 20)) # Popular Community if self.config.get_popularity_community_enabled(): from tribler_core.modules.popularity.popularity_community import PopularityCommunity self.popularity_community = PopularityCommunity( peer, self.ipv8.endpoint, self.ipv8.network, metadata_store=self.mds, torrent_checker=self.torrent_checker) self.ipv8.overlays.append(self.popularity_community) self.ipv8.strategies.append( (RandomWalk(self.popularity_community), 20)) # Gigachannel Community if self.config.get_chant_enabled(): from tribler_core.modules.metadata_store.community.gigachannel_community import GigaChannelCommunity, GigaChannelTestnetCommunity from tribler_core.modules.metadata_store.community.sync_strategy import SyncChannels community_cls = GigaChannelTestnetCommunity if self.config.get_testnet( ) else GigaChannelCommunity self.gigachannel_community = community_cls(peer, self.ipv8.endpoint, self.ipv8.network, self.mds, notifier=self.notifier) self.ipv8.overlays.append(self.gigachannel_community) self.ipv8.strategies.append( (RandomWalk(self.gigachannel_community), 20)) self.ipv8.strategies.append( (SyncChannels(self.gigachannel_community), 20)) # Gigachannel RemoteQuery Community from tribler_core.modules.metadata_store.community.remote_query_community \ import RemoteQueryCommunity, RemoteQueryTestnetCommunity community_cls = RemoteQueryTestnetCommunity if self.config.get_testnet( ) else RemoteQueryCommunity self.remote_query_community = community_cls(peer, self.ipv8.endpoint, self.ipv8.network, self.mds, notifier=self.notifier) self.ipv8.overlays.append(self.remote_query_community) self.ipv8.strategies.append( (RandomWalk(self.remote_query_community), 50))
def setUp(self): super(TestTrustchainWallet, self).setUp() self.initialize(TrustChainCommunity, 2) self.tc_wallet = TrustchainWallet(self.nodes[0].overlay) self.tc_wallet.MONITOR_DELAY = 0.01 self.tc_wallet.check_negative_balance = True
class TestTrustchainWallet(TestBase): def setUp(self): super(TestTrustchainWallet, self).setUp() self.initialize(TrustChainCommunity, 2) self.tc_wallet = TrustchainWallet(self.nodes[0].overlay) self.tc_wallet.MONITOR_DELAY = 0.01 self.tc_wallet.check_negative_balance = True def create_node(self): return MockIPv8(u"curve25519", TrustChainCommunity, working_directory=u":memory:") def test_get_mc_wallet_name(self): """ Test the identifier of the Trustchain wallet """ self.assertEqual(self.tc_wallet.get_name(), 'Tokens (MB)') def test_get_mc_wallet_id(self): """ Test the identifier of a Trustchain wallet """ self.assertEqual(self.tc_wallet.get_identifier(), 'MB') @trial_timeout(2) @inlineCallbacks def test_get_balance(self): """ Test the balance retrieval of a Trustchain wallet """ yield self.introduce_nodes() balance = yield self.tc_wallet.get_balance() self.assertEqual(balance['available'], 0) his_pubkey = self.nodes[0].network.verified_peers[0].public_key.key_to_bin() tx = { 'up': 20 * 1024 * 1024, 'down': 5 * 1024 * 1024, 'total_up': 20 * 1024 * 1024, 'total_down': 5 * 1024 * 1024 } self.nodes[0].overlay.sign_block(self.nodes[0].network.verified_peers[0], public_key=his_pubkey, block_type=b'tribler_bandwidth', transaction=tx) yield self.deliver_messages() balance = yield self.tc_wallet.get_balance() self.assertEqual(balance['available'], 15) def test_create_wallet(self): """ Test whether creating a Trustchain wallet raises an error """ self.assertRaises(RuntimeError, self.tc_wallet.create_wallet) @inlineCallbacks def test_transfer_invalid(self): """ Test the transfer method of a Trustchain wallet """ test_deferred = Deferred() def on_error(failure): self.assertIsInstance(failure.value, InsufficientFunds) test_deferred.callback(None) self.tc_wallet.transfer(200, None).addErrback(on_error) yield test_deferred @inlineCallbacks def test_monitor_transaction(self): """ Test the monitoring of a transaction in a Trustchain wallet """ his_pubkey = self.nodes[0].overlay.my_peer.public_key.key_to_bin() tx_deferred = self.tc_wallet.monitor_transaction('%s.1' % hexlify(his_pubkey).decode('utf-8')) # Now create the transaction transaction = { 'up': 20 * 1024 * 1024, 'down': 5 * 1024 * 1024, 'total_up': 20 * 1024 * 1024, 'total_down': 5 * 1024 * 1024 } self.nodes[1].overlay.sign_block(self.nodes[1].network.verified_peers[0], public_key=his_pubkey, block_type=b'tribler_bandwidth', transaction=transaction) yield tx_deferred @trial_timeout(2) @inlineCallbacks def test_monitor_tx_existing(self): """ Test monitoring a transaction that already exists """ transaction = { 'up': 20 * 1024 * 1024, 'down': 5 * 1024 * 1024, 'total_up': 20 * 1024 * 1024, 'total_down': 5 * 1024 * 1024 } his_pubkey = self.nodes[0].overlay.my_peer.public_key.key_to_bin() yield self.nodes[1].overlay.sign_block(self.nodes[1].network.verified_peers[0], public_key=his_pubkey, block_type=b'tribler_bandwidth', transaction=transaction) yield self.tc_wallet.monitor_transaction('%s.1' % hexlify(his_pubkey).decode('utf-8')) def test_address(self): """ Test the address of a Trustchain wallet """ self.assertTrue(self.tc_wallet.get_address()) @inlineCallbacks def test_get_transaction(self): """ Test the retrieval of transactions of a Trustchain wallet """ def on_transactions(transactions): self.assertIsInstance(transactions, list) yield self.tc_wallet.get_transactions().addCallback(on_transactions) def test_min_unit(self): """ Test the minimum unit of a Trustchain wallet """ self.assertEqual(self.tc_wallet.min_unit(), 1) @inlineCallbacks def test_get_statistics(self): """ Test fetching statistics from a Trustchain wallet """ self.tc_wallet.check_negative_balance = False res = self.tc_wallet.get_statistics() self.assertEqual(res["total_blocks"], 0) yield self.tc_wallet.transfer(5, self.nodes[1].overlay.my_peer) res = self.tc_wallet.get_statistics() self.assertTrue(res["latest_block"])
class TestTrustchainWallet(TestBase): def setUp(self): super(TestTrustchainWallet, self).setUp() self.initialize(TrustChainCommunity, 2) self.tc_wallet = TrustchainWallet(self.nodes[0].overlay) self.tc_wallet.MONITOR_DELAY = 0.01 self.tc_wallet.check_negative_balance = True async def tearDown(self): await self.tc_wallet.shutdown_task_manager() await super(TestTrustchainWallet, self).tearDown() def create_node(self): return MockIPv8(u"curve25519", TrustChainCommunity, working_directory=u":memory:") def test_get_mc_wallet_name(self): """ Test the identifier of the Trustchain wallet """ self.assertEqual(self.tc_wallet.get_name(), 'Tokens (MB)') def test_get_mc_wallet_id(self): """ Test the identifier of a Trustchain wallet """ self.assertEqual(self.tc_wallet.get_identifier(), 'MB') @timeout(2) async def test_get_balance(self): """ Test the balance retrieval of a Trustchain wallet """ await self.introduce_nodes() balance = await self.tc_wallet.get_balance() self.assertEqual(balance['available'], 0) his_pubkey = list( self.nodes[0].network.verified_peers)[0].public_key.key_to_bin() tx = { b'up': 20 * 1024 * 1024, b'down': 5 * 1024 * 1024, b'total_up': 20 * 1024 * 1024, b'total_down': 5 * 1024 * 1024 } self.nodes[0].overlay.sign_block(list( self.nodes[0].network.verified_peers)[0], public_key=his_pubkey, block_type=b'tribler_bandwidth', transaction=tx) await self.deliver_messages() balance = await self.tc_wallet.get_balance() self.assertEqual(balance['available'], 15) def test_create_wallet(self): """ Test whether creating a Trustchain wallet raises an error """ self.assertRaises(RuntimeError, self.tc_wallet.create_wallet) async def test_transfer_invalid(self): """ Test the transfer method of a Trustchain wallet """ with self.assertRaises(InsufficientFunds): await self.tc_wallet.transfer(200, None) async def test_monitor_transaction(self): """ Test the monitoring of a transaction in a Trustchain wallet """ his_pubkey = self.nodes[0].overlay.my_peer.public_key.key_to_bin() tx_future = self.tc_wallet.monitor_transaction( '%s.1' % hexlify(his_pubkey).decode('utf-8')) # Now create the transaction transaction = { b'up': 20 * 1024 * 1024, b'down': 5 * 1024 * 1024, b'total_up': 20 * 1024 * 1024, b'total_down': 5 * 1024 * 1024 } await self.nodes[1].overlay.sign_block(list( self.nodes[1].network.verified_peers)[0], public_key=his_pubkey, block_type=b'tribler_bandwidth', transaction=transaction) await tx_future @timeout(2) async def test_monitor_tx_existing(self): """ Test monitoring a transaction that already exists """ transaction = { b'up': 20 * 1024 * 1024, b'down': 5 * 1024 * 1024, b'total_up': 20 * 1024 * 1024, b'total_down': 5 * 1024 * 1024 } his_pubkey = self.nodes[0].overlay.my_peer.public_key.key_to_bin() await self.nodes[1].overlay.sign_block(list( self.nodes[1].network.verified_peers)[0], public_key=his_pubkey, block_type=b'tribler_bandwidth', transaction=transaction) await self.tc_wallet.monitor_transaction( '%s.1' % hexlify(his_pubkey).decode('utf-8')) def test_address(self): """ Test the address of a Trustchain wallet """ self.assertTrue(self.tc_wallet.get_address()) async def test_get_transaction(self): """ Test the retrieval of transactions of a Trustchain wallet """ transactions = await self.tc_wallet.get_transactions() self.assertIsInstance(transactions, list) def test_min_unit(self): """ Test the minimum unit of a Trustchain wallet """ self.assertEqual(self.tc_wallet.min_unit(), 1) async def test_get_statistics(self): """ Test fetching statistics from a Trustchain wallet """ self.tc_wallet.check_negative_balance = False res = self.tc_wallet.get_statistics() self.assertEqual(res["total_blocks"], 0) await self.tc_wallet.transfer(5, self.nodes[1].overlay.my_peer) res = self.tc_wallet.get_statistics() self.assertEqual(0, res["total_up"]) self.assertEqual(5 * 1024 * 1024, res["total_down"])