test: add unit tests for PutOp and GetOp operations (#2223)

Co-authored-by: Claude <noreply@anthropic.com>

Author: sanity

crates/core/src/operations/get.rs

@@ -1647,3 +1647,215 @@ mod messages {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::message::Transaction;
+    use crate::operations::test_utils::{make_contract_key, make_peer};
+    use std::collections::HashSet;
+
+    fn make_get_op(state: Option<GetState>, result: Option<GetResult>) -> GetOp {
+        GetOp {
+            id: Transaction::new::<GetMsg>(),
+            state,
+            result,
+            stats: None,
+            upstream_addr: None,
+        }
+    }
+
+    // Tests for finalized() method
+    #[test]
+    fn get_op_finalized_when_finished_with_result() {
+        let key = make_contract_key(1);
+        let result = GetResult {
+            key,
+            state: WrappedState::new(vec![1, 2, 3]),
+            contract: None,
+        };
+        let op = make_get_op(Some(GetState::Finished { key }), Some(result));
+        assert!(
+            op.finalized(),
+            "GetOp should be finalized when state is Finished and result is present"
+        );
+    }
+
+    #[test]
+    fn get_op_not_finalized_when_finished_without_result() {
+        let key = make_contract_key(1);
+        let op = make_get_op(Some(GetState::Finished { key }), None);
+        assert!(
+            !op.finalized(),
+            "GetOp should not be finalized when state is Finished but result is None"
+        );
+    }
+
+    #[test]
+    fn get_op_not_finalized_when_received_request() {
+        let op = make_get_op(Some(GetState::ReceivedRequest { requester: None }), None);
+        assert!(
+            !op.finalized(),
+            "GetOp should not be finalized in ReceivedRequest state"
+        );
+    }
+
+    #[test]
+    fn get_op_not_finalized_when_state_is_none() {
+        let op = make_get_op(None, None);
+        assert!(
+            !op.finalized(),
+            "GetOp should not be finalized when state is None"
+        );
+    }
+
+    // Tests for to_host_result() method
+    #[test]
+    fn get_op_to_host_result_success_when_result_present() {
+        let key = make_contract_key(1);
+        let state_data = WrappedState::new(vec![1, 2, 3]);
+        let result = GetResult {
+            key,
+            state: state_data.clone(),
+            contract: None,
+        };
+        let op = make_get_op(Some(GetState::Finished { key }), Some(result));
+        let host_result = op.to_host_result();
+
+        assert!(
+            host_result.is_ok(),
+            "to_host_result should return Ok when result is present"
+        );
+
+        if let Ok(HostResponse::ContractResponse(
+            freenet_stdlib::client_api::ContractResponse::GetResponse {
+                key: returned_key,
+                state: returned_state,
+                ..
+            },
+        )) = host_result
+        {
+            assert_eq!(returned_key, key, "Returned key should match");
+            assert_eq!(returned_state, state_data, "Returned state should match");
+        } else {
+            panic!("Expected GetResponse");
+        }
+    }
+
+    #[test]
+    fn get_op_to_host_result_error_when_no_result() {
+        let op = make_get_op(Some(GetState::ReceivedRequest { requester: None }), None);
+        let result = op.to_host_result();
+        assert!(
+            result.is_err(),
+            "to_host_result should return Err when result is None"
+        );
+    }
+
+    // Tests for outcome() method - partial coverage since full stats require complex setup
+    #[test]
+    fn get_op_outcome_incomplete_without_stats() {
+        let key = make_contract_key(1);
+        let result = GetResult {
+            key,
+            state: WrappedState::new(vec![]),
+            contract: None,
+        };
+        let op = make_get_op(Some(GetState::Finished { key }), Some(result));
+        let outcome = op.outcome();
+
+        assert!(matches!(outcome, OpOutcome::Incomplete));
+    }
+
+    // Tests for GetMsg helper methods
+    #[test]
+    fn get_msg_target_addr_returns_socket_for_request_get() {
+        let target = make_peer(5000);
+        let msg = GetMsg::RequestGet {
+            id: Transaction::new::<GetMsg>(),
+            target: target.clone(),
+            key: make_contract_key(1),
+            fetch_contract: false,
+            skip_list: HashSet::new(),
+        };
+        assert_eq!(
+            msg.target_addr(),
+            target.socket_addr(),
+            "target_addr should return target's socket address for RequestGet"
+        );
+    }
+
+    #[test]
+    fn get_msg_target_addr_returns_socket_for_return_get() {
+        let target = make_peer(6000);
+        let msg = GetMsg::ReturnGet {
+            id: Transaction::new::<GetMsg>(),
+            key: make_contract_key(1),
+            value: StoreResponse {
+                state: None,
+                contract: None,
+            },
+            target: target.clone(),
+            skip_list: HashSet::new(),
+        };
+        assert_eq!(
+            msg.target_addr(),
+            target.socket_addr(),
+            "target_addr should return target's socket address for ReturnGet"
+        );
+    }
+
+    #[test]
+    fn get_msg_id_returns_transaction() {
+        let tx = Transaction::new::<GetMsg>();
+        let msg = GetMsg::RequestGet {
+            id: tx,
+            target: make_peer(5000),
+            key: make_contract_key(1),
+            fetch_contract: false,
+            skip_list: HashSet::new(),
+        };
+        assert_eq!(*msg.id(), tx, "id() should return the transaction ID");
+    }
+
+    #[test]
+    fn get_msg_display_formats_correctly() {
+        let tx = Transaction::new::<GetMsg>();
+        let msg = GetMsg::SeekNode {
+            id: tx,
+            key: make_contract_key(1),
+            fetch_contract: false,
+            target: make_peer(5000),
+            htl: 5,
+            skip_list: HashSet::new(),
+        };
+        let display = format!("{}", msg);
+        assert!(
+            display.contains("SeekNode"),
+            "Display should contain message type name"
+        );
+    }
+
+    // Tests for GetState Display
+    #[test]
+    fn get_state_display_received_request() {
+        let state = GetState::ReceivedRequest { requester: None };
+        let display = format!("{}", state);
+        assert!(
+            display.contains("ReceivedRequest"),
+            "Display should contain state name"
+        );
+    }
+
+    #[test]
+    fn get_state_display_finished() {
+        let state = GetState::Finished {
+            key: make_contract_key(1),
+        };
+        let display = format!("{}", state);
+        assert!(
+            display.contains("Finished"),
+            "Display should contain state name"
+        );
+    }
+}

crates/core/src/operations/mod.rs

@@ -20,6 +20,8 @@ pub(crate) mod connect;
 pub(crate) mod get;
 pub(crate) mod put;
 pub(crate) mod subscribe;
+#[cfg(test)]
+pub(crate) mod test_utils;
 pub(crate) mod update;
 
 pub(crate) trait Operation

crates/core/src/operations/put.rs

@@ -1744,3 +1744,166 @@ mod messages {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::message::Transaction;
+    use crate::operations::test_utils::{make_contract_key, make_peer};
+
+    fn make_put_op(state: Option<PutState>) -> PutOp {
+        PutOp {
+            id: Transaction::new::<PutMsg>(),
+            state,
+            upstream_addr: None,
+        }
+    }
+
+    // Tests for finalized() method
+    #[test]
+    fn put_op_finalized_when_state_is_none() {
+        let op = make_put_op(None);
+        assert!(
+            op.finalized(),
+            "PutOp should be finalized when state is None"
+        );
+    }
+
+    #[test]
+    fn put_op_finalized_when_state_is_finished() {
+        let op = make_put_op(Some(PutState::Finished {
+            key: make_contract_key(1),
+        }));
+        assert!(
+            op.finalized(),
+            "PutOp should be finalized when state is Finished"
+        );
+    }
+
+    #[test]
+    fn put_op_not_finalized_when_received_request() {
+        let op = make_put_op(Some(PutState::ReceivedRequest));
+        assert!(
+            !op.finalized(),
+            "PutOp should not be finalized in ReceivedRequest state"
+        );
+    }
+
+    #[test]
+    fn put_op_not_finalized_when_broadcast_ongoing() {
+        let op = make_put_op(Some(PutState::BroadcastOngoing));
+        assert!(
+            !op.finalized(),
+            "PutOp should not be finalized in BroadcastOngoing state"
+        );
+    }
+
+    // Tests for to_host_result() method
+    #[test]
+    fn put_op_to_host_result_success_when_finished() {
+        let key = make_contract_key(1);
+        let op = make_put_op(Some(PutState::Finished { key }));
+        let result = op.to_host_result();
+        assert!(
+            result.is_ok(),
+            "to_host_result should return Ok for Finished state"
+        );
+
+        if let Ok(HostResponse::ContractResponse(
+            freenet_stdlib::client_api::ContractResponse::PutResponse { key: returned_key },
+        )) = result
+        {
+            assert_eq!(returned_key, key, "Returned key should match");
+        } else {
+            panic!("Expected PutResponse");
+        }
+    }
+
+    #[test]
+    fn put_op_to_host_result_error_when_not_finished() {
+        let op = make_put_op(Some(PutState::ReceivedRequest));
+        let result = op.to_host_result();
+        assert!(
+            result.is_err(),
+            "to_host_result should return Err for non-Finished state"
+        );
+    }
+
+    #[test]
+    fn put_op_to_host_result_error_when_none() {
+        let op = make_put_op(None);
+        let result = op.to_host_result();
+        assert!(
+            result.is_err(),
+            "to_host_result should return Err when state is None"
+        );
+    }
+
+    // Tests for is_completed() trait method
+    #[test]
+    fn put_op_is_completed_when_finished() {
+        let op = make_put_op(Some(PutState::Finished {
+            key: make_contract_key(1),
+        }));
+        assert!(
+            op.is_completed(),
+            "is_completed should return true for Finished state"
+        );
+    }
+
+    #[test]
+    fn put_op_is_not_completed_when_in_progress() {
+        let op = make_put_op(Some(PutState::ReceivedRequest));
+        assert!(
+            !op.is_completed(),
+            "is_completed should return false for ReceivedRequest state"
+        );
+    }
+
+    // Tests for PutMsg helper methods
+    #[test]
+    fn put_msg_target_addr_returns_socket_for_successful_put() {
+        let target = make_peer(5000);
+        let origin = make_peer(6000);
+        let msg = PutMsg::SuccessfulPut {
+            id: Transaction::new::<PutMsg>(),
+            target: target.clone(),
+            key: make_contract_key(1),
+            origin,
+        };
+        assert_eq!(
+            msg.target_addr(),
+            target.socket_addr(),
+            "target_addr should return target's socket address for SuccessfulPut"
+        );
+    }
+
+    #[test]
+    fn put_msg_target_addr_returns_none_for_await_put() {
+        let msg = PutMsg::AwaitPut {
+            id: Transaction::new::<PutMsg>(),
+        };
+        assert!(
+            msg.target_addr().is_none(),
+            "target_addr should return None for AwaitPut message"
+        );
+    }
+
+    #[test]
+    fn put_msg_id_returns_transaction() {
+        let tx = Transaction::new::<PutMsg>();
+        let msg = PutMsg::AwaitPut { id: tx };
+        assert_eq!(*msg.id(), tx, "id() should return the transaction ID");
+    }
+
+    #[test]
+    fn put_msg_display_formats_correctly() {
+        let tx = Transaction::new::<PutMsg>();
+        let msg = PutMsg::AwaitPut { id: tx };
+        let display = format!("{}", msg);
+        assert!(
+            display.contains("AwaitPut"),
+            "Display should contain message type name"
+        );
+    }
+}