Skip to content

Commit df829e2

Browse files
ibrizsabinibrizsabin
authored
Merge branch 'feat/sui-xcall-contracts' into 306-add-sui-test-workflow
2 parents 9d1c4ee + bc81e78 commit df829e2

15 files changed

+1961
-89
lines changed

‎contracts/cosmwasm-vm/cw-xcall-lib/src/message/call_message.rs

+22
Original file line numberDiff line numberDiff line change
@@ -35,3 +35,25 @@ impl IMessage for CallMessage {
3535
Ok(rlp::encode(self).to_vec())
3636
}
3737
}
38+
39+
#[cfg(test)]
40+
mod tests {
41+
use super::*;
42+
43+
use rlp::Rlp;
44+
45+
#[test]
46+
fn test_call_message() {
47+
let msg = CallMessage {
48+
data: vec![1, 2, 3],
49+
};
50+
51+
let encoded = msg.rlp_bytes().to_vec();
52+
let decoded = CallMessage::decode(&Rlp::new(&encoded)).unwrap();
53+
54+
assert_eq!(msg, decoded);
55+
assert_eq!(msg.rollback(), None);
56+
assert_eq!(msg.data(), msg.data);
57+
assert_eq!(msg.to_bytes().unwrap(), encoded)
58+
}
59+
}

‎contracts/cosmwasm-vm/cw-xcall-lib/src/message/call_message_persisted.rs

+22
Original file line numberDiff line numberDiff line change
@@ -34,3 +34,25 @@ impl IMessage for CallMessagePersisted {
3434
Ok(rlp::encode(self).to_vec())
3535
}
3636
}
37+
38+
#[cfg(test)]
39+
mod tests {
40+
use common::rlp::Rlp;
41+
42+
use super::*;
43+
44+
#[test]
45+
fn test_call_message_persisted() {
46+
let msg = CallMessagePersisted {
47+
data: vec![1, 2, 3],
48+
};
49+
50+
let encoded = msg.rlp_bytes().to_vec();
51+
let decoded = CallMessagePersisted::decode(&Rlp::new(&encoded)).unwrap();
52+
53+
assert_eq!(msg, decoded);
54+
assert_eq!(msg.rollback(), None);
55+
assert_eq!(msg.data(), msg.data);
56+
assert_eq!(msg.to_bytes().unwrap(), encoded)
57+
}
58+
}

‎contracts/cosmwasm-vm/cw-xcall-lib/src/message/call_message_rollback.rs

+23
Original file line numberDiff line numberDiff line change
@@ -40,3 +40,26 @@ impl IMessage for CallMessageWithRollback {
4040
Ok(rlp::encode(self).to_vec())
4141
}
4242
}
43+
44+
#[cfg(test)]
45+
mod tests {
46+
use common::rlp::Rlp;
47+
48+
use super::*;
49+
50+
#[test]
51+
fn test_call_message_with_rollback() {
52+
let msg = CallMessageWithRollback {
53+
data: vec![1, 2, 3],
54+
rollback: vec![1, 2, 3],
55+
};
56+
57+
let encoded = msg.rlp_bytes().to_vec();
58+
let decoded = CallMessageWithRollback::decode(&Rlp::new(&encoded)).unwrap();
59+
60+
assert_eq!(msg, decoded);
61+
assert_eq!(msg.rollback().unwrap(), msg.rollback);
62+
assert_eq!(msg.data(), msg.data);
63+
assert_eq!(msg.to_bytes().unwrap(), encoded)
64+
}
65+
}

‎contracts/cosmwasm-vm/cw-xcall-lib/src/message/envelope.rs

+46-25
Original file line numberDiff line numberDiff line change
@@ -81,43 +81,64 @@ mod tests {
8181
use super::*;
8282

8383
#[test]
84-
fn test_encoding_decoding_envelope_call_message() {
85-
// Create a sample Envelope
86-
let message = AnyMessage::CallMessage(CallMessage {
84+
fn test_envelope_call_message() {
85+
let msg = AnyMessage::CallMessage(CallMessage {
8786
data: vec![1, 2, 3],
8887
});
89-
let sources = vec!["source1".to_string(), "source2".to_string()];
90-
let destinations = vec!["dest1".to_string(), "dest2".to_string()];
91-
let envelope = Envelope::new(message, sources, destinations);
92-
let encoded_data = rlp::encode(&envelope).to_vec();
88+
let sources = vec!["src".to_string()];
89+
let destinations = vec!["dst".to_string()];
90+
let envelope = Envelope::new(msg.clone(), sources, destinations);
9391

94-
assert_eq!(
95-
"e50085c483010203d087736f757263653187736f7572636532cc856465737431856465737432",
96-
hex::encode(&encoded_data)
97-
);
98-
let decoded: Envelope = rlp::decode(&encoded_data).unwrap();
92+
let encoded = envelope.rlp_bytes().to_vec();
93+
let decoded = Envelope::decode(&rlp::Rlp::new(&encoded)).unwrap();
94+
assert_eq!(envelope, decoded);
95+
96+
let encoded = msg.to_bytes().unwrap();
97+
let decoded = decode_message(MessageType::CallMessage, encoded.clone()).unwrap();
98+
assert_eq!(decoded.rollback(), None);
99+
assert_eq!(decoded.data(), vec![1, 2, 3]);
100+
assert_eq!(decoded.to_bytes().unwrap(), encoded)
101+
}
102+
103+
#[test]
104+
fn test_envelope_call_message_persisted() {
105+
let msg = AnyMessage::CallMessagePersisted(CallMessagePersisted {
106+
data: vec![1, 2, 3],
107+
});
108+
let sources = vec!["src".to_string()];
109+
let destinations = vec!["dst".to_string()];
110+
let envelope = Envelope::new(msg.clone(), sources, destinations);
99111

112+
let encoded = envelope.rlp_bytes().to_vec();
113+
let decoded = Envelope::decode(&rlp::Rlp::new(&encoded)).unwrap();
100114
assert_eq!(envelope, decoded);
115+
116+
let encoded = msg.to_bytes().unwrap();
117+
let decoded = decode_message(MessageType::CallMessagePersisted, encoded.clone()).unwrap();
118+
assert_eq!(decoded.rollback(), None);
119+
assert_eq!(decoded.data(), vec![1, 2, 3]);
120+
assert_eq!(decoded.to_bytes().unwrap(), encoded)
101121
}
102122

103123
#[test]
104-
fn test_encoding_decoding_envelope_call_message_rollback() {
105-
// Create a sample Envelope
106-
let message = AnyMessage::CallMessageWithRollback(CallMessageWithRollback {
124+
fn test_envelope_call_message_with_rollback() {
125+
let msg = AnyMessage::CallMessageWithRollback(CallMessageWithRollback {
107126
data: vec![1, 2, 3],
108127
rollback: vec![1, 2, 3],
109128
});
110-
let sources = vec!["source1".to_string(), "source2".to_string()];
111-
let destinations = vec!["dest1".to_string(), "dest2".to_string()];
112-
let envelope = Envelope::new(message, sources, destinations);
113-
let encoded_data = rlp::encode(&envelope).to_vec();
114-
115-
assert_eq!(
116-
"e90189c88301020383010203d087736f757263653187736f7572636532cc856465737431856465737432",
117-
hex::encode(&encoded_data)
118-
);
119-
let decoded: Envelope = rlp::decode(&encoded_data).unwrap();
129+
let sources = vec!["src".to_string()];
130+
let destinations = vec!["dst".to_string()];
131+
let envelope = Envelope::new(msg.clone(), sources, destinations);
120132

133+
let encoded = envelope.rlp_bytes().to_vec();
134+
let decoded = Envelope::decode(&rlp::Rlp::new(&encoded)).unwrap();
121135
assert_eq!(envelope, decoded);
136+
137+
let encoded = msg.to_bytes().unwrap();
138+
let decoded =
139+
decode_message(MessageType::CallMessageWithRollback, encoded.clone()).unwrap();
140+
assert_eq!(decoded.rollback(), Some(vec![1, 2, 3]));
141+
assert_eq!(decoded.data(), vec![1, 2, 3]);
142+
assert_eq!(decoded.to_bytes().unwrap(), encoded)
122143
}
123144
}

‎contracts/cosmwasm-vm/cw-xcall-lib/src/message/msg_type.rs

+34
Original file line numberDiff line numberDiff line change
@@ -36,3 +36,37 @@ impl MessageType {
3636
MessageType::from(val)
3737
}
3838
}
39+
40+
#[cfg(test)]
41+
mod tests {
42+
use crate::message::msg_type::MessageType;
43+
44+
#[test]
45+
fn test_message_type_for_u8() {
46+
assert_eq!(MessageType::from(MessageType::CallMessage), 0.into());
47+
assert_eq!(
48+
MessageType::from(MessageType::CallMessagePersisted),
49+
2.into()
50+
);
51+
assert_eq!(
52+
MessageType::from(MessageType::CallMessageWithRollback),
53+
1.into()
54+
)
55+
}
56+
57+
#[test]
58+
fn test_message_type_from_int() {
59+
assert_eq!(MessageType::from_int(0), MessageType::CallMessage);
60+
assert_eq!(
61+
MessageType::from_int(1),
62+
MessageType::CallMessageWithRollback
63+
);
64+
assert_eq!(MessageType::from_int(2), MessageType::CallMessagePersisted)
65+
}
66+
67+
#[test]
68+
#[should_panic(expected = "unsupported message type")]
69+
fn test_message_type_from_int_fail() {
70+
MessageType::from_int(4);
71+
}
72+
}

‎contracts/cosmwasm-vm/cw-xcall/src/contract.rs

-29
Original file line numberDiff line numberDiff line change
@@ -244,32 +244,3 @@ impl<'a> CwCallService<'a> {
244244
Ok(na)
245245
}
246246
}
247-
248-
#[cfg(test)]
249-
mod tests {
250-
use cosmwasm_std::testing::{mock_dependencies, mock_env};
251-
use cw2::{get_contract_version, ContractVersion};
252-
253-
use crate::{
254-
contract::{CONTRACT_NAME, CONTRACT_VERSION},
255-
state::CwCallService,
256-
MigrateMsg,
257-
};
258-
259-
#[test]
260-
fn test_migrate() {
261-
let mut mock_deps = mock_dependencies();
262-
let env = mock_env();
263-
264-
let contract = CwCallService::default();
265-
let result = contract.migrate(mock_deps.as_mut(), env, MigrateMsg {});
266-
assert!(result.is_ok());
267-
let expected = ContractVersion {
268-
contract: CONTRACT_NAME.to_string(),
269-
version: CONTRACT_VERSION.to_string(),
270-
};
271-
let version = get_contract_version(&mock_deps.storage).unwrap();
272-
println!("{version:?}");
273-
assert_eq!(expected, version);
274-
}
275-
}

0 commit comments

Comments
 (0)