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)))