Clean up testing::Handler::run().

src/proto/server/client.rs

@@ -88,10 +88,10 @@ impl Client {
         ip,
         password_md5_opt,
       })) => {
-        info!("Logged in successfully!");
-        info!("Message Of The Day: {}", motd);
-        info!("Public IP address: {}", ip);
-        info!("Password MD5: {:?}", password_md5_opt);
+        info!("Client: Logged in successfully!");
+        info!("Client: Message Of The Day: {}", motd);
+        info!("Client: Public IP address: {}", ip);
+        info!("Client: Password MD5: {:?}", password_md5_opt);
         Ok(())
       }
       Some(ServerResponse::LoginResponse(LoginResponse::LoginFail {

src/proto/server/testing.rs

@@ -48,8 +48,15 @@ impl Handler {
     }
   }
 
-  async fn run(mut self) -> io::Result<()> {
-    // TODO: Extract this to a method.
+  async fn send_response(
+    &mut self,
+    response: &ServerResponse,
+  ) -> io::Result<()> {
+    debug!("Handler: sending response: {:?}", response);
+    self.frame_stream.write(response).await
+  }
+
+  async fn handle_login(&mut self) -> io::Result<()> {
     match self.frame_stream.read().await? {
       Some(ServerRequest::LoginRequest(request)) => {
         info!("Handler: Received login request: {:?}", request);
@@ -73,23 +80,33 @@ impl Handler {
       ip: self.ipv4_address(),
       password_md5_opt: None,
     });
-    self.frame_stream.write(&response).await?;
+    self.send_response(&response).await
+  }
 
-    while let Some(request) = self.frame_stream.read().await? {
-      // TODO: Extract this.
-      info!("Handler: received request: {:?}", request);
-      match request {
-        ServerRequest::UserStatusRequest(UserStatusRequest { user_name }) => {
-          let entry = self.user_status_map.lock().get(&user_name);
-          if let Some(response) = entry {
-            let response = ServerResponse::UserStatusResponse(response);
-            self.frame_stream.write(&response).await?;
-          }
-        }
-        _ => {
-          warn!("Handler: unhandled request: {:?}", request);
+  async fn handle_request(&mut self, request: ServerRequest) -> io::Result<()> {
+    debug!("Handler: received request: {:?}", request);
+
+    match request {
+      ServerRequest::UserStatusRequest(UserStatusRequest { user_name }) => {
+        let entry = self.user_status_map.lock().get(&user_name);
+        if let Some(response) = entry {
+          let response = ServerResponse::UserStatusResponse(response);
+          self.send_response(&response).await?;
         }
       }
+      _ => {
+        warn!("Handler: unhandled request: {:?}", request);
+      }
+    }
+
+    Ok(())
+  }
+
+  async fn run(mut self) -> io::Result<()> {
+    self.handle_login().await?;
+
+    while let Some(request) = self.frame_stream.read().await? {
+      self.handle_request(request).await?;
     }
 
     info!("Handler: client disconnecting, shutting down");