async def test_get_statistics(self):
"""
Testing whether the API returns the correct statistics
"""
block = TrustChainBlock()
block.public_key = self.session.trustchain_community.my_peer.public_key.key_to_bin()
block.link_public_key = unhexlify(b"deadbeef")
block.link_sequence_number = 21
block.type = b'tribler_bandwidth'
block.transaction = {b"up": 42, b"down": 8, b"total_up": 1024,
b"total_down": 2048, b"type": b"tribler_bandwidth"}
block._transaction = encode(block.transaction)
block.sequence_number = 3
block.previous_hash = unhexlify(b"babecafe")
block.signature = unhexlify(b"babebeef")
block.hash = block.calculate_hash()
self.session.trustchain_community.persistence.add_block(block)
response_dict = await self.do_request('trustchain/statistics', expected_code=200)
self.assertTrue("statistics" in response_dict)
stats = response_dict["statistics"]
self.assertEqual(stats["id"], hexlify(self.session.trustchain_community.
my_peer.public_key.key_to_bin()))
self.assertEqual(stats["total_blocks"], 3)
self.assertEqual(stats["total_up"], 1024)
self.assertEqual(stats["total_down"], 2048)
self.assertEqual(stats["peers_that_pk_helped"], 1)
self.assertEqual(stats["peers_that_helped_pk"], 1)
def create(cls,
block_type,
transaction,
database,
public_key,
link=None,
link_pk=None,
additional_info=None):
"""
Create an empty next block.
:param block_type: the type of the block to be created
:param transaction: the transaction to use in this block
:param database: the database to use as information source
:param public_key: the public key to use for this block
:param link: optionally create the block as a linked block to this block
:param link_pk: the public key of the counterparty in this transaction
:param additional_info: additional information, which has a higher priority than the
transaction when link exists
:return: A newly created block
"""
latest_bw_block = database.get_latest(public_key,
block_type=b'tribler_bandwidth')
latest_block = database.get_latest(public_key)
ret = cls()
if link:
ret.type = link.type
ret.transaction["up"] = link.transaction[
"down"] if "down" in link.transaction else 0
ret.transaction["down"] = link.transaction[
"up"] if "up" in link.transaction else 0
ret.link_public_key = link.public_key
ret.link_sequence_number = link.sequence_number
else:
ret.type = block_type
ret.transaction[
"up"] = transaction["up"] if "up" in transaction else 0
ret.transaction[
"down"] = transaction["down"] if "down" in transaction else 0
ret.link_public_key = link_pk
if latest_bw_block:
ret.transaction["total_up"] = latest_bw_block.transaction[
"total_up"] + ret.transaction["up"]
ret.transaction["total_down"] = latest_bw_block.transaction[
"total_down"] + ret.transaction["down"]
else:
ret.transaction["total_up"] = ret.transaction["up"]
ret.transaction["total_down"] = ret.transaction["down"]
if latest_block:
ret.sequence_number = latest_block.sequence_number + 1
ret.previous_hash = latest_block.hash
ret._transaction = encode(ret.transaction)
ret.public_key = public_key
ret.signature = EMPTY_SIG
ret.hash = ret.calculate_hash()
return ret
def test_encode_tuple(self):
"""
Check if a tuple can be encoded and decoded.
"""
value = (42, 42L, 42.0, u"42", '\x42')
encoded = encode(value)
_, decoded = decode(encoded)
self.assertEqual(value, decoded)
def test_encode_dict(self):
"""
Check if a dictionary can be encoded and decoded.
"""
value = {42: None, 42L: 42.0, u"42": '\x42'}
encoded = encode(value)
_, decoded = decode(encoded)
self.assertEqual(value, decoded)
def test_encode_int(self):
"""
Check if an int can be encoded and decoded.
"""
value = 42
encoded = encode(value)
_, decoded = decode(encoded)
self.assertEqual(value, decoded)
def test_encode_set(self):
"""
Check if a set can be encoded and decoded.
"""
value = {42, 42L, 42.0, u"42", '\x42'}
encoded = encode(value)
_, decoded = decode(encoded)
self.assertEqual(value, decoded)
def test_encode_unicode(self):
"""
Check if a unicode value can be encoded and decoded.
"""
value = u"42"
encoded = encode(value)
_, decoded = decode(encoded)
self.assertEqual(value, decoded)
def test_encode_long(self):
"""
Check if an long can be encoded and decoded.
"""
value = 42L
encoded = encode(value)
_, decoded = decode(encoded)
self.assertEqual(value, decoded)
def test_encode_bool_false(self):
"""
Check if a (false) boolean can be encoded and decoded.
"""
value = False
encoded = encode(value)
_, decoded = decode(encoded)
self.assertEqual(value, decoded)
def test_encode_bool(self):
"""
Check if a (true) boolean can be encoded and decoded.
"""
value = True
encoded = encode(value)
_, decoded = decode(encoded)
self.assertEqual(value, decoded)
def test_encode_none(self):
"""
Check if a None can be encoded and decoded.
"""
value = None
encoded = encode(value)
_, decoded = decode(encoded)
self.assertEqual(value, decoded)
async def test_get_bootstrap_identity_not_enough_tokens_2(self):
"""
Testing whether the API returns error 400 if bandwidth is to low when bootstrapping a new identity
"""
transaction = {b'up': 0, b'down': 100, b'total_up': 0, b'total_down': 100}
test_block = TrustChainBlock()
test_block.type = b'tribler_bandwidth'
test_block.transaction = transaction
test_block._transaction = encode(transaction)
test_block.public_key = self.session.trustchain_community.my_peer.public_key.key_to_bin()
test_block.hash = test_block.calculate_hash()
self.session.trustchain_community.persistence.add_block(test_block)
await self.do_request('trustchain/bootstrap?amount=10', expected_code=400)
async def test_get_bootstrap_identity_all_tokens(self):
"""
Testing whether the API return all available tokens when no argument is supplied
"""
transaction = {b'up': 100, b'down': 0, b'total_up': 100, b'total_down': 0}
transaction2 = {'up': 100, 'down': 0}
test_block = TrustChainBlock()
test_block.type = b'tribler_bandwidth'
test_block.transaction = transaction
test_block._transaction = encode(transaction)
test_block.public_key = self.session.trustchain_community.my_peer.public_key.key_to_bin()
test_block.hash = test_block.calculate_hash()
self.session.trustchain_community.persistence.add_block(test_block)
response_dict = await self.do_request('trustchain/bootstrap', expected_code=200)
self.assertEqual(response_dict['transaction'], transaction2)
async def test_trustview_max_response(self):
"""
Test whether the trust graph response is limited.
Here we redefine the max peers and max transactions limit for trust graph and add more peers and transactions,
then test if the endpoint response is limited.
"""
max_peers = 10
max_tx = 10
self.endpoint.initialize_graph()
self.endpoint.trust_graph.set_limits(max_peers, max_tx)
def get_dummy_tx():
return {
b'up': random.randint(1, 101),
b'down': random.randint(1, 101),
b'total_up': random.randint(1, 101),
b'total_down': random.randint(1, 101),
}
test_block = TestBlock(
key=self.session.trustchain_community.my_peer.key)
test_block.sequence_number = 0
test_block.type = b'tribler_bandwidth'
for _ in range(max_peers * 2):
test_block.transaction = get_dummy_tx()
test_block._transaction = encode(test_block.transaction)
test_block.link_public_key = default_eccrypto.generate_key(
u"very-low").pub().key_to_bin()
test_block.hash = test_block.calculate_hash()
self.session.trustchain_community.persistence.add_block(test_block)
test_block.sequence_number = test_block.sequence_number + 1
response_json = await self.do_request('trustview?depth=0',
expected_code=200)
self.assertIsNotNone(response_json['graph'])
self.assertLessEqual(response_json['num_tx'], max_tx)
self.assertLessEqual(len(response_json['graph']['node']), max_peers)
async def test_trustview_response(self):
"""
Test whether the trust graph response is correctly returned.
"""
root_key = self.session.trustchain_community.my_peer.public_key.key_to_bin(
)
friends = [
"4c69624e61434c504b3a2ee28ce24a2259b4e585b81106cdff4359fcf48e93336c11d133b01613f30b03b4db06df27"
"80daac2cdf2ee60be611bf7367a9c1071ac50d65ca5858a50e9578",
"4c69624e61434c504b3a5368c7b39a82063e29576df6d74fba3e0dba3af8e7a304b553b71f08ea6a0730e8cef767a4"
"85dc6f390b6da5631f772941ea69ce2c098d802b7a28b500edf2b3",
"4c69624e61434c504b3a0f3f6318e49ffeb0a160e7fcac5c1d3337ba409b45e1371ddca5e3b364ebdd1b73c775318a"
"533a25335a5c36ae3695f1c3036b651893659fbf2e1f2bce66cf65",
]
fofs = [
"4c69624e61434c504b3a2ee28ce24a2259b4e585b81106cdff4359fcf48e93336c11d133b01613f30b03b4db06df27"
"80daac2cdf2ee60be611bf7367a9c1071ac50d65ca5858a50e9579",
"4c69624e61434c504b3a5368c7b39a82063e29576df6d74fba3e0dba3af8e7a304b553b71f08ea6a0730e8cef767a4"
"85dc6f390b6da5631f772941ea69ce2c098d802b7a28b500edf2b4",
"4c69624e61434c504b3a0f3f6318e49ffeb0a160e7fcac5c1d3337ba409b45e1371ddca5e3b364ebdd1b73c775318a"
"533a25335a5c36ae3695f1c3036b651893659fbf2e1f2bce66cf66",
]
fofofs = [
"4c69624e61434c504b3a2ee28ce24a2259b4e585b81106cdff4359fcf48e93336c11d133b01613f30b03b4db06df27"
"80daac2cdf2ee60be611bf7367a9c1071ac50d65ca5858a50e9580",
"4c69624e61434c504b3a5368c7b39a82063e29576df6d74fba3e0dba3af8e7a304b553b71f08ea6a0730e8cef767a4"
"85dc6f390b6da5631f772941ea69ce2c098d802b7a28b500edf2b5",
"4c69624e61434c504b3a0f3f6318e49ffeb0a160e7fcac5c1d3337ba409b45e1371ddca5e3b364ebdd1b73c775318a"
"533a25335a5c36ae3695f1c3036b651893659fbf2e1f2bce66cf67",
]
def get_dummy_tx():
return {
b'up': random.randint(1, 101),
b'down': random.randint(1, 101),
b'total_up': random.randint(1, 101),
b'total_down': random.randint(1, 101),
}
def verify_response(response_json, nodes, tx):
self.assertIsNotNone(response_json['graph'])
self.assertEqual(response_json['num_tx'], tx)
self.assertEqual(len(response_json['graph']['node']), nodes)
test_block = TrustChainBlock()
test_block.type = b'tribler_bandwidth'
for seq, pub_key in enumerate(friends):
test_block.transaction = get_dummy_tx()
test_block._transaction = encode(test_block.transaction)
test_block.sequence_number = seq
test_block.public_key = root_key
test_block.link_public_key = unhexlify(pub_key)
test_block.hash = test_block.calculate_hash()
self.session.trustchain_community.persistence.add_block(test_block)
for ind, friend in enumerate(friends):
for ind2, fof in enumerate(fofs):
test_block.transaction = get_dummy_tx()
test_block._transaction = encode(test_block.transaction)
test_block.sequence_number = ind + ind2
test_block.public_key = unhexlify(friend)
test_block.link_public_key = unhexlify(fof)
test_block.hash = test_block.calculate_hash()
self.session.trustchain_community.persistence.add_block(
test_block)
for ind3, fof in enumerate(fofs):
for ind4, fofof in enumerate(fofofs):
test_block.transaction = get_dummy_tx()
test_block._transaction = encode(test_block.transaction)
test_block.sequence_number = ind3 + ind4
test_block.public_key = unhexlify(fof)
test_block.link_public_key = unhexlify(fofof)
test_block.hash = test_block.calculate_hash()
self.session.trustchain_community.persistence.add_block(
test_block)
res = await self.do_request('trustview?depth=1', expected_code=200)
verify_response(res, 4, 3)
res = await self.do_request('trustview?depth=2', expected_code=200)
verify_response(res, 7, 12)
res = await self.do_request('trustview?depth=3', expected_code=200)
verify_response(res, 10, 21)
res = await self.do_request('trustview?depth=4', expected_code=200)
verify_response(res, 10, 21)