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_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_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_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 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 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(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 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_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 setUp(self):
super(TestPopularityCommunity, self).setUp()
self.shared_key = default_eccrypto.generate_key(u"curve25519")
self.initialize(PopularityCommunity, self.NUM_NODES)
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)
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)))
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)
