Peer info reader done

crates/librqbit/src/peer_binary_protocol/mod.rs

@@ -548,38 +548,6 @@ impl Request {
 
 #[cfg(test)]
 mod tests {
-    use std::{
-        fs::File,
-        io::{Read, Write},
-        net::SocketAddr,
-        str::FromStr,
-    };
-
-    use log::info;
-    use parking_lot::RwLock;
-    use tokio::sync::mpsc::UnboundedSender;
-
-    use crate::{
-        bencode_value::BencodeValue,
-        lengths::ceil_div_u64,
-        peer_binary_protocol::extended::ut_metadata::UtMetadata,
-        peer_connection::{PeerConnection, PeerConnectionHandler, WriterRequest},
-        peer_id::generate_peer_id,
-    };
-    use std::sync::Once;
-
-    static LOG_INIT: Once = std::sync::Once::new();
-
-    fn init_logging() {
-        LOG_INIT.call_once(pretty_env_logger::init)
-    }
-
-    fn decode_info_hash(hash_str: &str) -> [u8; 20] {
-        let mut hash_arr = [0u8; 20];
-        hex::decode_to_slice(hash_str, &mut hash_arr).unwrap();
-        hash_arr
-    }
-
     use super::*;
     #[test]
     fn test_handshake_serialize() {
@@ -628,107 +596,4 @@ mod tests {
             panic!("resources/test/extended-handshake.bin did not serialize exactly the same. Dumped to /tmp/test_deserialize_serialize_extended_is_same, you can compare with resources/test/extended-handshake.bin")
         }
     }
-
-    #[tokio::test]
-    async fn test_connect_to_local_qbittorrent() {
-        init_logging();
-
-        struct Handler {
-            ehandshake: RwLock<Option<ExtendedHandshake<ByteString>>>,
-            tx: UnboundedSender<WriterRequest>,
-        }
-
-        impl PeerConnectionHandler for Handler {
-            fn get_have_bytes(&self) -> u64 {
-                0
-            }
-
-            fn serialize_bitfield_message_to_buf(&self, _buf: &mut Vec<u8>) -> Option<usize> {
-                None
-            }
-
-            fn on_handshake(&self, handshake: Handshake) {
-                info!("received handshake: {:?}", handshake)
-            }
-
-            fn on_received_message(&self, msg: Message<ByteBuf<'_>>) -> anyhow::Result<()> {
-                info!("received message: {:?}", msg);
-
-                if let Message::Extended(ExtendedMessage::UtMetadata(UtMetadata::Data {
-                    piece,
-                    total_size,
-                    data,
-                })) = msg
-                {
-                    // this just assumes piece come in the order requested.
-                    let mut f = std::fs::OpenOptions::new()
-                        .create(true)
-                        .append(true)
-                        .open("/tmp/torrent")
-                        .unwrap();
-                    f.write_all(&data).unwrap();
-
-                    // test if it's the last piece
-                    if data.len() < CHUNK_SIZE as usize {
-                        let mut buf = Vec::new();
-                        let mut f = File::open("/tmp/torrent").unwrap();
-                        f.read_to_end(&mut buf).unwrap();
-
-                        // let torrent: TorrentMetaV1Borrowed =
-                        //     crate::torrent_metainfo::torrent_from_bytes(&buf).unwrap();
-                        let torrent: BencodeValue<ByteBuf> =
-                            crate::bencode_value::dyn_from_bytes(&buf).unwrap();
-                        dbg!(torrent);
-                    }
-                }
-                Ok(())
-            }
-
-            fn on_uploaded_bytes(&self, _bytes: u32) {}
-
-            fn read_chunk(&self, _chunk: &ChunkInfo, _buf: &mut [u8]) -> anyhow::Result<()> {
-                panic!("dude, why are you requesting chunks")
-            }
-
-            fn on_extended_handshake(&self, extended_handshake: &ExtendedHandshake<ByteBuf>) {
-                self.ehandshake
-                    .write()
-                    .replace(extended_handshake.clone_to_owned());
-                self.tx
-                    .send(WriterRequest::Message(Message::Unchoke))
-                    .unwrap();
-                self.tx
-                    .send(WriterRequest::Message(Message::Interested))
-                    .unwrap();
-
-                let total_metadata_chunks = ceil_div_u64(
-                    extended_handshake.metadata_size.unwrap() as u64,
-                    CHUNK_SIZE as u64,
-                );
-
-                for i in 0..total_metadata_chunks {
-                    self.tx
-                        .send(WriterRequest::Message(Message::Extended(
-                            ExtendedMessage::UtMetadata(UtMetadata::Request(i as u32)),
-                        )))
-                        .unwrap()
-                }
-            }
-        }
-
-        let addr = SocketAddr::from_str("127.0.0.1:27311").unwrap();
-        let (tx, rx) = tokio::sync::mpsc::unbounded_channel();
-        let handler = Handler {
-            tx,
-            ehandshake: RwLock::new(None),
-        };
-        let peer_id = generate_peer_id();
-        let info_hash = decode_info_hash("9905f844e5d8787ecd5e08fb46b2eb0a42c131d7");
-
-        let conn = PeerConnection::new(addr, info_hash, peer_id, handler);
-
-        // tx.send(WriterRequest::Message(Message::Extended(ExtendedMessage)));
-
-        conn.manage_peer(rx).await.unwrap();
-    }
 }