def test_add_deprecated_magnet_link(self):
ses = lt.session()
atp = lt.add_torrent_params()
atp.info_hashes = lt.info_hash_t(lt.sha1_hash(b"a" * 20))
h = ses.add_torrent(atp)
self.assertTrue(
h.status().info_hashes == lt.info_hash_t(lt.sha1_hash(b"a" * 20)))
def magnet_atp(protos: tuple[conftest.Proto, conftest.Proto],
atp: lt.add_torrent_params) -> lt.add_torrent_params:
magnet_proto, _ = protos
assert atp.ti is not None
magnet = lt.parse_magnet_uri(lt.make_magnet_uri(atp.ti))
if not (magnet_proto & conftest.V1):
magnet.info_hashes = lt.info_hash_t(magnet.info_hashes.v2)
elif not (magnet_proto & conftest.V2):
magnet.info_hashes = lt.info_hash_t(magnet.info_hashes.v1)
return magnet
def test_sha1(self) -> None:
sha1 = lt.sha1_hash(lib.get_random_bytes(20))
ih = lt.info_hash_t(sha1)
self.assertEqual(ih.get(lt.protocol_version.V1), sha1)
self.assertEqual(ih.get(lt.protocol_version.V2), lt.sha1_hash())
self.assertEqual(ih.get_best(), sha1)
self.assertTrue(ih.has(lt.protocol_version.V1))
self.assertFalse(ih.has(lt.protocol_version.V2))
self.assertTrue(ih.has_v1())
self.assertFalse(ih.has_v2())
self.assertEqual(ih.v1, sha1)
self.assertEqual(ih.v2, lt.sha256_hash())
self.assertEqual(ih, lt.info_hash_t(sha1))
self.assertEqual(hash(ih), hash(lt.info_hash_t(sha1)))
self.assertNotEqual(ih, lt.info_hash_t())
def test_torrent_info_sha1_overload(self):
ti = lt.torrent_info(lt.info_hash_t(lt.sha1_hash(b'a' * 20)))
self.assertEqual(ti.info_hash(), lt.sha1_hash(b'a' * 20))
self.assertEqual(ti.info_hashes().v1, lt.sha1_hash(b'a' * 20))
ti_copy = lt.torrent_info(ti)
self.assertEqual(ti_copy.info_hash(), lt.sha1_hash(b'a' * 20))
self.assertEqual(ti_copy.info_hashes().v1, lt.sha1_hash(b'a' * 20))
def test_sha256(self) -> None:
sha256 = lt.sha256_hash(lib.get_random_bytes(32))
sha256_trunc = lt.sha1_hash(sha256.to_bytes()[:20])
ih = lt.info_hash_t(sha256)
self.assertEqual(ih.get(lt.protocol_version.V1), lt.sha1_hash())
self.assertEqual(ih.get(lt.protocol_version.V2), sha256_trunc)
self.assertEqual(ih.get_best(), sha256_trunc)
self.assertFalse(ih.has(lt.protocol_version.V1))
self.assertTrue(ih.has(lt.protocol_version.V2))
self.assertFalse(ih.has_v1())
self.assertTrue(ih.has_v2())
self.assertEqual(ih.v1, lt.sha1_hash())
self.assertEqual(ih.v2, sha256)
self.assertEqual(ih, lt.info_hash_t(sha256))
self.assertEqual(hash(ih), hash(lt.info_hash_t(sha256)))
self.assertNotEqual(ih, lt.info_hash_t())
def test_dual(self) -> None:
sha1 = lt.sha1_hash(lib.get_random_bytes(20))
sha256 = lt.sha256_hash(lib.get_random_bytes(32)) # type: ignore
ih = lt.info_hash_t(sha1, sha256) # type: ignore
self.assertEqual(ih.get(lt.protocol_version.V1), sha1)
self.assertEqual(ih.get(lt.protocol_version.V2), sha256)
self.assertEqual(ih.get_best(), sha256)
self.assertTrue(ih.has(lt.protocol_version.V1))
self.assertTrue(ih.has(lt.protocol_version.V2))
self.assertTrue(ih.has_v1())
self.assertTrue(ih.has_v2())
self.assertEqual(ih.v1, sha1)
self.assertEqual(ih.v2, sha256)
self.assertEqual(ih, lt.info_hash_t(sha1, sha256)) # type: ignore
self.assertEqual(hash(ih),
hash(lt.info_hash_t(sha1, sha256))) # type: ignore
self.assertNotEqual(ih, lt.info_hash_t())
def test_torrent_handle(self) -> None:
atp = lt.add_torrent_params()
atp.info_hashes = lt.info_hash_t(
lt.sha1_hash(bytes.fromhex(self.info_hash_sha1)))
session = lt.session(lib.get_isolated_settings())
with tempfile.TemporaryDirectory() as path:
atp.save_path = path
handle = session.add_torrent(atp)
uri = lt.make_magnet_uri(handle)
self.assertEqual(uri, f"magnet:?xt=urn:btih:{self.info_hash_sha1}")
def test_set_metadata(self) -> None:
self.session.remove_torrent(self.handle)
self.atp.ti = None
self.atp.info_hashes = lt.info_hash_t(self.torrent.sha1_hash)
handle = self.session.add_torrent(self.atp)
with self.assertWarns(DeprecationWarning):
self.assertFalse(handle.has_metadata())
handle.set_metadata(lt.bencode(self.torrent.info))
with self.assertWarns(DeprecationWarning):
self.assertTrue(handle.has_metadata())
def test_info_hash(self):
s1 = lt.sha1_hash(b'a' * 20)
s2 = lt.sha256_hash(b'b' * 32)
ih1 = lt.info_hash_t(s1)
self.assertTrue(ih1.has_v1())
self.assertFalse(ih1.has_v2())
self.assertEqual(ih1.v1, s1)
ih2 = lt.info_hash_t(s2)
self.assertFalse(ih2.has_v1())
self.assertTrue(ih2.has_v2())
self.assertEqual(ih2.v2, s2)
ih12 = lt.info_hash_t(s1, s2)
self.assertTrue(ih12.has_v1())
self.assertTrue(ih12.has_v2())
self.assertEqual(ih12.v1, s1)
self.assertEqual(ih12.v2, s2)
self.assertNotEqual(hash(ih1), hash(ih2))
self.assertNotEqual(hash(ih1), hash(ih12))
self.assertEqual(hash(ih1), hash(lt.info_hash_t(s1)))
self.assertEqual(hash(ih2), hash(lt.info_hash_t(s2)))
self.assertEqual(hash(ih12), hash(lt.info_hash_t(s1, s2)))
def test_add_torrent_info_hash(self):
s = lt.session(settings)
h = s.add_torrent({
'info_hash': b'a' * 20,
'info_hashes': b'a' * 32,
'save_path': '.'
})
time.sleep(1)
alerts = s.pop_alerts()
while len(alerts) > 0:
a = alerts.pop(0)
print(a)
self.assertTrue(h.is_valid())
self.assertEqual(
h.status().info_hashes,
lt.info_hash_t(lt.sha1_hash(b'a' * 20), lt.sha256_hash(b'a' * 32)))
def info_hashes(self) -> lt.info_hash_t:
return lt.info_hash_t(self.sha1_hash)
def info_hashes(info: Dict[bytes, Any]) -> lt.info_hash_t:
return lt.info_hash_t(lt.sha1_hash(
hashlib.sha1(lt.bencode(info)).digest()))
async def test_is_private_bad(configured: bool) -> None:
with pytest.raises(KeyError):
await torrent_info.is_private(lt.info_hash_t(lt.sha1_hash(b"a" * 20)))
def test_from_orm_v1(self) -> None:
ih = lt.info_hash_t(lt.sha1_hash(b"\xaa" * 20))
info_hashes = ltmodels.InfoHashes.from_orm(ih)
self.assertEqual(info_hashes, ltmodels.InfoHashes(v1="aa" * 20))
def test_from_orm_v2(self) -> None:
ih = lt.info_hash_t(lt.sha256_hash(b"\xbb" * 32))
info_hashes = ltmodels.InfoHashes.from_orm(ih)
self.assertEqual(info_hashes, ltmodels.InfoHashes(v2="bb" * 32))
def info_hashes() -> lt.info_hash_t:
return lt.info_hash_t(lt.sha1_hash(bytes(random.getrandbits(8) for _ in range(20))))
def info_hashes_from_digest(digest: bytes) -> lt.info_hash_t:
return lt.info_hash_t(hash_from_digest(digest))
async def test_map_file_bad_torrent(configured: bool) -> None:
# We should always get KeyError with an unknown torrent
with pytest.raises(KeyError):
await torrent_info.map_file(lt.info_hash_t(lt.sha1_hash(b"a" * 20)), 0)
def test_info_hash(self) -> None:
self.assertEqual(self.handle.info_hash(), self.torrent.sha1_hash)
self.assertEqual(
self.handle.info_hashes(), lt.info_hash_t(self.torrent.sha1_hash)
)
def test_info_hash(self) -> None:
sha1 = lt.sha1_hash(lib.get_random_bytes(20))
ti = lt.torrent_info(lt.info_hash_t(sha1))
self.assertEqual(ti.info_hashes(), lt.info_hash_t(sha1))
def test_info_hash(self) -> None:
self.assertFalse(self.ti.info_hash().is_all_zeros())
self.assertEqual(self.ti.info_hashes(),
lt.info_hash_t(self.ti.info_hash()))
def test_torrent_info_sha256_overload(self):
ti = lt.torrent_info(lt.info_hash_t(lt.sha256_hash(b'a' * 32)))
self.assertEqual(ti.info_hashes().v2, lt.sha256_hash(b'a' * 32))
ti_copy = lt.torrent_info(ti)
self.assertEqual(ti_copy.info_hashes().v2, lt.sha256_hash(b'a' * 32))
self.assertEqual(set(name_to_access_swarm.keys()), {"public"})
# The public swarm should be accessible to an arbitrary torrent
access = name_to_access_swarm["public"]
configure_public_swarm = await access(INFO_HASHES)
# The public ConfigureSwarm function should do nothing
atp = lt.add_torrent_params()
atp.info_hashes = INFO_HASHES
before = lt.write_resume_data(atp)
await configure_public_swarm(atp)
after = lt.write_resume_data(atp)
self.assertEqual(after, before)
INFO_HASHES = lt.info_hash_t(
lt.sha1_hash(bytes(random.getrandbits(8) for _ in range(20))))
TRACKER = "http://127.0.0.1:12345"
class TestWithPlugins(unittest.IsolatedAsyncioTestCase):
async def asyncSetUp(self) -> None:
await super().asyncSetUp()
caches.clear_all()
self.fake_eps = epfake.EntryPointFaker()
self.fake_eps.enable()
async def asyncTearDown(self) -> None:
await super().asyncTearDown()
self.fake_eps.disable()
caches.clear_all()
def test_sha1_hash_stable(self) -> None:
sha1 = lt.sha1_hash(lib.get_random_bytes(20))
ih = lt.info_hash_t(sha1)
self.assertEqual(hash(ih), hash(lt.info_hash_t(sha1)))
