def setUp(self, annotate=True):
yield super(TestMarketConversion, self).setUp(annotate=annotate)
self.market_community = MarketCommunity(self.dispersy,
self.master_member,
self.member)
self.market_community.initialize()
self.conversion = MarketConversion(self.market_community)
def setUp(self, annotate=True):
yield super(CommunityTestSuite, self).setUp(annotate=annotate)
dummy1_wallet = DummyWallet1()
dummy2_wallet = DummyWallet2()
self.market_community = MarketCommunity(self.dispersy,
self.master_member,
self.member)
self.market_community.initialize(wallets={
dummy1_wallet.get_identifier():
dummy1_wallet,
dummy2_wallet.get_identifier():
dummy2_wallet
},
use_database=False)
self.market_community.use_local_address = True
self.dispersy._lan_address = ("127.0.0.1", 1234)
self.dispersy._endpoint.open(self.dispersy)
self.dispersy.attach_community(self.market_community)
eccrypto = ECCrypto()
ec = eccrypto.generate_key(u"curve25519")
member = Member(self.dispersy, ec, 1)
trader_id = hashlib.sha1(member.public_key).digest().encode('hex')
self.ask = Ask(
MessageId(TraderId('0'), MessageNumber('message_number')),
OrderId(TraderId(trader_id), OrderNumber(1234)),
Price(63400, 'DUM1'), Quantity(30, 'DUM2'), Timeout(3600),
Timestamp.now())
self.ask.sign(member)
self.bid = Bid(
MessageId(TraderId('1'), MessageNumber('message_number')),
OrderId(TraderId(trader_id), OrderNumber(1235)),
Price(343, 'DUM1'), Quantity(22, 'DUM2'), Timeout(3600),
Timestamp.now())
self.bid.sign(member)
self.order = Order(
OrderId(TraderId(self.market_community.mid), OrderNumber(24)),
Price(20, 'DUM1'), Quantity(30, 'DUM2'), Timeout(3600.0),
Timestamp.now(), False)
self.proposed_trade = Trade.propose(
MessageId(TraderId('0'), MessageNumber('message_number')),
OrderId(TraderId('0'), OrderNumber(23)),
OrderId(TraderId(self.market_community.mid), OrderNumber(24)),
Price(20, 'DUM1'), Quantity(30, 'DUM2'), Timestamp.now())
def test_get_master_members(self):
"""
Test retrieval of the master members of the Market community
"""
self.assertTrue(MarketCommunity.get_master_members(self.dispersy))
class CommunityTestSuite(AbstractTestCommunity):
"""Community test cases."""
@blocking_call_on_reactor_thread
@inlineCallbacks
def setUp(self, annotate=True):
yield super(CommunityTestSuite, self).setUp(annotate=annotate)
dummy1_wallet = DummyWallet1()
dummy2_wallet = DummyWallet2()
self.market_community = MarketCommunity(self.dispersy,
self.master_member,
self.member)
self.market_community.initialize(wallets={
dummy1_wallet.get_identifier():
dummy1_wallet,
dummy2_wallet.get_identifier():
dummy2_wallet
},
use_database=False)
self.market_community.use_local_address = True
self.dispersy._lan_address = ("127.0.0.1", 1234)
self.dispersy._endpoint.open(self.dispersy)
self.dispersy.attach_community(self.market_community)
eccrypto = ECCrypto()
ec = eccrypto.generate_key(u"curve25519")
member = Member(self.dispersy, ec, 1)
trader_id = hashlib.sha1(member.public_key).digest().encode('hex')
self.ask = Ask(
MessageId(TraderId('0'), MessageNumber('message_number')),
OrderId(TraderId(trader_id), OrderNumber(1234)),
Price(63400, 'DUM1'), Quantity(30, 'DUM2'), Timeout(3600),
Timestamp.now())
self.ask.sign(member)
self.bid = Bid(
MessageId(TraderId('1'), MessageNumber('message_number')),
OrderId(TraderId(trader_id), OrderNumber(1235)),
Price(343, 'DUM1'), Quantity(22, 'DUM2'), Timeout(3600),
Timestamp.now())
self.bid.sign(member)
self.order = Order(
OrderId(TraderId(self.market_community.mid), OrderNumber(24)),
Price(20, 'DUM1'), Quantity(30, 'DUM2'), Timeout(3600.0),
Timestamp.now(), False)
self.proposed_trade = Trade.propose(
MessageId(TraderId('0'), MessageNumber('message_number')),
OrderId(TraderId('0'), OrderNumber(23)),
OrderId(TraderId(self.market_community.mid), OrderNumber(24)),
Price(20, 'DUM1'), Quantity(30, 'DUM2'), Timestamp.now())
@blocking_call_on_reactor_thread
def test_get_master_members(self):
"""
Test retrieval of the master members of the Market community
"""
self.assertTrue(MarketCommunity.get_master_members(self.dispersy))
@blocking_call_on_reactor_thread
def test_proposed_trade_cache_timeout(self):
"""
Test the timeout method of a proposed trade request in the cache
"""
ask = Ask(
MessageId(TraderId('0'), MessageNumber('message_number')),
OrderId(TraderId(self.market_community.mid), OrderNumber(24)),
Price(63400, 'DUM1'), Quantity(30, 'DUM2'), Timeout(3600),
Timestamp.now())
order = Order(OrderId(TraderId("0"), OrderNumber(23)),
Price(20, 'DUM1'), Quantity(30, 'DUM2'), Timeout(3600.0),
Timestamp.now(), False)
self.market_community.order_book.insert_ask(ask)
self.assertEqual(len(self.market_community.order_book.asks), 1)
self.market_community.order_manager.order_repository.add(order)
order.reserve_quantity_for_tick(self.proposed_trade.recipient_order_id,
Quantity(30, 'DUM2'))
self.market_community.order_manager.order_repository.update(order)
cache = ProposedTradeRequestCache(self.market_community,
self.proposed_trade)
cache.on_timeout()
self.assertEqual(len(self.market_community.order_book.asks), 0)
def get_tick_message(self, tick):
meta = self.market_community.get_meta_message(
u"ask" if isinstance(tick, Ask) else u"bid")
return meta.impl(
authentication=(self.market_community.my_member, ),
distribution=(self.market_community.claim_global_time(), ),
payload=tick.to_network() + (Ttl.default(), "127.0.0.1", 1234))
def get_offer_sync(self, tick):
meta = self.market_community.get_meta_message(u"offer-sync")
candidate = Candidate(
self.market_community.lookup_ip(TraderId(
self.market_community.mid)), False)
return meta.impl(
authentication=(self.market_community.my_member, ),
distribution=(self.market_community.claim_global_time(), ),
destination=(candidate, ),
payload=tick.to_network() + (Ttl(1), ) + ("127.0.0.1", 1234) +
(isinstance(tick, Ask), ))
@blocking_call_on_reactor_thread
def test_verify_offer_creation(self):
"""
Test creation of an offer in the community
"""
self.assertRaises(RuntimeError,
self.market_community.verify_offer_creation,
Price(3, 'MC'), 'ABC', Quantity(4, 'BTC'), 'ABC')
self.assertRaises(RuntimeError,
self.market_community.verify_offer_creation,
Price(3, 'MC'), 'ABC', Quantity(4, 'BTC'), 'MC')
self.assertRaises(RuntimeError,
self.market_community.verify_offer_creation,
Price(1, 'DUM1'), 'DUM1', Quantity(1, 'BTC'), 'BTC')
self.assertRaises(RuntimeError,
self.market_community.verify_offer_creation,
Price(0.1, 'DUM1'), 'DUM1', Quantity(1,
'DUM2'), 'DUM2')
self.assertRaises(RuntimeError,
self.market_community.verify_offer_creation,
Price(1, 'DUM1'), 'DUM1', Quantity(0.1,
'DUM2'), 'DUM2')
@blocking_call_on_reactor_thread
def test_check_message(self):
"""
Test the general check of the validity of a message in the market community
"""
self.market_community.update_ip(TraderId(self.market_community.mid),
('2.2.2.2', 2))
proposed_trade_msg = self.get_proposed_trade_msg()
self.market_community.timeline.check = lambda _: (True, None)
[
self.assertIsInstance(msg, Message.Implementation) for msg in
self.market_community.check_message([proposed_trade_msg])
]
self.market_community.timeline.check = lambda _: (False, None)
[
self.assertIsInstance(msg, DelayMessageByProof) for msg in
self.market_community.check_message([proposed_trade_msg])
]
@blocking_call_on_reactor_thread
def test_check_tick_message(self):
"""
Test the general check of the validity of a tick message in the market community
"""
self.ask._signature = EMPTY_SIG
[
self.assertIsInstance(msg, DropMessage)
for msg in self.market_community.check_tick_message(
[self.get_tick_message(self.ask)])
]
self.market_community.timeline.check = lambda _: (False, None)
[
self.assertIsInstance(msg, DelayMessageByProof)
for msg in self.market_community.check_tick_message(
[self.get_tick_message(self.ask)])
]
self.market_community.timeline.check = lambda _: (True, None)
self.ask.order_id._trader_id = TraderId(self.market_community.mid)
[
self.assertIsInstance(msg, DropMessage)
for msg in self.market_community.check_tick_message(
[self.get_tick_message(self.ask)])
]
@blocking_call_on_reactor_thread
def test_check_trade_message(self):
"""
Test the general check of the validity of a trade message in the market community
"""
self.proposed_trade.recipient_order_id._trader_id = TraderId("abcdef")
self.market_community.update_ip(TraderId(self.market_community.mid),
('2.2.2.2', 2))
self.market_community.update_ip(TraderId("abcdef"), ('2.2.2.2', 2))
self.market_community.timeline.check = lambda _: (False, None)
[
self.assertIsInstance(msg, DelayMessageByProof)
for msg in self.market_community.check_trade_message(
[self.get_proposed_trade_msg()])
]
self.market_community.timeline.check = lambda _: (True, None)
[
self.assertIsInstance(msg, DropMessage)
for msg in self.market_community.check_trade_message(
[self.get_proposed_trade_msg()])
]
self.proposed_trade.recipient_order_id._trader_id = TraderId(
self.market_community.mid)
self.market_community.timeline.check = lambda _: (True, None)
[
self.assertIsInstance(msg, DropMessage)
for msg in self.market_community.check_trade_message(
[self.get_proposed_trade_msg()])
]
self.market_community.order_manager.order_repository.add(self.order)
self.market_community.timeline.check = lambda _: (True, None)
[
self.assertIsInstance(msg, Message.Implementation)
for msg in self.market_community.check_trade_message(
[self.get_proposed_trade_msg()])
]
@blocking_call_on_reactor_thread
def test_send_offer_sync(self):
"""
Test sending an offer sync
"""
self.market_community.update_ip(TraderId('0'), ("127.0.0.1", 1234))
self.market_community.update_ip(TraderId('1'), ("127.0.0.1", 1234))
self.market_community.update_ip(self.ask.order_id.trader_id,
("127.0.0.1", 1234))
candidate = WalkCandidate(("127.0.0.1", 1234), False,
("127.0.0.1", 1234), ("127.0.0.1", 1234),
u"public")
self.assertTrue(
self.market_community.send_offer_sync(candidate, self.ask))
@blocking_call_on_reactor_thread
def test_send_proposed_trade(self):
"""
Test sending a proposed trade
"""
self.market_community.update_ip(TraderId(self.market_community.mid),
('127.0.0.1', 1234))
self.assertEqual(
self.market_community.send_proposed_trade_messages(
[self.proposed_trade]), [True])
@blocking_call_on_reactor_thread
def test_send_counter_trade(self):
"""
Test sending a counter trade
"""
self.market_community.update_ip(TraderId('b'), ('127.0.0.1', 1234))
counter_trade = CounterTrade(
MessageId(TraderId('a'), MessageNumber('2')), self.order.order_id,
OrderId(TraderId('b'), OrderNumber(3)), 1235, Price(3, 'MC'),
Quantity(4, 'BTC'), Timestamp.now())
self.market_community.send_counter_trade(counter_trade)
@blocking_call_on_reactor_thread
def test_start_transaction(self):
"""
Test the start transaction method
"""
self.market_community.order_manager.order_repository.add(self.order)
self.market_community.update_ip(TraderId('0'), ("127.0.0.1", 1234))
self.market_community.start_transaction(self.proposed_trade)
self.assertEqual(
len(self.market_community.transaction_manager.find_all()), 1)
@blocking_call_on_reactor_thread
def test_create_intro_request(self):
"""
Test the creation of an introduction request
"""
self.market_community.order_book.insert_ask(self.ask)
self.market_community.order_book.insert_bid(self.bid)
candidate = WalkCandidate(("127.0.0.1", 1234), False,
("127.0.0.1", 1234), ("127.0.0.1", 1234),
u"public")
request = self.market_community.create_introduction_request(
candidate, True)
self.assertTrue(request)
self.assertTrue(request.payload.orders_bloom_filter)
@blocking_call_on_reactor_thread
def test_on_introduction_request(self):
"""
Test that when we receive an intro request with a orders bloom filter, we send an order sync back
"""
def on_send_offer_sync(_, tick):
self.assertIsInstance(tick, Tick)
on_send_offer_sync.called = True
on_send_offer_sync.called = False
candidate = WalkCandidate(("127.0.0.1", 1234), False,
("127.0.0.1", 1234), ("127.0.0.1", 1234),
u"public")
candidate.associate(self.market_community.my_member)
payload = self.market_community.create_introduction_request(
candidate, True).payload
self.market_community.order_book.insert_ask(self.ask)
self.market_community.order_book.insert_bid(self.bid)
self.market_community.update_ip(TraderId('0'), ("127.0.0.1", 1234))
self.market_community.update_ip(TraderId('1'), ("127.0.0.1", 1234))
self.market_community.send_offer_sync = on_send_offer_sync
message = MockObject()
message.payload = payload
message.candidate = candidate
self.market_community.on_introduction_request([message])
self.assertTrue(on_send_offer_sync.called)
@blocking_call_on_reactor_thread
def test_lookup_ip(self):
# Test for lookup ip
self.market_community.update_ip(TraderId('0'), ("1.1.1.1", 0))
self.assertEquals(("1.1.1.1", 0),
self.market_community.lookup_ip(TraderId('0')))
@blocking_call_on_reactor_thread
def test_get_wallet_address(self):
"""
Test the retrieval of a wallet address
"""
self.assertRaises(ValueError, self.market_community.get_wallet_address,
'ABCD')
self.assertTrue(self.market_community.get_wallet_address('DUM1'))
@blocking_call_on_reactor_thread
def test_create_ask(self):
# Test for create ask
self.assertRaises(RuntimeError, self.market_community.create_ask, 20,
'DUM2', 100, 'DUM2', 0.0)
self.assertRaises(RuntimeError, self.market_community.create_ask, 20,
'NOTEXIST', 100, 'DUM2', 0.0)
self.assertRaises(RuntimeError, self.market_community.create_ask, 20,
'DUM2', 100, 'NOTEXIST', 0.0)
self.assertTrue(
self.market_community.create_ask(20, 'DUM1', 100, 'DUM2', 3600))
self.assertEquals(1, len(self.market_community.order_book._asks))
self.assertEquals(0, len(self.market_community.order_book._bids))
@blocking_call_on_reactor_thread
def test_on_tick(self):
"""
Test whether a tick is inserted in the order book when we receive one
"""
self.market_community.on_tick(
[self.get_tick_message(self.ask),
self.get_tick_message(self.bid)])
self.assertEquals(1, len(self.market_community.order_book.asks))
self.assertEquals(1, len(self.market_community.order_book.bids))
# Update the timestamp of the ticks
ask_timestamp = float(self.ask.timestamp)
self.ask.update_timestamp()
self.market_community.on_tick([self.get_tick_message(self.ask)])
self.assertEquals(1, len(self.market_community.order_book.asks))
new_timestamp = self.market_community.order_book.get_tick(
self.ask.order_id).tick.timestamp
self.assertGreater(new_timestamp, ask_timestamp)
@blocking_call_on_reactor_thread
def test_create_bid(self):
# Test for create bid
self.assertRaises(RuntimeError, self.market_community.create_bid, 20,
'DUM2', 100, 'DUM2', 0.0)
self.assertRaises(RuntimeError, self.market_community.create_bid, 20,
'NOTEXIST', 100, 'DUM2', 0.0)
self.assertRaises(RuntimeError, self.market_community.create_bid, 20,
'DUM2', 100, 'NOTEXIST', 0.0)
self.assertTrue(
self.market_community.create_bid(20, 'DUM1', 100, 'DUM2', 3600))
self.assertEquals(0, len(self.market_community.order_book.asks))
self.assertEquals(1, len(self.market_community.order_book.bids))
def get_proposed_trade_msg(self):
destination, payload = self.proposed_trade.to_network()
payload += ("127.0.0.1", 1234)
candidate = Candidate(self.market_community.lookup_ip(destination),
False)
meta = self.market_community.get_meta_message(u"proposed-trade")
message = meta.impl(
authentication=(self.market_community.my_member, ),
distribution=(self.market_community.claim_global_time(), ),
destination=(candidate, ),
payload=payload)
return message
@blocking_call_on_reactor_thread
def test_on_proposed_trade_accept(self):
"""
Test whether we accept a trade when we receive a correct proposed trade message
"""
def mocked_start_transaction(*_):
mocked_start_transaction.called = True
mocked_start_transaction.called = False
self.market_community.update_ip(TraderId(self.market_community.mid),
('2.2.2.2', 2))
self.market_community.start_transaction = mocked_start_transaction
self.market_community.order_manager.order_repository.add(self.order)
self.market_community.on_proposed_trade(
[self.get_proposed_trade_msg()])
self.assertTrue(mocked_start_transaction.called)
@blocking_call_on_reactor_thread
def test_on_proposed_trade_decline(self):
"""
Test whether we decline a trade when we receive an invalid proposed trade message
"""
def mocked_send_decline_trade(*_):
mocked_send_decline_trade.called = True
mocked_send_decline_trade.called = False
self.market_community.update_ip(TraderId(self.market_community.mid),
('2.2.2.2', 2))
self.market_community.send_declined_trade = mocked_send_decline_trade
self.market_community.order_manager.order_repository.add(self.order)
self.proposed_trade._price = Price(900, 'DUM1')
self.market_community.on_proposed_trade(
[self.get_proposed_trade_msg()])
self.assertTrue(mocked_send_decline_trade.called)
@blocking_call_on_reactor_thread
def test_on_proposed_trade_counter(self):
"""
Test whether we send a counter trade when we receive a proposed trade message
"""
def mocked_send_counter_trade(*_):
mocked_send_counter_trade.called = True
mocked_send_counter_trade.called = False
self.market_community.update_ip(TraderId(self.market_community.mid),
('2.2.2.2', 2))
self.market_community.send_counter_trade = mocked_send_counter_trade
self.market_community.order_manager.order_repository.add(self.order)
self.proposed_trade._quantity = Quantity(100000, 'DUM2')
self.market_community.on_proposed_trade(
[self.get_proposed_trade_msg()])
self.assertTrue(mocked_send_counter_trade.called)
@blocking_call_on_reactor_thread
def test_on_offer_sync(self):
"""
Test whether the right operations happen when we receive an offer sync
"""
self.assertEqual(len(self.market_community.order_book.asks), 0)
self.assertEqual(len(self.market_community.order_book.bids), 0)
self.market_community.update_ip(TraderId(self.market_community.mid),
('2.2.2.2', 2))
self.market_community.on_offer_sync([self.get_offer_sync(self.ask)])
self.assertEqual(len(self.market_community.order_book.asks), 1)
self.market_community.order_book.remove_tick(self.ask.order_id)
self.market_community.on_offer_sync([self.get_offer_sync(self.bid)])
self.assertEqual(len(self.market_community.order_book.bids), 1)
@blocking_call_on_reactor_thread
def test_compute_reputation(self):
"""
Test the compute_reputation method
"""
self.market_community.tradechain_community = MockObject()
self.market_community.tradechain_community.persistence = MockObject()
self.market_community.tradechain_community.persistence.get_all_blocks = lambda: [
]
self.market_community.compute_reputation()
self.assertFalse(self.market_community.reputation_dict)
@blocking_call_on_reactor_thread
def test_abort_transaction(self):
"""
Test aborting a transaction
"""
self.order.reserve_quantity_for_tick(
OrderId(TraderId('0'), OrderNumber(23)), Quantity(30, 'DUM2'))
self.market_community.order_manager.order_repository.add(self.order)
self.market_community.update_ip(TraderId('0'), ("127.0.0.1", 1234))
self.market_community.start_transaction(self.proposed_trade)
transaction = self.market_community.transaction_manager.find_all()[0]
self.assertTrue(transaction)
self.assertEqual(self.order.reserved_quantity, Quantity(30, 'DUM2'))
self.market_community.abort_transaction(transaction)
order = self.market_community.order_manager.order_repository.find_by_id(
transaction.order_id)
self.assertEqual(order.reserved_quantity, Quantity(0, 'DUM2'))
def load_ipv8_overlays(self):
# Discovery Community
with open(self.session.config.get_permid_keypair_filename(),
'r') as key_file:
content = key_file.read()
content = content[31:-30].replace('\n', '').decode("BASE64")
peer = Peer(M2CryptoSK(keystring=content))
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))
if not self.session.config.get_dispersy_enabled():
self.ipv8.strategies.append((RandomWalk(discovery_community), 20))
# TriblerChain Community
if self.session.config.get_trustchain_enabled():
triblerchain_peer = Peer(self.session.trustchain_keypair)
from Tribler.community.triblerchain.community import TriblerChainCommunity
self.triblerchain_community = TriblerChainCommunity(
triblerchain_peer,
self.ipv8.endpoint,
self.ipv8.network,
tribler_session=self.session,
working_directory=self.session.config.get_state_dir())
self.ipv8.overlays.append(self.triblerchain_community)
self.ipv8.strategies.append(
(EdgeWalk(self.triblerchain_community), 20))
# Tunnel Community
if self.session.config.get_tunnel_community_enabled():
tunnel_peer = Peer(self.session.trustchain_keypair)
from Tribler.community.triblertunnel.community import TriblerTunnelCommunity
self.tunnel_community = TriblerTunnelCommunity(
tunnel_peer,
self.ipv8.endpoint,
self.ipv8.network,
tribler_session=self.session,
dht_provider=MainlineDHTProvider(
self.mainline_dht,
self.session.config.get_dispersy_port()),
triblerchain_community=self.triblerchain_community)
self.ipv8.overlays.append(self.tunnel_community)
self.ipv8.strategies.append(
(RandomWalk(self.tunnel_community), 20))
# Market Community
if self.session.config.get_market_community_enabled():
wallets = {}
try:
from Tribler.community.market.wallet.btc_wallet import BitcoinWallet, BitcoinTestnetWallet
wallet_type = BitcoinTestnetWallet if self.session.config.get_btc_testnet(
) else BitcoinWallet
btc_wallet = wallet_type(
os.path.join(self.session.config.get_state_dir(),
'wallet'))
wallets[btc_wallet.get_identifier()] = btc_wallet
except ImportError:
self._logger.error(
"Electrum wallet cannot be found, Bitcoin trading not available!"
)
mc_wallet = TrustchainWallet(self.triblerchain_community)
wallets[mc_wallet.get_identifier()] = mc_wallet
if self.session.config.get_dummy_wallets_enabled():
# For debugging purposes, we create dummy wallets
dummy_wallet1 = DummyWallet1()
wallets[dummy_wallet1.get_identifier()] = dummy_wallet1
dummy_wallet2 = DummyWallet2()
wallets[dummy_wallet2.get_identifier()] = dummy_wallet2
from Tribler.community.market.community import MarketCommunity
market_peer = Peer(self.session.tradechain_keypair)
self.market_community = MarketCommunity(
market_peer,
self.ipv8.endpoint,
self.ipv8.network,
tribler_session=self.session,
wallets=wallets,
working_directory=self.session.config.get_state_dir())
self.ipv8.overlays.append(self.market_community)
self.ipv8.strategies.append(
(RandomWalk(self.market_community), 20))
class TestMarketConversion(AbstractTestCommunity):
@blocking_call_on_reactor_thread
@inlineCallbacks
def setUp(self, annotate=True):
yield super(TestMarketConversion, self).setUp(annotate=annotate)
self.market_community = MarketCommunity(self.dispersy, self.master_member, self.member)
self.market_community.initialize()
self.conversion = MarketConversion(self.market_community)
@blocking_call_on_reactor_thread
@inlineCallbacks
def tearDown(self, annotate=True):
# Don't unload_community() as it never got registered in dispersy on the first place.
self.market_community.cancel_all_pending_tasks()
self.market_community = None
yield super(TestMarketConversion, self).tearDown(annotate=annotate)
def get_placeholder_msg(self, meta_name):
"""
Return a placeholder message with a specific meta name
"""
meta_msg = self.market_community.get_meta_message(meta_name)
msg = MockObject()
msg.meta = meta_msg
return msg
def test_decode_payload(self):
"""
Test decoding of a payload
"""
message = MockObject()
meta_msg = self.market_community.get_meta_message(u"ask")
offer_payload = OfferPayload.Implementation(meta_msg, TraderId('abc'), MessageNumber('3'), OrderNumber(4),
Price(5, 'BTC'), Quantity(6, 'MC'), Timeout(3600), Timestamp.now(),
'a', 'b', Ttl(3), "1.2.3.4", 1234)
message.payload = offer_payload
packet = encode((3.14, 100))
placeholder = self.get_placeholder_msg(u"ask")
self.assertRaises(DropPacket, self.conversion._decode_payload, placeholder, 0, packet, [Price])
self.assertRaises(DropPacket, self.conversion._decode_payload, placeholder, 0, "a2zz", [Price])
def test_encode_decode_intro_request(self):
"""
Test encoding and decoding of an introduction request
"""
message = MockObject()
meta_msg = self.market_community.get_meta_message(u"dispersy-introduction-request")
bloomfilter = BloomFilter(0.005, 30, prefix=' ')
intro_payload = MarketIntroPayload.Implementation(meta_msg, ("127.0.0.1", 1324), ("127.0.0.1", 1234),
("127.0.0.1", 1234), True, u"public", None, 3, bloomfilter)
message.payload = intro_payload
packet_str = ''.join(self.conversion._encode_introduction_request(message))
self.assertTrue(packet_str)
placeholder = self.get_placeholder_msg(u"dispersy-introduction-request")
_, decoded = self.conversion._decode_introduction_request(placeholder, 0, packet_str)
self.assertTrue(decoded)
self.assertRaises(DropPacket, self.conversion._decode_introduction_request, placeholder, 0, 'abc')
self.assertRaises(DropPacket, self.conversion._decode_introduction_request, placeholder, 0, packet_str + 'b')
# Add a malformed bloomfilter
intro_payload = MarketIntroPayload.Implementation(meta_msg, ("127.0.0.1", 1324), ("127.0.0.1", 1234),
("127.0.0.1", 1234), True, u"public", None, 3, None)
message.payload = intro_payload
packet_str = ''.join(self.conversion._encode_introduction_request(message))
self.assertRaises(DropPacket, self.conversion._decode_introduction_request, placeholder, 0, packet_str + 'a')
bf_encoding = pack("!BH", 3, 0) + 'aa'
self.assertRaises(DropPacket, self.conversion._decode_introduction_request, placeholder, 0,
packet_str + bf_encoding)
def test_encode_decode_offer(self):
"""
Test encoding and decoding of an offer
"""
message = MockObject()
meta_msg = self.market_community.get_meta_message(u"ask")
offer_payload = OfferPayload.Implementation(meta_msg, TraderId('abc'), MessageNumber('3'), OrderNumber(4),
Price(5, 'BTC'), Quantity(6, 'MC'), Timeout(3600), Timestamp.now(),
'a', 'b', Ttl(3), "1.2.3.4", 1234)
message.payload = offer_payload
packet, = self.conversion._encode_offer(message)
self.assertTrue(packet)
_, decoded = self.conversion._decode_offer(self.get_placeholder_msg(u"ask"), 0, packet)
self.assertTrue(decoded)
self.assertEqual(decoded.price, Price(5, 'BTC'))
self.assertEqual(int(decoded.ttl), 3)
def test_encode_decode_cancel_order(self):
"""
Test encoding and decoding of a cancel order
"""
message = MockObject()
meta_msg = self.market_community.get_meta_message(u"cancel-order")
cancel_order_payload = CancelOrderPayload.Implementation(meta_msg, TraderId('abc'), MessageNumber('3'),
Timestamp.now(), OrderNumber(4), Ttl(2))
message.payload = cancel_order_payload
packet, = self.conversion._encode_cancel_order(message)
self.assertTrue(packet)
_, decoded = self.conversion._decode_cancel_order(self.get_placeholder_msg(u"cancel-order"), 0, packet)
self.assertTrue(decoded)
self.assertEqual(decoded.order_number, OrderNumber(4))
self.assertEqual(int(decoded.ttl), 2)
def test_encode_decode_offer_sync(self):
"""
Test encoding and decoding of an offer sync
"""
message = MockObject()
meta_msg = self.market_community.get_meta_message(u"offer-sync")
offer_payload = OfferSyncPayload.Implementation(meta_msg, TraderId('abc'), MessageNumber('3'), OrderNumber(4),
Price(5, 'BTC'), Quantity(6, 'MC'), Timeout(3600),
Timestamp.now(), 'a', 'b', Ttl(3), "1.2.3.4", 1234, True)
message.payload = offer_payload
packet, = self.conversion._encode_offer_sync(message)
self.assertTrue(packet)
_, decoded = self.conversion._decode_offer_sync(self.get_placeholder_msg(u"offer-sync"), 0, packet)
self.assertTrue(decoded)
self.assertEqual(decoded.price, Price(5, 'BTC'))
self.assertEqual(int(decoded.ttl), 3)
self.assertTrue(decoded.is_ask)
def test_encode_decode_declined_trade(self):
"""
Test encoding and decoding of an declined trade
"""
message = MockObject()
meta_msg = self.market_community.get_meta_message(u"declined-trade")
trade_payload = DeclinedTradePayload.Implementation(meta_msg, TraderId('abc'), MessageNumber('3'),
OrderNumber(4), TraderId('def'), OrderNumber(5), 1234,
Timestamp.now())
message.payload = trade_payload
packet, = self.conversion._encode_declined_trade(message)
self.assertTrue(packet)
_, decoded = self.conversion._decode_declined_trade(self.get_placeholder_msg(u"declined-trade"), 0, packet)
self.assertTrue(decoded)
self.assertEqual(decoded.trader_id, TraderId('abc'))
self.assertEqual(decoded.recipient_trader_id, TraderId('def'))
def test_encode_decode_start_transaction(self):
"""
Test encoding and decoding of a start transaction message
"""
message = MockObject()
meta_msg = self.market_community.get_meta_message(u"start-transaction")
transaction_payload = StartTransactionPayload.Implementation(meta_msg, TraderId('abc'), MessageNumber('3'),
TraderId('def'), TransactionNumber(5),
TraderId('def'), OrderNumber(3), TraderId('abc'),
OrderNumber(4), 1235, Price(5, 'BTC'),
Quantity(4, 'MC'), Timestamp.now())
message.payload = transaction_payload
packet, = self.conversion._encode_start_transaction(message)
self.assertTrue(packet)
_, decoded = self.conversion._decode_start_transaction(
self.get_placeholder_msg(u"start-transaction"), 0, packet)
self.assertTrue(decoded)
self.assertEqual(decoded.trader_id, TraderId('abc'))
self.assertEqual(decoded.transaction_trader_id, TraderId('def'))
def test_encode_decode_transaction(self):
"""
Test encoding and decoding of a transaction message
"""
message = MockObject()
meta_msg = self.market_community.get_meta_message(u"end-transaction")
transaction_payload = TransactionPayload.Implementation(meta_msg, TraderId('abc'), MessageNumber('3'),
TraderId('def'), TransactionNumber(5), Timestamp.now())
message.payload = transaction_payload
packet, = self.conversion._encode_transaction(message)
self.assertTrue(packet)
_, decoded = self.conversion._decode_transaction(self.get_placeholder_msg(u"end-transaction"), 0, packet)
self.assertTrue(decoded)
self.assertEqual(decoded.trader_id, TraderId('abc'))
self.assertEqual(decoded.transaction_trader_id, TraderId('def'))
def test_encode_decode_wallet_info(self):
"""
Test encoding and decoding of wallet info
"""
message = MockObject()
meta_msg = self.market_community.get_meta_message(u"wallet-info")
wallet_payload = WalletInfoPayload.Implementation(meta_msg, TraderId('abc'), MessageNumber('3'),
TraderId('def'), TransactionNumber(5), WalletAddress('a'),
WalletAddress('b'), Timestamp.now())
message.payload = wallet_payload
packet, = self.conversion._encode_wallet_info(message)
self.assertTrue(packet)
_, decoded = self.conversion._decode_wallet_info(self.get_placeholder_msg(u"wallet-info"), 0, packet)
self.assertTrue(decoded)
self.assertEqual(decoded.trader_id, TraderId('abc'))
self.assertEqual(decoded.transaction_trader_id, TraderId('def'))
def test_encode_decode_payment(self):
"""
Test encoding and decoding of a payment
"""
message = MockObject()
meta_msg = self.market_community.get_meta_message(u"payment")
payment_payload = PaymentPayload.Implementation(meta_msg, TraderId('abc'), MessageNumber('3'),
TraderId('def'), TransactionNumber(5), Quantity(5, 'MC'),
Price(6, 'BTC'), WalletAddress('a'),
WalletAddress('b'), PaymentId('abc'), Timestamp.now(), False)
message.payload = payment_payload
packet, = self.conversion._encode_payment(message)
self.assertTrue(packet)
_, decoded = self.conversion._decode_payment(self.get_placeholder_msg(u"payment"), 0, packet)
self.assertTrue(decoded)
self.assertEqual(decoded.trader_id, TraderId('abc'))
self.assertEqual(decoded.transaction_trader_id, TraderId('def'))
self.assertEqual(decoded.payment_id, PaymentId('abc'))
self.assertEqual(decoded.success, False)
def load_ipv8_overlays(self):
# Discovery Community
with open(self.session.config.get_permid_keypair_filename(),
'r') as key_file:
content = key_file.read()
content = content[31:-30].replace('\n', '').decode("BASE64")
peer = Peer(M2CryptoSK(keystring=content))
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))
if not self.session.config.get_dispersy_enabled():
self.ipv8.strategies.append((RandomWalk(discovery_community), 20))
# TrustChain Community
if self.session.config.get_trustchain_enabled():
from Tribler.pyipv8.ipv8.attestation.trustchain.community import TrustChainCommunity
trustchain_peer = Peer(self.session.trustchain_keypair)
self.trustchain_community = TrustChainCommunity(
trustchain_peer,
self.ipv8.endpoint,
self.ipv8.network,
working_directory=self.session.config.get_state_dir(),
testnet=self.session.config.get_trustchain_testnet())
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
# Tunnel Community
if self.session.config.get_tunnel_community_enabled():
tunnel_peer = Peer(self.session.trustchain_keypair)
from Tribler.community.triblertunnel.community import TriblerTunnelCommunity
self.tunnel_community = TriblerTunnelCommunity(
tunnel_peer,
self.ipv8.endpoint,
self.ipv8.network,
tribler_session=self.session,
dht_provider=MainlineDHTProvider(
self.mainline_dht,
self.session.config.get_dispersy_port()),
bandwidth_wallet=self.wallets["MB"])
self.ipv8.overlays.append(self.tunnel_community)
self.ipv8.strategies.append(
(RandomWalk(self.tunnel_community), 20))
# Market Community
if self.session.config.get_market_community_enabled():
from Tribler.community.market.community import MarketCommunity
market_peer = Peer(self.session.trustchain_keypair)
self.market_community = MarketCommunity(
market_peer,
self.ipv8.endpoint,
self.ipv8.network,
tribler_session=self.session,
trustchain=self.trustchain_community,
wallets=self.wallets,
working_directory=self.session.config.get_state_dir())
self.ipv8.overlays.append(self.market_community)
self.ipv8.strategies.append(
(RandomWalk(self.market_community), 20))
# Popular Community
if self.session.config.get_popularity_community_enabled():
from Tribler.community.popularity.community import PopularityCommunity
local_peer = Peer(self.session.trustchain_keypair)
self.popularity_community = PopularityCommunity(
local_peer,
self.ipv8.endpoint,
self.ipv8.network,
torrent_db=self.session.lm.torrent_db,
session=self.session)
self.ipv8.overlays.append(self.popularity_community)
self.ipv8.strategies.append(
(RandomWalk(self.popularity_community), 20))
self.popularity_community.start()
class TestMarketConversion(AbstractTestCommunity):
@blocking_call_on_reactor_thread
@inlineCallbacks
def setUp(self, annotate=True):
yield super(TestMarketConversion, self).setUp(annotate=annotate)
self.market_community = MarketCommunity(self.dispersy,
self.master_member,
self.member)
self.market_community.initialize()
self.conversion = MarketConversion(self.market_community)
@blocking_call_on_reactor_thread
@inlineCallbacks
def tearDown(self, annotate=True):
# Don't unload_community() as it never got registered in dispersy on the first place.
self.market_community.cancel_all_pending_tasks()
self.market_community = None
yield super(TestMarketConversion, self).tearDown(annotate=annotate)
def get_placeholder_msg(self, meta_name):
"""
Return a placeholder message with a specific meta name
"""
meta_msg = self.market_community.get_meta_message(meta_name)
msg = MockObject()
msg.meta = meta_msg
return msg
def test_decode_payload(self):
"""
Test decoding of a payload
"""
message = MockObject()
meta_msg = self.market_community.get_meta_message(
u"order-status-request")
offer_payload = OrderStatusRequestPayload.Implementation(
meta_msg, TraderId('abc'), MessageNumber('3'), Timestamp(1000),
TraderId('def'), OrderNumber(4), 5)
message.payload = offer_payload
packet = encode((3.14, 100))
placeholder = self.get_placeholder_msg(u"order-status-request")
self.assertRaises(DropPacket, self.conversion._decode_payload,
placeholder, 0, packet, [Price])
self.assertRaises(DropPacket, self.conversion._decode_payload,
placeholder, 0, "a2zz", [Price])
def test_encode_match(self):
"""
Test encoding and decoding of a match message
"""
message = MockObject()
meta_msg = self.market_community.get_meta_message(u"match")
match_payload = MatchPayload.Implementation(meta_msg, TraderId('abc'),
MessageNumber('3'),
OrderNumber(4),
Price(1, 'BTC'),
Quantity(2, 'MC'),
Timeout(3600),
Timestamp.now(),
'192.168.1.1', 1234,
OrderNumber(3),
Quantity(2, 'MC'),
TraderId('abc'),
TraderId('def'),
'match_id')
message.payload = match_payload
packet, = self.conversion._encode_match(message)
self.assertTrue(packet)
_, decoded = self.conversion._decode_match(
self.get_placeholder_msg(u"match"), 0, packet)
self.assertTrue(decoded)
self.assertEqual(decoded.match_id, 'match_id')
def test_encode_accept_match(self):
"""
Test encoding and decoding of an accept-match message
"""
message = MockObject()
meta_msg = self.market_community.get_meta_message(u"accept-match")
match_payload = AcceptMatchPayload.Implementation(
meta_msg, TraderId('abc'), MessageNumber('3'), Timestamp.now(),
'match_id', Quantity(2, 'MC'))
message.payload = match_payload
packet, = self.conversion._encode_accept_match(message)
self.assertTrue(packet)
_, decoded = self.conversion._decode_accept_match(
self.get_placeholder_msg(u"accept-match"), 0, packet)
self.assertTrue(decoded)
self.assertEqual(decoded.match_id, 'match_id')
def test_encode_decline_match(self):
"""
Test encoding and decoding of a decline-match message
"""
message = MockObject()
meta_msg = self.market_community.get_meta_message(u"decline-match")
match_payload = DeclineMatchPayload.Implementation(
meta_msg, TraderId('abc'), MessageNumber('3'), Timestamp.now(),
'match_id', DeclinedTradeReason.ORDER_COMPLETED)
message.payload = match_payload
packet, = self.conversion._encode_decline_match(message)
self.assertTrue(packet)
_, decoded = self.conversion._decode_decline_match(
self.get_placeholder_msg(u"decline-match"), 0, packet)
self.assertTrue(decoded)
self.assertEqual(decoded.match_id, 'match_id')
self.assertEqual(decoded.decline_reason,
DeclinedTradeReason.ORDER_COMPLETED)
def test_encode_decode_declined_trade(self):
"""
Test encoding and decoding of an declined trade
"""
message = MockObject()
meta_msg = self.market_community.get_meta_message(u"declined-trade")
trade_payload = DeclinedTradePayload.Implementation(
meta_msg, TraderId('abc'), MessageNumber('3'), OrderNumber(4),
TraderId('def'), OrderNumber(5), 1234, Timestamp.now(),
DeclinedTradeReason.ORDER_COMPLETED)
message.payload = trade_payload
packet, = self.conversion._encode_declined_trade(message)
self.assertTrue(packet)
_, decoded = self.conversion._decode_declined_trade(
self.get_placeholder_msg(u"declined-trade"), 0, packet)
self.assertTrue(decoded)
self.assertEqual(decoded.trader_id, TraderId('abc'))
self.assertEqual(decoded.recipient_trader_id, TraderId('def'))
def test_encode_decode_start_transaction(self):
"""
Test encoding and decoding of a start transaction message
"""
message = MockObject()
meta_msg = self.market_community.get_meta_message(u"start-transaction")
transaction_payload = StartTransactionPayload.Implementation(
meta_msg, TraderId('abc'), MessageNumber('3'), TraderId('def'),
TransactionNumber(5), TraderId('def'), OrderNumber(3),
TraderId('abc'), OrderNumber(4), 1235, Price(5, 'BTC'),
Quantity(4, 'MC'), Timestamp.now())
message.payload = transaction_payload
packet, = self.conversion._encode_start_transaction(message)
self.assertTrue(packet)
_, decoded = self.conversion._decode_start_transaction(
self.get_placeholder_msg(u"start-transaction"), 0, packet)
self.assertTrue(decoded)
self.assertEqual(decoded.trader_id, TraderId('abc'))
self.assertEqual(decoded.transaction_trader_id, TraderId('def'))
def test_encode_decode_wallet_info(self):
"""
Test encoding and decoding of wallet info
"""
message = MockObject()
meta_msg = self.market_community.get_meta_message(u"wallet-info")
wallet_payload = WalletInfoPayload.Implementation(
meta_msg, TraderId('abc'), MessageNumber('3'), TraderId('def'),
TransactionNumber(5), WalletAddress('a'), WalletAddress('b'),
Timestamp.now())
message.payload = wallet_payload
packet, = self.conversion._encode_wallet_info(message)
self.assertTrue(packet)
_, decoded = self.conversion._decode_wallet_info(
self.get_placeholder_msg(u"wallet-info"), 0, packet)
self.assertTrue(decoded)
self.assertEqual(decoded.trader_id, TraderId('abc'))
self.assertEqual(decoded.transaction_trader_id, TraderId('def'))
def test_encode_decode_payment(self):
"""
Test encoding and decoding of a payment
"""
message = MockObject()
meta_msg = self.market_community.get_meta_message(u"payment")
payment_payload = PaymentPayload.Implementation(
meta_msg, TraderId('abc'), MessageNumber('3'), TraderId('def'),
TransactionNumber(5), Quantity(5, 'MC'), Price(6, 'BTC'),
WalletAddress('a'), WalletAddress('b'), PaymentId('abc'),
Timestamp.now(), False)
message.payload = payment_payload
packet, = self.conversion._encode_payment(message)
self.assertTrue(packet)
_, decoded = self.conversion._decode_payment(
self.get_placeholder_msg(u"payment"), 0, packet)
self.assertTrue(decoded)
self.assertEqual(decoded.trader_id, TraderId('abc'))
self.assertEqual(decoded.transaction_trader_id, TraderId('def'))
self.assertEqual(decoded.payment_id, PaymentId('abc'))
self.assertEqual(decoded.success, False)
def test_encode_decode_order_status_request(self):
"""
Test encoding and decoding of a order status request
"""
message = MockObject()
meta_msg = self.market_community.get_meta_message(
u"order-status-request")
payload = OrderStatusRequestPayload.Implementation(
meta_msg, TraderId('abc'), MessageNumber('3'), Timestamp.now(),
TraderId('def'), OrderNumber(5), 1234)
message.payload = payload
packet, = self.conversion._encode_order_status_request(message)
self.assertTrue(packet)
_, decoded = self.conversion._decode_order_status_request(
self.get_placeholder_msg(u"order-status-request"), 0, packet)
self.assertTrue(decoded)
self.assertEqual(decoded.trader_id, TraderId('abc'))
self.assertEqual(decoded.identifier, 1234)
