def test_strategy_multi_peer(self): """ If we have multiple peers, we should select one and send it our channel views. Also, we should still inspect our download queue. """ self.community.get_peers_return = [Peer(default_eccrypto.generate_key(u"very-low")), Peer(default_eccrypto.generate_key(u"very-low")), Peer(default_eccrypto.generate_key(u"very-low"))] self.strategy.take_step() self.assertEqual(1, len(self.community.send_random_to_called)) self.assertIn(self.community.send_random_to_called[0], self.community.get_peers_return)
def test_strategy_multi_peer(self): """ If we have multiple peers, we should select one and send it our channel views. Also, we should still inspect our download queue. """ self.community.get_peers_return = [ Peer(default_eccrypto.generate_key(u"very-low")), Peer(default_eccrypto.generate_key(u"very-low")), Peer(default_eccrypto.generate_key(u"very-low")) ] self.strategy.take_step() self.assertEqual(1, len(self.community.send_random_to_called)) self.assertIn(self.community.send_random_to_called[0], self.community.get_peers_return)
def test_has_valid_signature(self): """ Test whether a signature can be validated correctly """ metadata = self.mds.ChannelNode.from_dict({}) self.assertTrue(metadata.has_valid_signature()) md_dict = metadata.to_dict() # Mess with the signature metadata.signature = 'a' self.assertFalse(metadata.has_valid_signature()) # Create metadata with wrong key metadata.delete() md_dict.update(public_key=database_blob("aaa")) md_dict.pop("rowid") metadata = self.mds.ChannelNode(skip_key_check=True, **md_dict) self.assertFalse(metadata.has_valid_signature()) key = default_eccrypto.generate_key(u"curve25519") metadata2 = self.mds.ChannelNode(sign_with=key, **md_dict) self.assertTrue(database_blob(key.pub().key_to_bin()[10:]), metadata2.public_key) md_dict2 = metadata2.to_dict() md_dict2["signature"] = md_dict["signature"] self.assertRaises(InvalidSignatureException, self.mds.ChannelNode, **md_dict2)
def test_cleanup_pony_experimental_db(self): # Create a Pony database of older experimental version pony_db = os.path.join(self.session_base_dir, 'pony.db') pony_db_bak = os.path.join(self.session_base_dir, 'pony2.db') my_key = default_eccrypto.generate_key(u"curve25519") mds = MetadataStore(pony_db, self.session_base_dir, my_key) mds.shutdown() shutil.copyfile(pony_db, pony_db_bak) connection = sqlite3.connect(pony_db) with connection: cursor = connection.cursor() cursor.execute("DROP TABLE MiscData") connection.close() # Assert older experimental version is deleted self.assertFalse(cleanup_pony_experimental_db(pony_db)) self.assertFalse(os.path.exists(pony_db)) # Assert recent database version is left untouched self.assertFalse(cleanup_pony_experimental_db(pony_db_bak)) self.assertTrue(os.path.exists(pony_db_bak)) # Assert True is returned for a garbled db and nothing is done with it garbled_db = os.path.join(self.session_base_dir, 'garbled.db') with open(garbled_db, 'w') as f: f.write("123") self.assertRaises(sqlite3.DatabaseError, cleanup_pony_experimental_db, garbled_db) self.assertTrue(os.path.exists(garbled_db))
def test_list_contents(self): """ Test whether a correct list with channel content is returned from the database """ self.mds.ChannelNode._my_key = default_eccrypto.generate_key('low') channel1 = self.mds.ChannelMetadata(infohash=str(random.getrandbits(160))) self.mds.TorrentMetadata.from_dict(dict(self.torrent_template)) self.mds.ChannelNode._my_key = default_eccrypto.generate_key('low') channel2 = self.mds.ChannelMetadata(infohash=str(random.getrandbits(160))) self.mds.TorrentMetadata.from_dict(dict(self.torrent_template, infohash="1")) self.mds.TorrentMetadata.from_dict(dict(self.torrent_template, infohash="2")) self.assertEqual(1, len(channel1.contents_list)) self.assertEqual(2, len(channel2.contents_list)) self.assertEqual(2, channel2.contents_len)
def test_get_channels(self): """ Test whether we can get channels """ # First we create a few channels for ind in xrange(10): self.mds.ChannelNode._my_key = default_eccrypto.generate_key('low') _ = self.mds.ChannelMetadata(title='channel%d' % ind, subscribed=(ind % 2 == 0), infohash=str(random.getrandbits(160))) channels = self.mds.ChannelMetadata.get_entries(first=1, last=5) self.assertEqual(len(channels[0]), 5) self.assertEqual(channels[1], 10) # Test filtering channels = self.mds.ChannelMetadata.get_entries(first=1, last=5, query_filter='channel5') self.assertEqual(len(channels[0]), 1) # Test sorting channels = self.mds.ChannelMetadata.get_entries(first=1, last=10, sort_by='title', sort_asc=False) self.assertEqual(len(channels[0]), 10) self.assertEqual(channels[0][0].title, 'channel9') # Test fetching subscribed channels channels = self.mds.ChannelMetadata.get_entries(first=1, last=10, sort_by='title', subscribed=True) self.assertEqual(len(channels[0]), 5)
def setUp(self): yield super(TestMetadataStore, self).setUp() my_key = default_eccrypto.generate_key(u"curve25519") self.mds = MetadataStore( os.path.join(self.session_base_dir, 'test.db'), self.session_base_dir, my_key)
def test_get_channels(self): """ Test whether we can get channels """ # First we create a few channels for ind in xrange(10): self.mds.ChannelNode._my_key = default_eccrypto.generate_key('low') _ = self.mds.ChannelMetadata(title='channel%d' % ind, subscribed=(ind % 2 == 0), infohash=str(random.getrandbits(160))) channels = self.mds.ChannelMetadata.get_entries(first=1, last=5) self.assertEqual(len(channels[0]), 5) self.assertEqual(channels[1], 10) # Test filtering channels = self.mds.ChannelMetadata.get_entries( first=1, last=5, query_filter='channel5') self.assertEqual(len(channels[0]), 1) # Test sorting channels = self.mds.ChannelMetadata.get_entries(first=1, last=10, sort_by='title', sort_asc=False) self.assertEqual(len(channels[0]), 10) self.assertEqual(channels[0][0].title, 'channel9') # Test fetching subscribed channels channels = self.mds.ChannelMetadata.get_entries(first=1, last=10, sort_by='title', subscribed=True) self.assertEqual(len(channels[0]), 5)
def create_node(self, *args, **kwargs): metadata_store = MetadataStore(os.path.join(self.temporary_directory(), "%d.db" % self.count), self.temporary_directory(), default_eccrypto.generate_key(u"curve25519")) kwargs['metadata_store'] = metadata_store node = super(TestGigaChannelUnits, self).create_node(*args, **kwargs) self.count += 1 return node
def test_list_contents(self): """ Test whether a correct list with channel content is returned from the database """ pub_key1 = default_eccrypto.generate_key('low').pub().key_to_bin() pub_key2 = default_eccrypto.generate_key('low').pub().key_to_bin() channel1 = self.mds.ChannelMetadata(public_key=pub_key1) self.mds.TorrentMetadata.from_dict(dict(self.torrent_template, public_key=pub_key1)) channel2 = self.mds.ChannelMetadata(public_key=pub_key2) self.mds.TorrentMetadata.from_dict(dict(self.torrent_template, public_key=pub_key2)) self.mds.TorrentMetadata.from_dict(dict(self.torrent_template, public_key=pub_key2)) self.assertEqual(1, len(channel1.contents_list)) self.assertEqual(2, len(channel2.contents_list)) self.assertEqual(2, channel2.contents_len)
def test_strategy_one_peer(self): """ If we have one peer, we should send it our channel views and inspect our download queue. """ self.community.get_peers_return = [Peer(default_eccrypto.generate_key(u"very-low"))] self.strategy.take_step() self.assertEqual(1, len(self.community.send_random_to_called)) self.assertEqual(self.community.get_peers_return[0], self.community.send_random_to_called[0])
def create_node(self, *args, **kwargs): metadata_store = MetadataStore( os.path.join(self.temporary_directory(), "%d.db" % self.count), self.temporary_directory(), default_eccrypto.generate_key(u"curve25519")) kwargs['metadata_store'] = metadata_store node = super(TestGigaChannelUnits, self).create_node(*args, **kwargs) self.count += 1 return node
def setUp(self): yield super(TestUpgradeDB72ToPony, self).setUp() self.my_key = default_eccrypto.generate_key(u"curve25519") mds_db = os.path.join(self.session_base_dir, 'test.db') mds_channels_dir = self.session_base_dir self.mds = MetadataStore(mds_db, mds_channels_dir, self.my_key) self.m = DispersyToPonyMigration(OLD_DB_SAMPLE) self.m.initialize(self.mds)
def setUp(self): yield super(TestChannelMetadata, self).setUp() self.torrent_template = { "title": "", "infohash": "", "torrent_date": datetime(1970, 1, 1), "tags": "video" } self.my_key = default_eccrypto.generate_key(u"curve25519") self.mds = MetadataStore(":memory:", self.session_base_dir, self.my_key)
def make_wrong_payload(filename): key = default_eccrypto.generate_key(u"curve25519") metadata_payload = SignedPayload(666, 0, database_blob( key.pub().key_to_bin()[10:]), signature='\x00' * 64, skip_key_check=True) with open(filename, 'wb') as output_file: output_file.write(''.join(metadata_payload.serialized()))
def add_random_channel(self): """ Add a random channel to the metadata store. :return: The metadata of the added channel. """ rand_key = default_eccrypto.generate_key('low') new_channel = self.session.lm.mds.ChannelMetadata( public_key=buffer(rand_key.pub().key_to_bin()), title='test', tags='test') new_channel.sign(rand_key) return new_channel
def test_store_clock(self): my_key = default_eccrypto.generate_key(u"curve25519") mds2 = MetadataStore(os.path.join(self.session_base_dir, 'test.db'), self.session_base_dir, my_key) tick = mds2.clock.tick() mds2.shutdown() mds2 = MetadataStore(os.path.join(self.session_base_dir, 'test.db'), self.session_base_dir, my_key) self.assertEqual(mds2.clock.clock, tick) mds2.shutdown()
def test_list_contents(self): """ Test whether a correct list with channel content is returned from the database """ pub_key1 = default_eccrypto.generate_key('low').pub().key_to_bin() pub_key2 = default_eccrypto.generate_key('low').pub().key_to_bin() channel1 = self.mds.ChannelMetadata(public_key=pub_key1) self.mds.TorrentMetadata.from_dict( dict(self.torrent_template, public_key=pub_key1)) channel2 = self.mds.ChannelMetadata(public_key=pub_key2) self.mds.TorrentMetadata.from_dict( dict(self.torrent_template, public_key=pub_key2)) self.mds.TorrentMetadata.from_dict( dict(self.torrent_template, public_key=pub_key2)) self.assertEqual(1, len(channel1.contents_list)) self.assertEqual(2, len(channel2.contents_list)) self.assertEqual(2, channel2.contents_len)
def setUp(self): yield super(TestTorrentMetadata, self).setUp() self.torrent_template = { "title": "", "infohash": "", "torrent_date": datetime(1970, 1, 1), "tags": "video" } self.my_key = default_eccrypto.generate_key(u"curve25519") self.mds = MetadataStore(os.path.join(self.session_base_dir, 'test.db'), self.session_base_dir, self.my_key)
def test_list_contents(self): """ Test whether a correct list with channel content is returned from the database """ self.mds.ChannelNode._my_key = default_eccrypto.generate_key('low') channel1 = self.mds.ChannelMetadata( infohash=str(random.getrandbits(160))) self.mds.TorrentMetadata.from_dict(dict(self.torrent_template)) self.mds.ChannelNode._my_key = default_eccrypto.generate_key('low') channel2 = self.mds.ChannelMetadata( infohash=str(random.getrandbits(160))) self.mds.TorrentMetadata.from_dict( dict(self.torrent_template, infohash="1")) self.mds.TorrentMetadata.from_dict( dict(self.torrent_template, infohash="2")) self.assertEqual(1, len(channel1.contents_list)) self.assertEqual(2, len(channel2.contents_list)) self.assertEqual(2, channel2.contents_len)
def add_random_channel(self): """ Add a random channel to the metadata store. :return: The metadata of the added channel. """ rand_key = default_eccrypto.generate_key('low') new_channel = self.session.lm.mds.ChannelMetadata(public_key=buffer( rand_key.pub().key_to_bin()), title='test', tags='test') new_channel.sign(rand_key) return new_channel
def setUp(self): yield super(TestContentRepository, self).setUp() self.my_key = default_eccrypto.generate_key(u"curve25519") mds = MetadataStore(':memory:', self.session_base_dir, self.my_key) self.content_repository = ContentRepository(mds) # Add some content to the metadata database with db_session: mds.ChannelMetadata.create_channel('test', 'test') for torrent_ind in xrange(5): torrent = mds.TorrentMetadata(title='torrent%d' % torrent_ind, infohash=('%d' % torrent_ind) * 20) torrent.health.seeders = torrent_ind + 1
def setUp(self): yield super(TestTorrentMetadata, self).setUp() self.torrent_template = { "title": "", "infohash": "", "torrent_date": datetime(1970, 1, 1), "tags": "video" } self.my_key = default_eccrypto.generate_key(u"curve25519") self.mds = MetadataStore( os.path.join(self.session_base_dir, 'test.db'), self.session_base_dir, self.my_key)
def test_strategy_one_peer(self): """ If we have one peer, we should send it our channel views and inspect our download queue. """ self.community.get_peers_return = [ Peer(default_eccrypto.generate_key(u"very-low")) ] self.strategy.take_step() self.assertEqual(1, len(self.community.send_random_to_called)) self.assertEqual(self.community.get_peers_return[0], self.community.send_random_to_called[0])
def test_new_db_version_ok(self): pony_db = os.path.join(self.session_base_dir, 'pony.db') my_key = default_eccrypto.generate_key(u"curve25519") mds = MetadataStore(pony_db, self.session_base_dir, my_key) mds.shutdown() self.assertTrue(new_db_version_ok(pony_db)) connection = sqlite3.connect(pony_db) with connection: cursor = connection.cursor() cursor.execute("UPDATE MiscData SET value = 12313512 WHERE name == 'db_version'") self.assertFalse(new_db_version_ok(pony_db))
def test_already_upgraded(self): pony_db = os.path.join(self.session_base_dir, 'pony.db') my_key = default_eccrypto.generate_key(u"curve25519") mds = MetadataStore(pony_db, self.session_base_dir, my_key) mds.shutdown() self.assertFalse(already_upgraded(pony_db)) mds = MetadataStore(pony_db, self.session_base_dir, my_key) with db_session: mds.MiscData(name=CONVERSION_FROM_72, value=CONVERSION_FINISHED) mds.shutdown() self.assertTrue(already_upgraded(pony_db))
def test_new_db_version_ok(self): pony_db = os.path.join(self.session_base_dir, 'pony.db') my_key = default_eccrypto.generate_key(u"curve25519") mds = MetadataStore(pony_db, self.session_base_dir, my_key) mds.shutdown() self.assertTrue(new_db_version_ok(pony_db)) connection = sqlite3.connect(pony_db) with connection: cursor = connection.cursor() cursor.execute( "UPDATE MiscData SET value = 12313512 WHERE name == 'db_version'" ) self.assertFalse(new_db_version_ok(pony_db))
def setUp(self): yield super(TestGigaChannelManager, self).setUp() self.torrent_template = { "title": "", "infohash": "", "torrent_date": datetime(1970, 1, 1), "tags": "video" } my_key = default_eccrypto.generate_key(u"curve25519") self.mock_session = MockObject() self.mock_session.lm = MockObject() self.mock_session.lm.mds = MetadataStore(":memory:", self.session_base_dir, my_key) self.chanman = GigaChannelManager(self.mock_session) self.torrents_added = 0
def setUp(self): yield super(BaseTestMetadataEndpoint, self).setUp() self.infohashes = [] torrents_per_channel = 5 # Add a few channels with db_session: for ind in xrange(10): self.session.lm.mds.ChannelNode._my_key = default_eccrypto.generate_key('curve25519') _ = self.session.lm.mds.ChannelMetadata(title='channel%d' % ind, subscribed=(ind % 2 == 0), num_entries=torrents_per_channel, infohash=random_infohash()) for torrent_ind in xrange(torrents_per_channel): rand_infohash = random_infohash() self.infohashes.append(rand_infohash) _ = self.session.lm.mds.TorrentMetadata(title='torrent%d' % torrent_ind, infohash=rand_infohash)
def setUp(self): yield super(TestStatisticsEndpoint, self).setUp() self.mock_ipv8 = MockIPv8( u"low", TrustChainCommunity, working_directory=self.session.config.get_state_dir()) self.mock_ipv8.overlays = [self.mock_ipv8.overlay] self.mock_ipv8.endpoint.bytes_up = 100 self.mock_ipv8.endpoint.bytes_down = 20 self.session.lm.ipv8 = self.mock_ipv8 self.session.config.set_ipv8_enabled(True) my_key = default_eccrypto.generate_key(u"curve25519") self.session.lm.mds = MetadataStore( os.path.join(self.session_base_dir, 'test.db'), self.session_base_dir, my_key)
def setUp(self): yield super(BaseTestMetadataEndpoint, self).setUp() self.infohashes = [] torrents_per_channel = 5 # Add a few channels with db_session: for ind in xrange(10): self.session.lm.mds.ChannelNode._my_key = default_eccrypto.generate_key( 'curve25519') _ = self.session.lm.mds.ChannelMetadata( title='channel%d' % ind, subscribed=(ind % 2 == 0), num_entries=torrents_per_channel, infohash=random_infohash()) for torrent_ind in xrange(torrents_per_channel): rand_infohash = random_infohash() self.infohashes.append(rand_infohash) _ = self.session.lm.mds.TorrentMetadata( title='torrent%d' % torrent_ind, infohash=rand_infohash)
def test_get_entries(self): """ Test whether we can get torrents """ # First we create a few channels and add some torrents to these channels tlist = [] for ind in xrange(5): self.mds.ChannelNode._my_key = default_eccrypto.generate_key( 'curve25519') _ = self.mds.ChannelMetadata(title='channel%d' % ind, subscribed=(ind % 2 == 0), infohash=str(random.getrandbits(160))) tlist.extend([ self.mds.TorrentMetadata(title='torrent%d' % torrent_ind, infohash=str(random.getrandbits(160))) for torrent_ind in xrange(5) ]) tlist[-1].xxx = 1 tlist[-2].status = TODELETE torrents, count = self.mds.TorrentMetadata.get_entries(first=1, last=5) self.assertEqual(5, len(torrents)) self.assertEqual(25, count) # Test fetching torrents in a channel channel_pk = self.mds.ChannelNode._my_key.pub().key_to_bin()[10:] torrents, count = self.mds.TorrentMetadata.get_entries( first=1, last=10, sort_by='title', channel_pk=channel_pk) self.assertEqual(5, len(torrents)) self.assertEqual(5, count) torrents, count = self.mds.TorrentMetadata.get_entries( channel_pk=channel_pk, hide_xxx=True, exclude_deleted=True)[:] self.assertListEqual(tlist[-5:-2], list(torrents)) self.assertEqual(count, 3)
def setUp(self): yield super(TestMetadata, self).setUp() self.my_key = default_eccrypto.generate_key(u"curve25519") self.mds = MetadataStore(':memory:', self.session_base_dir, self.my_key)
def setUp(self): super(TestPopularityCommunity, self).setUp() self.shared_key = default_eccrypto.generate_key(u"curve25519") self.initialize(PopularityCommunity, self.NUM_NODES)
def _generate_peer(): return Peer(default_eccrypto.generate_key(u"very-low"))
def setUp(self): yield super(TestMetadataStore, self).setUp() my_key = default_eccrypto.generate_key(u"curve25519") self.mds = MetadataStore(":memory:", self.session_base_dir, my_key)
from datetime import datetime from pony.orm import db_session from Tribler.Core.Modules.MetadataStore.OrmBindings.channel_node import NEW from Tribler.Core.Modules.MetadataStore.store import MetadataStore from Tribler.Core.TorrentDef import TorrentDef from Tribler.Test.Core.Modules.MetadataStore.test_channel_download import CHANNEL_METADATA, CHANNEL_METADATA_UPDATED, \ CHANNEL_TORRENT, CHANNEL_TORRENT_UPDATED from Tribler.Test.common import TORRENT_UBUNTU_FILE, TORRENT_VIDEO_FILE from Tribler.pyipv8.ipv8.keyvault.crypto import default_eccrypto DATA_DIR = os.path.join(os.path.abspath(os.path.dirname(os.path.realpath(__file__))), '..', '..', 'data') SAMPLE_DIR = os.path.join(DATA_DIR, 'sample_channel') my_key = default_eccrypto.generate_key(u"curve25519") def gen_random_entry(): return { "title": "test entry " + str(random.randint(0, 1000000)), "infohash": str(random.getrandbits(160)), "torrent_date": datetime(1970, 1, 1), "size": 100 + random.randint(0, 10000), "tags": "video", "status": NEW } @db_session def gen_sample_channel(mds):
def make_wrong_payload(filename): key = default_eccrypto.generate_key(u"curve25519") metadata_payload = MetadataPayload(666, buffer(key.pub().key_to_bin()), datetime.utcnow(), 123) with open(filename, 'wb') as output_file: output_file.write(''.join(metadata_payload.serialized(key)))
from pony.orm import db_session from Tribler.Core.Modules.MetadataStore.OrmBindings.channel_node import NEW from Tribler.Core.Modules.MetadataStore.store import MetadataStore from Tribler.Core.TorrentDef import TorrentDef from Tribler.Test.Core.Modules.MetadataStore.test_channel_download import CHANNEL_METADATA, CHANNEL_METADATA_UPDATED, \ CHANNEL_TORRENT, CHANNEL_TORRENT_UPDATED from Tribler.Test.common import TORRENT_UBUNTU_FILE, TORRENT_VIDEO_FILE from Tribler.pyipv8.ipv8.keyvault.crypto import default_eccrypto DATA_DIR = os.path.join( os.path.abspath(os.path.dirname(os.path.realpath(__file__))), '..', '..', 'data') SAMPLE_DIR = os.path.join(DATA_DIR, 'sample_channel') my_key = default_eccrypto.generate_key(u"curve25519") def gen_random_entry(): return { "title": "test entry " + str(random.randint(0, 1000000)), "infohash": str(random.getrandbits(160)), "torrent_date": datetime(1970, 1, 1), "size": 100 + random.randint(0, 10000), "tags": "video", "status": NEW } @db_session def gen_sample_channel(mds):
def setUp(self): yield super(TestTorrentMetadata, self).setUp() self.my_key = default_eccrypto.generate_key(u"curve25519") self.mds = MetadataStore(':memory:', self.session_base_dir, self.my_key)
def test_key_mismatch_exception(self): mismatched_key = default_eccrypto.generate_key(u"curve25519") metadata = self.mds.ChannelNode.from_dict({}) self.assertRaises(KeysMismatchException, metadata.serialized, key=mismatched_key)
def setUp(self): yield super(TestMetadataStore, self).setUp() my_key = default_eccrypto.generate_key(u"curve25519") self.mds = MetadataStore(os.path.join(self.session_base_dir, 'test.db'), self.session_base_dir, my_key)