class AbstractTestCommunity(AbstractServer):
# We have to initialize Dispersy and the tunnel community on the reactor thread
@inlineCallbacks
def setUp(self):
yield super(AbstractTestCommunity, self).setUp()
self.dispersy = Dispersy(ManualEnpoint(0), self.getStateDir())
self.dispersy._database.open()
self.master_member = DummyMember(self.dispersy, 1, "a" * 20)
self.member = self.dispersy.get_new_member(u"curve25519")
@inlineCallbacks
def tearDown(self):
for community in self.dispersy.get_communities():
yield community.unload_community()
self.master_member = None
self.member = None
yield super(AbstractTestCommunity, self).tearDown()
class TestCircuitDebugEndpoint(AbstractApiTest):
@blocking_call_on_reactor_thread
@inlineCallbacks
def setUp(self, autoload_discovery=True):
yield super(TestCircuitDebugEndpoint,
self).setUp(autoload_discovery=autoload_discovery)
self.dispersy = Dispersy(ManualEnpoint(0), self.getStateDir())
self.dispersy._database.open()
master_member = DummyMember(self.dispersy, 1, "a" * 20)
member = self.dispersy.get_new_member(u"curve25519")
self.tunnel_community = HiddenTunnelCommunity(self.dispersy,
master_member, member)
self.dispersy.get_communities = lambda: [self.tunnel_community]
self.session.get_dispersy_instance = lambda: self.dispersy
def setUpPreSession(self):
super(TestCircuitDebugEndpoint, self).setUpPreSession()
self.config.set_tunnel_community_enabled(True)
@deferred(timeout=10)
def test_get_circuit_no_community(self):
"""
Testing whether the API returns error 404 if no tunnel community is loaded
"""
self.dispersy.get_communities = lambda: []
return self.do_request('debug/circuits', expected_code=404)
@deferred(timeout=10)
def test_get_circuits(self):
"""
Testing whether the API returns the correct circuits
"""
mock_hop = MockObject()
mock_hop.host = 'somewhere'
mock_hop.port = 4242
mock_circuit = MockObject()
mock_circuit.state = 'TESTSTATE'
mock_circuit.goal_hops = 42
mock_circuit.bytes_up = 200
mock_circuit.bytes_down = 400
mock_circuit.creation_time = 1234
mock_circuit.hops = [mock_hop]
self.tunnel_community.circuits = {'abc': mock_circuit}
def verify_response(response):
response_json = json.loads(response)
self.assertEqual(len(response_json['circuits']), 1)
self.assertEqual(response_json['circuits'][0]['state'],
'TESTSTATE')
self.assertEqual(response_json['circuits'][0]['bytes_up'], 200)
self.assertEqual(response_json['circuits'][0]['bytes_down'], 400)
self.assertEqual(len(response_json['circuits'][0]['hops']), 1)
self.assertEqual(response_json['circuits'][0]['hops'][0]['host'],
'somewhere:4242')
self.should_check_equality = False
return self.do_request('debug/circuits',
expected_code=200).addCallback(verify_response)
@deferred(timeout=10)
def test_get_open_files(self):
"""
Test whether the API returns open files
"""
def verify_response(response):
response_json = json.loads(response)
self.assertGreaterEqual(len(response_json['open_files']), 1)
self.should_check_equality = False
return self.do_request('debug/open_files',
expected_code=200).addCallback(verify_response)
@deferred(timeout=10)
def test_get_open_sockets(self):
"""
Test whether the API returns open sockets
"""
def verify_response(response):
response_json = json.loads(response)
self.assertGreaterEqual(len(response_json['open_sockets']), 1)
self.should_check_equality = False
return self.do_request('debug/open_sockets',
expected_code=200).addCallback(verify_response)
@deferred(timeout=10)
def test_get_threads(self):
"""
Test whether the API returns open threads
"""
def verify_response(response):
response_json = json.loads(response)
self.assertGreaterEqual(len(response_json['threads']), 1)
self.should_check_equality = False
return self.do_request('debug/threads',
expected_code=200).addCallback(verify_response)
@deferred(timeout=10)
def test_get_cpu_history(self):
"""
Test whether the API returns the cpu history
"""
def verify_response(response):
response_json = json.loads(response)
self.assertGreaterEqual(len(response_json['cpu_history']), 1)
self.session.lm.resource_monitor.check_resources()
self.should_check_equality = False
return self.do_request('debug/cpu/history',
expected_code=200).addCallback(verify_response)
@deferred(timeout=10)
def test_get_memory_history(self):
"""
Test whether the API returns the memory history
"""
def verify_response(response):
response_json = json.loads(response)
self.assertGreaterEqual(len(response_json['memory_history']), 1)
self.session.lm.resource_monitor.check_resources()
self.should_check_equality = False
return self.do_request('debug/memory/history',
expected_code=200).addCallback(verify_response)
@deferred(timeout=60)
def test_dump_memory(self):
"""
Test whether the API returns a memory dump
"""
def verify_response(response):
self.assertTrue(response)
self.should_check_equality = False
return self.do_request('debug/memory/dump',
expected_code=200).addCallback(verify_response)
@deferred(timeout=10)
def test_debug_pane_core_logs(self):
"""
Test whether the API returns the logs
"""
test_core_log_message = "This is the core test log message"
max_lines = 100
# Log directory
log_dir = SessionStartupConfig.load().get_log_dir()
if not os.path.exists(log_dir):
os.makedirs(log_dir)
# Fill logging files with statements
core_info_log_file_path = os.path.join(log_dir,
'tribler-core-info.log')
# write 100 test lines which is used to test for its presence in the response
with open(core_info_log_file_path, "w") as core_info_log_file:
for log_index in xrange(max_lines):
core_info_log_file.write("%s %d\n" %
(test_core_log_message, log_index))
def verify_log_exists(response):
json_response = json.loads(response)
logs = json_response['content'].strip().split("\n")
# Check number of logs returned is correct
self.assertEqual(len(logs), max_lines)
# Check if test log message is present in the logs, at least once
log_exists = any(
(True for log in logs if test_core_log_message in log))
self.assertTrue(log_exists,
"Test log not found in the debug log response")
self.should_check_equality = False
return self.do_request('debug/log?process=core&max_lines=%d' % max_lines, expected_code=200)\
.addCallback(verify_log_exists)\
@deferred(timeout=10)
def test_debug_pane_default_num_logs(self):
"""
Test whether the API returns the last 100 logs when no max_lines parameter is not provided
"""
test_core_log_message = "This is the gui test log message"
expected_num_lines = 100
# Log directory
log_dir = SessionStartupConfig.load().get_log_dir()
if not os.path.exists(log_dir):
os.makedirs(log_dir)
gui_info_log_file_path = os.path.join(log_dir, 'tribler-gui-info.log')
# write 200 (greater than expected_num_lines) test logs in file
with open(gui_info_log_file_path, "w") as core_info_log_file:
for log_index in xrange(200): # write more logs
core_info_log_file.write("%s %d\n" %
(test_core_log_message, log_index))
# Check number of logs returned is as expected
def verify_max_logs_returned(response):
json_response = json.loads(response)
logs = json_response['content'].strip().split("\n")
self.assertEqual(len(logs), expected_num_lines)
self.should_check_equality = False
return self.do_request('debug/log?process=gui&max_lines=', expected_code=200)\
.addCallback(verify_max_logs_returned)
class TestCircuitDebugEndpoint(AbstractApiTest):
@blocking_call_on_reactor_thread
@inlineCallbacks
def setUp(self, autoload_discovery=True):
yield super(TestCircuitDebugEndpoint,
self).setUp(autoload_discovery=autoload_discovery)
self.dispersy = Dispersy(ManualEnpoint(0), self.getStateDir())
self.dispersy._database.open()
master_member = DummyMember(self.dispersy, 1, "a" * 20)
member = self.dispersy.get_new_member(u"curve25519")
self.tunnel_community = HiddenTunnelCommunity(self.dispersy,
master_member, member)
self.dispersy.get_communities = lambda: [self.tunnel_community]
self.session.get_dispersy_instance = lambda: self.dispersy
def setUpPreSession(self):
super(TestCircuitDebugEndpoint, self).setUpPreSession()
self.config.set_tunnel_community_enabled(True)
@deferred(timeout=10)
def test_get_circuit_no_community(self):
"""
Testing whether the API returns error 404 if no tunnel community is loaded
"""
self.dispersy.get_communities = lambda: []
return self.do_request('debug/circuits', expected_code=404)
@deferred(timeout=10)
def test_get_circuits(self):
"""
Testing whether the API returns the correct circuits
"""
mock_hop = MockObject()
mock_hop.host = 'somewhere'
mock_hop.port = 4242
mock_circuit = MockObject()
mock_circuit.state = 'TESTSTATE'
mock_circuit.goal_hops = 42
mock_circuit.bytes_up = 200
mock_circuit.bytes_down = 400
mock_circuit.creation_time = 1234
mock_circuit.hops = [mock_hop]
self.tunnel_community.circuits = {'abc': mock_circuit}
def verify_response(response):
response_json = json.loads(response)
self.assertEqual(len(response_json['circuits']), 1)
self.assertEqual(response_json['circuits'][0]['state'],
'TESTSTATE')
self.assertEqual(response_json['circuits'][0]['bytes_up'], 200)
self.assertEqual(response_json['circuits'][0]['bytes_down'], 400)
self.assertEqual(len(response_json['circuits'][0]['hops']), 1)
self.assertEqual(response_json['circuits'][0]['hops'][0]['host'],
'somewhere:4242')
self.should_check_equality = False
return self.do_request('debug/circuits',
expected_code=200).addCallback(verify_response)
class TestMultichainStatsEndpoint(AbstractApiTest):
@blocking_call_on_reactor_thread
@inlineCallbacks
def setUp(self, autoload_discovery=True):
yield super(TestMultichainStatsEndpoint,
self).setUp(autoload_discovery=autoload_discovery)
self.dispersy = Dispersy(ManualEnpoint(0), self.getStateDir())
self.dispersy._database.open()
master_member = DummyMember(self.dispersy, 1, "a" * 20)
self.member = self.dispersy.get_new_member(u"curve25519")
self.mc_community = MultiChainCommunity(self.dispersy, master_member,
self.member)
self.dispersy.get_communities = lambda: [self.mc_community]
self.session.get_dispersy_instance = lambda: self.dispersy
@deferred(timeout=10)
def test_get_circuit_no_community(self):
"""
Testing whether the API returns error 404 if no multichain community is loaded
"""
self.dispersy.get_communities = lambda: []
return self.do_request('multichain/statistics', expected_code=404)
@deferred(timeout=10)
def test_get_statistics(self):
"""
Testing whether the API returns the correct statistics
"""
mock_block = MockObject()
mock_block.public_key_requester = self.member.public_key
mock_block.public_key_responder = "deadbeef".decode("HEX")
mock_block.up = 42
mock_block.down = 8
mock_block.total_up_requester = 1024
mock_block.total_down_requester = 2048
mock_block.sequence_number_requester = 3
mock_block.previous_hash_requester = "cafebabe".decode("HEX")
mock_block.hash_requester = "b19b00b5".decode("HEX")
mock_block.signature_requester = "deadbabe".decode("HEX")
mock_block.total_up_responder = 512
mock_block.total_down_responder = 256
mock_block.sequence_number_responder = 15
mock_block.previous_hash_responder = "cafef00d".decode("HEX")
mock_block.hash_responder = "baadf00d".decode("HEX")
mock_block.signature_responder = "deadf00d".decode("HEX")
self.mc_community.persistence.add_block(mock_block)
def verify_response(response):
response_json = json.loads(response)
self.assertTrue("statistics" in response_json)
stats = response_json["statistics"]
self.assertEqual(
stats["self_id"],
base64.encodestring(self.member.public_key).strip())
self.assertEqual(stats["self_total_blocks"], 3)
self.assertEqual(stats["self_total_up_mb"], 1024)
self.assertEqual(stats["self_total_down_mb"], 2048)
self.assertNotEqual(stats["latest_block_insert_time"], "")
self.assertEqual(
stats["latest_block_id"],
base64.encodestring("b19b00b5".decode("HEX")).strip())
self.assertEqual(
stats["latest_block_requester_id"],
base64.encodestring(self.member.public_key).strip())
self.assertEqual(
stats["latest_block_responder_id"],
base64.encodestring("deadbeef".decode("HEX")).strip())
self.assertEqual(stats["latest_block_up_mb"], "42")
self.assertEqual(stats["latest_block_down_mb"], "8")
self.should_check_equality = False
return self.do_request('multichain/statistics',
expected_code=200).addCallback(verify_response)
@deferred(timeout=10)
def test_get_statistics_no_data(self):
"""
Testing whether the API returns the correct statistics
"""
def verify_response(response):
response_json = json.loads(response)
self.assertTrue("statistics" in response_json)
stats = response_json["statistics"]
self.assertEqual(
stats["self_id"],
base64.encodestring(self.member.public_key).strip())
self.assertEqual(stats["self_total_blocks"], -1)
self.assertEqual(stats["self_total_up_mb"], 0)
self.assertEqual(stats["self_total_down_mb"], 0)
self.assertEqual(stats["latest_block_insert_time"], "")
self.assertEqual(stats["latest_block_id"], "")
self.assertEqual(stats["latest_block_requester_id"], "")
self.assertEqual(stats["latest_block_responder_id"], "")
self.assertEqual(stats["latest_block_up_mb"], "")
self.assertEqual(stats["latest_block_down_mb"], "")
self.should_check_equality = False
return self.do_request('multichain/statistics',
expected_code=200).addCallback(verify_response)
class TestCircuitDebugEndpoint(AbstractApiTest):
@blocking_call_on_reactor_thread
@inlineCallbacks
def setUp(self, autoload_discovery=True):
yield super(TestCircuitDebugEndpoint,
self).setUp(autoload_discovery=autoload_discovery)
self.dispersy = Dispersy(ManualEnpoint(0), self.getStateDir())
self.dispersy._database.open()
master_member = DummyMember(self.dispersy, 1, "a" * 20)
member = self.dispersy.get_new_member(u"curve25519")
self.tunnel_community = HiddenTunnelCommunity(self.dispersy,
master_member, member)
self.dispersy.get_communities = lambda: [self.tunnel_community]
self.session.get_dispersy_instance = lambda: self.dispersy
def setUpPreSession(self):
super(TestCircuitDebugEndpoint, self).setUpPreSession()
self.config.set_tunnel_community_enabled(True)
@deferred(timeout=10)
def test_get_circuit_no_community(self):
"""
Testing whether the API returns error 404 if no tunnel community is loaded
"""
self.dispersy.get_communities = lambda: []
return self.do_request('debug/circuits', expected_code=404)
@deferred(timeout=10)
def test_get_circuits(self):
"""
Testing whether the API returns the correct circuits
"""
mock_hop = MockObject()
mock_hop.host = 'somewhere'
mock_hop.port = 4242
mock_circuit = MockObject()
mock_circuit.state = 'TESTSTATE'
mock_circuit.goal_hops = 42
mock_circuit.bytes_up = 200
mock_circuit.bytes_down = 400
mock_circuit.creation_time = 1234
mock_circuit.hops = [mock_hop]
self.tunnel_community.circuits = {'abc': mock_circuit}
def verify_response(response):
response_json = json.loads(response)
self.assertEqual(len(response_json['circuits']), 1)
self.assertEqual(response_json['circuits'][0]['state'],
'TESTSTATE')
self.assertEqual(response_json['circuits'][0]['bytes_up'], 200)
self.assertEqual(response_json['circuits'][0]['bytes_down'], 400)
self.assertEqual(len(response_json['circuits'][0]['hops']), 1)
self.assertEqual(response_json['circuits'][0]['hops'][0]['host'],
'somewhere:4242')
self.should_check_equality = False
return self.do_request('debug/circuits',
expected_code=200).addCallback(verify_response)
@deferred(timeout=10)
def test_get_open_files(self):
"""
Test whether the API returns open files
"""
def verify_response(response):
response_json = json.loads(response)
self.assertGreaterEqual(len(response_json['open_files']), 1)
self.should_check_equality = False
return self.do_request('debug/open_files',
expected_code=200).addCallback(verify_response)
@deferred(timeout=10)
def test_get_open_sockets(self):
"""
Test whether the API returns open sockets
"""
def verify_response(response):
response_json = json.loads(response)
self.assertGreaterEqual(len(response_json['open_sockets']), 1)
self.should_check_equality = False
return self.do_request('debug/open_sockets',
expected_code=200).addCallback(verify_response)
@deferred(timeout=10)
def test_get_threads(self):
"""
Test whether the API returns open threads
"""
def verify_response(response):
response_json = json.loads(response)
self.assertGreaterEqual(len(response_json['threads']), 1)
self.should_check_equality = False
return self.do_request('debug/threads',
expected_code=200).addCallback(verify_response)
@deferred(timeout=10)
def test_get_cpu_history(self):
"""
Test whether the API returns the cpu history
"""
def verify_response(response):
response_json = json.loads(response)
self.assertGreaterEqual(len(response_json['cpu_history']), 1)
self.session.lm.resource_monitor.check_resources()
self.should_check_equality = False
return self.do_request('debug/cpu/history',
expected_code=200).addCallback(verify_response)
@deferred(timeout=10)
def test_get_memory_history(self):
"""
Test whether the API returns the memory history
"""
def verify_response(response):
response_json = json.loads(response)
self.assertGreaterEqual(len(response_json['memory_history']), 1)
self.session.lm.resource_monitor.check_resources()
self.should_check_equality = False
return self.do_request('debug/memory/history',
expected_code=200).addCallback(verify_response)
@deferred(timeout=10)
def test_dump_memory(self):
"""
Test whether the API returns a memory dump
"""
def verify_response(response):
self.assertTrue(response)
self.should_check_equality = False
return self.do_request('debug/memory/dump',
expected_code=200).addCallback(verify_response)
@deferred(timeout=10)
def test_debug_pane_logs(self):
"""
Test whether the API returns the logs
"""
test_log_message = "This is the test log message"
max_lines = 100
import Tribler
project_root_dir = os.path.abspath(
os.path.join(os.path.dirname(Tribler.__file__), ".."))
log_config = os.path.join(project_root_dir, "logger.conf")
# State directory for logs
state_log_dir = os.path.join(self.session.config.get_state_dir(),
'logs')
if not os.path.exists(state_log_dir):
os.makedirs(state_log_dir)
# Setup logging
logging.info_log_file = os.path.join(state_log_dir, 'tribler-info.log')
logging.error_log_file = os.path.join(state_log_dir,
'tribler-error.log')
logging.config.fileConfig(log_config, disable_existing_loggers=False)
def verify_log_exists(response):
json_response = json.loads(response)
logs = json_response['content'].strip().split("\n")
# Check number of logs returned is correct
self.assertEqual(len(logs), max_lines)
# Check if test log message is present in the logs, at least once
log_exists = any((True for log in logs if test_log_message in log))
self.assertTrue(log_exists,
"Test log not found in the debug log response")
# write 100 test logs which is used to test for its presence in the response
for log_index in xrange(100):
logging.error("%s [%d]", test_log_message, log_index)
self.should_check_equality = False
return self.do_request(
'debug/log?max_lines=%d' % max_lines,
expected_code=200).addCallback(verify_log_exists)
class TestTrustchainStatsEndpoint(AbstractApiTest):
@blocking_call_on_reactor_thread
@inlineCallbacks
def setUp(self, autoload_discovery=True):
yield super(TestTrustchainStatsEndpoint,
self).setUp(autoload_discovery=autoload_discovery)
self.dispersy = Dispersy(ManualEnpoint(0), self.getStateDir())
self.dispersy._database.open()
master_member = DummyMember(self.dispersy, 1, "a" * 20)
self.member = self.dispersy.get_new_member(u"curve25519")
self.tc_community = TriblerChainCommunity(self.dispersy, master_member,
self.member)
self.dispersy.get_communities = lambda: [self.tc_community]
self.session.get_dispersy_instance = lambda: self.dispersy
@deferred(timeout=10)
def test_get_statistics_no_community(self):
"""
Testing whether the API returns error 404 if no trustchain community is loaded
"""
dummy_master_member = DummyMember(self.dispersy, 1, "b" * 20)
Community.__abstractmethods__ = frozenset()
self.dispersy.get_communities = lambda: [
Community(self.dispersy, dummy_master_member, self.member),
Community(self.dispersy, dummy_master_member, self.member)
]
return self.do_request('trustchain/statistics', expected_code=404)
@deferred(timeout=10)
def test_get_statistics(self):
"""
Testing whether the API returns the correct statistics
"""
block = TrustChainBlock()
block.public_key = self.member.public_key
block.link_public_key = "deadbeef".decode("HEX")
block.link_sequence_number = 21
block.transaction = {
"up": 42,
"down": 8,
"total_up": 1024,
"total_down": 2048
}
block.sequence_number = 3
block.previous_hash = "babecafe".decode("HEX")
block.signature = "babebeef".decode("HEX")
self.tc_community.persistence.add_block(block)
def verify_response(response):
response_json = json.loads(response)
self.assertTrue("statistics" in response_json)
stats = response_json["statistics"]
self.assertEqual(stats["id"], self.member.public_key.encode("HEX"))
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)
self.assertIn("latest_block", stats)
self.assertNotEqual(stats["latest_block"]["insert_time"], "")
self.assertEqual(stats["latest_block"]["hash"],
block.hash.encode("HEX"))
self.assertEqual(stats["latest_block"]["link_public_key"],
"deadbeef")
self.assertEqual(stats["latest_block"]["link_sequence_number"], 21)
self.assertEqual(stats["latest_block"]["up"], 42)
self.assertEqual(stats["latest_block"]["down"], 8)
self.should_check_equality = False
return self.do_request('trustchain/statistics',
expected_code=200).addCallback(verify_response)
@deferred(timeout=10)
def test_get_statistics_no_data(self):
"""
Testing whether the API returns the correct statistics
"""
def verify_response(response):
response_json = json.loads(response)
self.assertTrue("statistics" in response_json)
stats = response_json["statistics"]
self.assertEqual(stats["id"], self.member.public_key.encode("HEX"))
self.assertEqual(stats["total_blocks"], 0)
self.assertEqual(stats["total_up"], 0)
self.assertEqual(stats["total_down"], 0)
self.assertEqual(stats["peers_that_pk_helped"], 0)
self.assertEqual(stats["peers_that_helped_pk"], 0)
self.assertNotIn("latest_block", stats)
self.should_check_equality = False
return self.do_request('trustchain/statistics',
expected_code=200).addCallback(verify_response)
@deferred(timeout=10)
def test_get_blocks_no_community(self):
"""
Testing whether the API returns error 404 if no trustchain community is loaded when requesting blocks
"""
self.dispersy.get_communities = lambda: []
return self.do_request('trustchain/blocks/aaaaa', expected_code=404)
@deferred(timeout=10)
def test_get_blocks(self):
"""
Testing whether the API returns the correct blocks
"""
def verify_response(response):
response_json = json.loads(response)
self.assertEqual(len(response_json["blocks"]), 1)
test_block = TestBlock()
self.tc_community.persistence.add_block(test_block)
self.should_check_equality = False
return self.do_request('trustchain/blocks/%s?limit=10' %
test_block.public_key.encode("HEX"),
expected_code=200).addCallback(verify_response)
@deferred(timeout=10)
def test_get_blocks_bad_limit_too_many(self):
"""
Testing whether the API takes large values for the limit
"""
self.should_check_equality = False
return self.do_request('trustchain/blocks/%s?limit=10000000' %
TestBlock().public_key.encode("HEX"),
expected_code=400)
@deferred(timeout=10)
def test_get_blocks_bad_limit_negative(self):
"""
Testing whether the API takes negative values for the limit
"""
self.should_check_equality = False
return self.do_request('trustchain/blocks/%s?limit=-10000000' %
TestBlock().public_key.encode("HEX"),
expected_code=400)
@deferred(timeout=10)
def test_get_blocks_bad_limit_nan(self):
"""
Testing whether the API takes odd values for the limit
"""
self.should_check_equality = False
return self.do_request('trustchain/blocks/%s?limit=bla' %
TestBlock().public_key.encode("HEX"),
expected_code=400)
@deferred(timeout=10)
def test_get_blocks_bad_limit_nothing(self):
"""
Testing whether the API takes no values for the limit
"""
self.should_check_equality = False
return self.do_request('trustchain/blocks/%s?limit=' %
TestBlock().public_key.encode("HEX"),
expected_code=400)
@deferred(timeout=10)
def test_get_blocks_unlimited(self):
"""
Testing whether the API takes no limit argument
"""
self.should_check_equality = False
return self.do_request('trustchain/blocks/%s' %
TestBlock().public_key.encode("HEX"),
expected_code=200)
@deferred(timeout=10)
def test_get_bootstrap_identity_no_community(self):
"""
Testing whether the API returns error 404 if no trustchain community is loaded when bootstrapping a new identity
"""
self.dispersy.get_communities = lambda: []
return self.do_request('trustchain/bootstrap', expected_code=404)
@deferred(timeout=10)
def test_get_bootstrap_identity_all_tokens(self):
"""
Testing whether the API return all available credit when no argument is supplied
"""
transaction = {'up': 100, 'down': 0, 'total_up': 100, 'total_down': 0}
transaction2 = {'up': 100, 'down': 0}
def verify_response(response):
response_json = json.loads(response)
self.assertEqual(response_json['transaction'], transaction2)
test_block = TestBlock(transaction=transaction,
key=self.tc_community.my_member.private_key)
self.tc_community.persistence.add_block(test_block)
self.should_check_equality = False
return self.do_request('trustchain/bootstrap',
expected_code=200).addCallback(verify_response)
@deferred(timeout=10)
def test_get_bootstrap_identity_partial_tokens(self):
"""
Testing whether the API return partial available credit when argument is supplied
"""
transaction = {'up': 100, 'down': 0, 'total_up': 100, 'total_down': 0}
transaction2 = {'up': 50, 'down': 0}
def verify_response(response):
response_json = json.loads(response)
self.assertEqual(response_json['transaction'], transaction2)
test_block = TestBlock(transaction=transaction,
key=self.tc_community.my_member.private_key)
self.tc_community.persistence.add_block(test_block)
self.should_check_equality = False
return self.do_request('trustchain/bootstrap?amount=50',
expected_code=200).addCallback(verify_response)
@deferred(timeout=10)
def test_get_bootstrap_identity_not_enough_tokens(self):
"""
Testing whether the API returns error 400 if bandwidth is to low when bootstrapping a new identity
"""
transaction = {'up': 100, 'down': 0, 'total_up': 100, 'total_down': 0}
test_block = TestBlock(transaction=transaction,
key=self.tc_community.my_member.private_key)
self.tc_community.persistence.add_block(test_block)
self.should_check_equality = False
return self.do_request('trustchain/bootstrap?amount=200',
expected_code=400)
@deferred(timeout=10)
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 = {'up': 0, 'down': 100, 'total_up': 0, 'total_down': 100}
test_block = TestBlock(transaction=transaction,
key=self.tc_community.my_member.private_key)
self.tc_community.persistence.add_block(test_block)
self.should_check_equality = False
return self.do_request('trustchain/bootstrap?amount=10',
expected_code=400)
@deferred(timeout=10)
def test_get_bootstrap_identity_zero_amount(self):
"""
Testing whether the API returns error 400 if amount is zero when bootstrapping a new identity
"""
self.should_check_equality = False
return self.do_request('trustchain/bootstrap?amount=0',
expected_code=400)
@deferred(timeout=10)
def test_get_bootstrap_identity_negative_amount(self):
"""
Testing whether the API returns error 400 if amount is negative when bootstrapping a new identity
"""
self.should_check_equality = False
return self.do_request('trustchain/bootstrap?amount=-1',
expected_code=400)
@deferred(timeout=10)
def test_get_bootstrap_identity_string(self):
"""
Testing whether the API returns error 400 if amount is string when bootstrapping a new identity
"""
self.should_check_equality = False
return self.do_request('trustchain/bootstrap?amount=aaa',
expected_code=400)
class TestMultichainStatsEndpoint(AbstractApiTest):
@blocking_call_on_reactor_thread
@inlineCallbacks
def setUp(self, autoload_discovery=True):
yield super(TestMultichainStatsEndpoint, self).setUp(autoload_discovery=autoload_discovery)
self.dispersy = Dispersy(ManualEnpoint(0), self.getStateDir())
self.dispersy._database.open()
master_member = DummyMember(self.dispersy, 1, "a" * 20)
self.member = self.dispersy.get_new_member(u"curve25519")
self.mc_community = MultiChainCommunity(self.dispersy, master_member, self.member)
self.dispersy.get_communities = lambda: [self.mc_community]
self.session.get_dispersy_instance = lambda: self.dispersy
@deferred(timeout=10)
def test_get_statistics_no_community(self):
"""
Testing whether the API returns error 404 if no multichain community is loaded
"""
dummy_master_member = DummyMember(self.dispersy, 1, "b" * 20)
Community.__abstractmethods__ = frozenset()
self.dispersy.get_communities = lambda: [Community(self.dispersy, dummy_master_member, self.member),
Community(self.dispersy, dummy_master_member, self.member)]
return self.do_request('multichain/statistics', expected_code=404)
@deferred(timeout=10)
def test_get_statistics(self):
"""
Testing whether the API returns the correct statistics
"""
block = MultiChainBlock()
block.public_key = self.member.public_key
block.link_public_key = "deadbeef".decode("HEX")
block.link_sequence_number = 21
block.up = 42
block.down = 8
block.total_up = 1024
block.total_down = 2048
block.sequence_number = 3
block.previous_hash = "babecafe".decode("HEX")
block.signature = "babebeef".decode("HEX")
self.mc_community.persistence.add_block(block)
def verify_response(response):
response_json = json.loads(response)
self.assertTrue("statistics" in response_json)
stats = response_json["statistics"]
self.assertEqual(stats["id"], self.member.public_key.encode("HEX"))
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)
self.assertIn("latest_block", stats)
self.assertNotEqual(stats["latest_block"]["insert_time"], "")
self.assertEqual(stats["latest_block"]["hash"], block.hash.encode("HEX"))
self.assertEqual(stats["latest_block"]["link_public_key"], "deadbeef")
self.assertEqual(stats["latest_block"]["link_sequence_number"], 21)
self.assertEqual(stats["latest_block"]["up"], 42)
self.assertEqual(stats["latest_block"]["down"], 8)
self.should_check_equality = False
return self.do_request('multichain/statistics', expected_code=200).addCallback(verify_response)
@deferred(timeout=10)
def test_get_statistics_no_data(self):
"""
Testing whether the API returns the correct statistics
"""
def verify_response(response):
response_json = json.loads(response)
self.assertTrue("statistics" in response_json)
stats = response_json["statistics"]
self.assertEqual(stats["id"], self.member.public_key.encode("HEX"))
self.assertEqual(stats["total_blocks"], 0)
self.assertEqual(stats["total_up"], 0)
self.assertEqual(stats["total_down"], 0)
self.assertEqual(stats["peers_that_pk_helped"], 0)
self.assertEqual(stats["peers_that_helped_pk"], 0)
self.assertNotIn("latest_block", stats)
self.should_check_equality = False
return self.do_request('multichain/statistics', expected_code=200).addCallback(verify_response)
@deferred(timeout=10)
def test_get_blocks_no_community(self):
"""
Testing whether the API returns error 404 if no multichain community is loaded when requesting blocks
"""
self.dispersy.get_communities = lambda: []
return self.do_request('multichain/blocks/aaaaa', expected_code=404)
@deferred(timeout=10)
def test_get_blocks(self):
"""
Testing whether the API returns the correct blocks
"""
def verify_response(response):
response_json = json.loads(response)
self.assertEqual(len(response_json["blocks"]), 1)
test_block = TestBlock()
self.mc_community.persistence.add_block(test_block)
self.should_check_equality = False
return self.do_request('multichain/blocks/%s?limit=10' % test_block.public_key.encode("HEX"),
expected_code=200).addCallback(verify_response)
@deferred(timeout=10)
def test_get_blocks_bad_limit_too_many(self):
"""
Testing whether the API takes large values for the limit
"""
self.should_check_equality = False
return self.do_request('multichain/blocks/%s?limit=10000000' % TestBlock().public_key.encode("HEX"),
expected_code=400)
@deferred(timeout=10)
def test_get_blocks_bad_limit_negative(self):
"""
Testing whether the API takes negative values for the limit
"""
self.should_check_equality = False
return self.do_request('multichain/blocks/%s?limit=-10000000' % TestBlock().public_key.encode("HEX"),
expected_code=400)
@deferred(timeout=10)
def test_get_blocks_bad_limit_nan(self):
"""
Testing whether the API takes odd values for the limit
"""
self.should_check_equality = False
return self.do_request('multichain/blocks/%s?limit=bla' % TestBlock().public_key.encode("HEX"),
expected_code=400)
@deferred(timeout=10)
def test_get_blocks_bad_limit_nothing(self):
"""
Testing whether the API takes no values for the limit
"""
self.should_check_equality = False
return self.do_request('multichain/blocks/%s?limit=' % TestBlock().public_key.encode("HEX"),
expected_code=400)
@deferred(timeout=10)
def test_get_blocks_unlimited(self):
"""
Testing whether the API takes no limit argument
"""
self.should_check_equality = False
return self.do_request('multichain/blocks/%s' % TestBlock().public_key.encode("HEX"),
expected_code=200)
