chain, store: Remove unnecessary Option wrapping in tests

lutter · lutter · commit bf740a9773df · 2026-03-06T14:20:01.000-08:00
diff --git a/chain/near/src/trigger.rs b/chain/near/src/trigger.rs
@@ -179,8 +179,8 @@ mod tests {
         let mut heap = BytesHeap::new(API_VERSION_0_0_5);
         let trigger = NearTrigger::Receipt(Arc::new(ReceiptWithOutcome {
             block: Arc::new(block()),
-            outcome: execution_outcome_with_id().unwrap(),
-            receipt: receipt().unwrap(),
+            outcome: execution_outcome_with_id(),
+            receipt: receipt(),
         }));
 
         let result = trigger
@@ -195,78 +195,78 @@ mod tests {
             header: Some(codec::BlockHeader {
                 height: 2,
                 prev_height: 1,
-                epoch_id: hash("01"),
-                next_epoch_id: hash("02"),
-                hash: hash("01"),
-                prev_hash: hash("00"),
-                prev_state_root: hash("bb00010203"),
-                chunk_receipts_root: hash("bb00010203"),
-                chunk_headers_root: hash("bb00010203"),
-                chunk_tx_root: hash("bb00010203"),
-                outcome_root: hash("cc00010203"),
+                epoch_id: Some(hash("01")),
+                next_epoch_id: Some(hash("02")),
+                hash: Some(hash("01")),
+                prev_hash: Some(hash("00")),
+                prev_state_root: Some(hash("bb00010203")),
+                chunk_receipts_root: Some(hash("bb00010203")),
+                chunk_headers_root: Some(hash("bb00010203")),
+                chunk_tx_root: Some(hash("bb00010203")),
+                outcome_root: Some(hash("cc00010203")),
                 chunks_included: 1,
-                challenges_root: hash("aa"),
+                challenges_root: Some(hash("aa")),
                 timestamp: 100,
                 timestamp_nanosec: 0,
-                random_value: hash("010203"),
+                random_value: Some(hash("010203")),
                 validator_proposals: vec![],
                 chunk_mask: vec![],
-                gas_price: big_int(10),
+                gas_price: Some(big_int(10)),
                 block_ordinal: 0,
-                total_supply: big_int(1_000),
+                total_supply: Some(big_int(1_000)),
                 challenges_result: vec![],
-                last_final_block: hash("00"),
+                last_final_block: Some(hash("00")),
                 last_final_block_height: 0,
-                last_ds_final_block: hash("00"),
+                last_ds_final_block: Some(hash("00")),
                 last_ds_final_block_height: 0,
-                next_bp_hash: hash("bb"),
-                block_merkle_root: hash("aa"),
+                next_bp_hash: Some(hash("bb")),
+                block_merkle_root: Some(hash("aa")),
                 epoch_sync_data_hash: vec![0x00, 0x01],
                 approvals: vec![],
-                signature: signature("00"),
+                signature: Some(signature("00")),
                 latest_protocol_version: 0,
             }),
-            chunk_headers: vec![chunk_header().unwrap()],
+            chunk_headers: vec![chunk_header()],
             shards: vec![codec::IndexerShard {
                 shard_id: 0,
                 chunk: Some(codec::IndexerChunk {
                     author: "near".to_string(),
-                    header: chunk_header(),
+                    header: Some(chunk_header()),
                     transactions: vec![codec::IndexerTransactionWithOutcome {
                         transaction: Some(codec::SignedTransaction {
                             signer_id: "signer".to_string(),
-                            public_key: public_key("aabb"),
+                            public_key: Some(public_key("aabb")),
                             nonce: 1,
                             receiver_id: "receiver".to_string(),
                             actions: vec![],
-                            signature: signature("ff"),
-                            hash: hash("bb"),
+                            signature: Some(signature("ff")),
+                            hash: Some(hash("bb")),
                         }),
                         outcome: Some(codec::IndexerExecutionOutcomeWithOptionalReceipt {
-                            execution_outcome: execution_outcome_with_id(),
-                            receipt: receipt(),
+                            execution_outcome: Some(execution_outcome_with_id()),
+                            receipt: Some(receipt()),
                         }),
                     }],
-                    receipts: vec![receipt().unwrap()],
+                    receipts: vec![receipt()],
                 }),
                 receipt_execution_outcomes: vec![codec::IndexerExecutionOutcomeWithReceipt {
-                    execution_outcome: execution_outcome_with_id(),
-                    receipt: receipt(),
+                    execution_outcome: Some(execution_outcome_with_id()),
+                    receipt: Some(receipt()),
                 }],
             }],
             state_changes: vec![],
         }
     }
 
-    fn receipt() -> Option<codec::Receipt> {
-        Some(codec::Receipt {
+    fn receipt() -> codec::Receipt {
+        codec::Receipt {
             predecessor_id: "genesis.near".to_string(),
             receiver_id: "near".to_string(),
-            receipt_id: hash("dead"),
+            receipt_id: Some(hash("dead")),
             receipt: Some(codec::receipt::Receipt::Action(codec::ReceiptAction {
                 signer_id: "near".to_string(),
-                signer_public_key: public_key("aa"),
-                gas_price: big_int(2),
+                signer_public_key: Some(public_key("aa")),
+                gas_price: Some(big_int(2)),
                 output_data_receivers: vec![],
                 input_data_ids: vec![],
                 actions: vec![
@@ -288,24 +288,24 @@ mod tests {
                                 method_name: "func".to_string(),
                                 args: vec![0x01, 0x02],
                                 gas: 1000,
-                                deposit: big_int(100),
+                                deposit: Some(big_int(100)),
                             },
                         )),
                     },
                     codec::Action {
                         action: Some(codec::action::Action::Transfer(codec::TransferAction {
-                            deposit: big_int(100),
+                            deposit: Some(big_int(100)),
                         })),
                     },
                     codec::Action {
                         action: Some(codec::action::Action::Stake(codec::StakeAction {
-                            stake: big_int(100),
-                            public_key: public_key("aa"),
+                            stake: Some(big_int(100)),
+                            public_key: Some(public_key("aa")),
                         })),
                     },
                     codec::Action {
                         action: Some(codec::action::Action::AddKey(codec::AddKeyAction {
-                            public_key: public_key("aa"),
+                            public_key: Some(public_key("aa")),
                             access_key: Some(codec::AccessKey {
                                 nonce: 1,
                                 permission: Some(codec::AccessKeyPermission {
@@ -325,7 +325,7 @@ mod tests {
                     },
                     codec::Action {
                         action: Some(codec::action::Action::AddKey(codec::AddKeyAction {
-                            public_key: public_key("aa"),
+                            public_key: Some(public_key("aa")),
                             access_key: Some(codec::AccessKey {
                                 nonce: 1,
                                 permission: Some(codec::AccessKeyPermission {
@@ -340,7 +340,7 @@ mod tests {
                     },
                     codec::Action {
                         action: Some(codec::action::Action::DeleteKey(codec::DeleteKeyAction {
-                            public_key: public_key("aa"),
+                            public_key: Some(public_key("aa")),
                         })),
                     },
                     codec::Action {
@@ -352,11 +352,11 @@ mod tests {
                     },
                 ],
             })),
-        })
+        }
     }
 
-    fn chunk_header() -> Option<codec::ChunkHeader> {
-        Some(codec::ChunkHeader {
+    fn chunk_header() -> codec::ChunkHeader {
+        codec::ChunkHeader {
             chunk_hash: vec![0x00],
             prev_block_hash: vec![0x01],
             outcome_root: vec![0x02],
@@ -368,69 +368,69 @@ mod tests {
             shard_id: 4,
             gas_used: 5,
             gas_limit: 6,
-            validator_reward: big_int(7),
-            balance_burnt: big_int(7),
+            validator_reward: Some(big_int(7)),
+            balance_burnt: Some(big_int(7)),
             outgoing_receipts_root: vec![0x07],
             tx_root: vec![0x08],
             validator_proposals: vec![codec::ValidatorStake {
                 account_id: "account".to_string(),
-                public_key: public_key("aa"),
-                stake: big_int(10),
+                public_key: Some(public_key("aa")),
+                stake: Some(big_int(10)),
             }],
-            signature: signature("ff"),
-        })
+            signature: Some(signature("ff")),
+        }
     }
 
-    fn execution_outcome_with_id() -> Option<codec::ExecutionOutcomeWithId> {
-        Some(codec::ExecutionOutcomeWithId {
+    fn execution_outcome_with_id() -> codec::ExecutionOutcomeWithId {
+        codec::ExecutionOutcomeWithId {
             proof: Some(codec::MerklePath { path: vec![] }),
-            block_hash: hash("aa"),
-            id: hash("beef"),
-            outcome: execution_outcome(),
-        })
+            block_hash: Some(hash("aa")),
+            id: Some(hash("beef")),
+            outcome: Some(execution_outcome()),
+        }
     }
 
-    fn execution_outcome() -> Option<codec::ExecutionOutcome> {
-        Some(codec::ExecutionOutcome {
+    fn execution_outcome() -> codec::ExecutionOutcome {
+        codec::ExecutionOutcome {
             logs: vec!["string".to_string()],
             receipt_ids: vec![],
             gas_burnt: 1,
-            tokens_burnt: big_int(2),
+            tokens_burnt: Some(big_int(2)),
             executor_id: "near".to_string(),
             metadata: 0,
             status: Some(codec::execution_outcome::Status::SuccessValue(
                 codec::SuccessValueExecutionStatus { value: vec![0x00] },
             )),
-        })
+        }
     }
 
-    fn big_int(input: u64) -> Option<codec::BigInt> {
+    fn big_int(input: u64) -> codec::BigInt {
         let value = BigInt::from(input);
         let bytes = value.to_signed_bytes_le();
 
-        Some(codec::BigInt { bytes })
+        codec::BigInt { bytes }
     }
 
-    fn hash(input: &str) -> Option<codec::CryptoHash> {
-        Some(codec::CryptoHash {
+    fn hash(input: &str) -> codec::CryptoHash {
+        codec::CryptoHash {
             bytes: hex::decode(input).unwrap_or_else(|_| panic!("Invalid hash value {}", input)),
-        })
+        }
     }
 
-    fn public_key(input: &str) -> Option<codec::PublicKey> {
-        Some(codec::PublicKey {
+    fn public_key(input: &str) -> codec::PublicKey {
+        codec::PublicKey {
             r#type: 0,
             bytes: hex::decode(input)
                 .unwrap_or_else(|_| panic!("Invalid PublicKey value {}", input)),
-        })
+        }
     }
 
-    fn signature(input: &str) -> Option<codec::Signature> {
-        Some(codec::Signature {
+    fn signature(input: &str) -> codec::Signature {
+        codec::Signature {
             r#type: 0,
             bytes: hex::decode(input)
                 .unwrap_or_else(|_| panic!("Invalid Signature value {}", input)),
-        })
+        }
     }
 
     struct BytesHeap {
diff --git a/store/test-store/tests/graphql/introspection.rs b/store/test-store/tests/graphql/introspection.rs
@@ -139,8 +139,8 @@ async fn introspection_query(schema: Arc<ApiSchema>, query: &str) -> QueryResult
 }
 
 fn compare(a: &r::Value, b: &r::Value, path: &mut Vec<String>) -> Option<(r::Value, r::Value)> {
-    fn different(a: &r::Value, b: &r::Value) -> Option<(r::Value, r::Value)> {
-        Some((a.clone(), b.clone()))
+    fn different(a: &r::Value, b: &r::Value) -> (r::Value, r::Value) {
+        (a.clone(), b.clone())
     }
 
     match a {
@@ -150,7 +150,7 @@ fn compare(a: &r::Value, b: &r::Value, path: &mut Vec<String>) -> Option<(r::Val
         | r::Value::Null
         | r::Value::Timestamp(_) => {
             if a != b {
-                different(a, b)
+                Some(different(a, b))
             } else {
                 None
             }
@@ -167,30 +167,30 @@ fn compare(a: &r::Value, b: &r::Value, path: &mut Vec<String>) -> Option<(r::Val
                 }
                 if la.len() > lb.len() {
                     path.push(lb.len().to_string());
-                    return different(&la[lb.len()], &r::Value::Null);
+                    return Some(different(&la[lb.len()], &r::Value::Null));
                 }
                 if lb.len() > la.len() {
                     path.push(la.len().to_string());
-                    return different(&r::Value::Null, &lb[la.len()]);
+                    return Some(different(&r::Value::Null, &lb[la.len()]));
                 }
                 None
             }
-            _ => different(a, b),
+            _ => Some(different(a, b)),
         },
         r::Value::String(sa) | r::Value::Enum(sa) => match b {
             r::Value::String(sb) | r::Value::Enum(sb) => {
                 if sa != sb {
-                    different(a, b)
+                    Some(different(a, b))
                 } else {
                     None
                 }
             }
-            _ => different(a, b),
+            _ => Some(different(a, b)),
         },
         r::Value::Object(oa) => match b {
             r::Value::Object(ob) => {
                 if oa.len() != ob.len() {
-                    return different(a, b);
+                    return Some(different(a, b));
                 }
                 for (ka, va) in oa.iter() {
                     match ob.get(ka) {
@@ -203,13 +203,13 @@ fn compare(a: &r::Value, b: &r::Value, path: &mut Vec<String>) -> Option<(r::Val
                             path.pop();
                         }
                         None => {
-                            return different(va, &r::Value::Null);
+                            return Some(different(va, &r::Value::Null));
                         }
                     }
                 }
                 None
             }
-            _ => different(a, b),
+            _ => Some(different(a, b)),
         },
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -139,8 +139,8 @@ async fn introspection_query(schema: Arc<ApiSchema>, query: &str) -> QueryResult`
`139`	`139`	`}`
`140`	`140`
`141`	`141`	`fn compare(a: &r::Value, b: &r::Value, path: &mut Vec<String>) -> Option<(r::Value, r::Value)> {`
`142`		`- fn different(a: &r::Value, b: &r::Value) -> Option<(r::Value, r::Value)> {`
`143`		`- Some((a.clone(), b.clone()))`
	`142`	`+ fn different(a: &r::Value, b: &r::Value) -> (r::Value, r::Value) {`
	`143`	`+ (a.clone(), b.clone())`
`144`	`144`	`}`
`145`	`145`
`146`	`146`	`match a {`
`@@ -150,7 +150,7 @@ fn compare(a: &r::Value, b: &r::Value, path: &mut Vec<String>) -> Option<(r::Val`
`150`	`150`	`\| r::Value::Null`
`151`	`151`	`\| r::Value::Timestamp(_) => {`
`152`	`152`	`if a != b {`
`153`		`- different(a, b)`
	`153`	`+ Some(different(a, b))`
`154`	`154`	`} else {`
`155`	`155`	`None`
`156`	`156`	`}`
`@@ -167,30 +167,30 @@ fn compare(a: &r::Value, b: &r::Value, path: &mut Vec<String>) -> Option<(r::Val`
`167`	`167`	`}`
`168`	`168`	`if la.len() > lb.len() {`
`169`	`169`	`path.push(lb.len().to_string());`
`170`		`- return different(&la[lb.len()], &r::Value::Null);`
	`170`	`+ return Some(different(&la[lb.len()], &r::Value::Null));`
`171`	`171`	`}`
`172`	`172`	`if lb.len() > la.len() {`
`173`	`173`	`path.push(la.len().to_string());`
`174`		`- return different(&r::Value::Null, &lb[la.len()]);`
	`174`	`+ return Some(different(&r::Value::Null, &lb[la.len()]));`
`175`	`175`	`}`
`176`	`176`	`None`
`177`	`177`	`}`
`178`		`- _ => different(a, b),`
	`178`	`+ _ => Some(different(a, b)),`
`179`	`179`	`},`
`180`	`180`	`r::Value::String(sa) \| r::Value::Enum(sa) => match b {`
`181`	`181`	`r::Value::String(sb) \| r::Value::Enum(sb) => {`
`182`	`182`	`if sa != sb {`
`183`		`- different(a, b)`
	`183`	`+ Some(different(a, b))`
`184`	`184`	`} else {`
`185`	`185`	`None`
`186`	`186`	`}`
`187`	`187`	`}`
`188`		`- _ => different(a, b),`
	`188`	`+ _ => Some(different(a, b)),`
`189`	`189`	`},`
`190`	`190`	`r::Value::Object(oa) => match b {`
`191`	`191`	`r::Value::Object(ob) => {`
`192`	`192`	`if oa.len() != ob.len() {`
`193`		`- return different(a, b);`
	`193`	`+ return Some(different(a, b));`
`194`	`194`	`}`
`195`	`195`	`for (ka, va) in oa.iter() {`
`196`	`196`	`match ob.get(ka) {`
`@@ -203,13 +203,13 @@ fn compare(a: &r::Value, b: &r::Value, path: &mut Vec<String>) -> Option<(r::Val`
`203`	`203`	`path.pop();`
`204`	`204`	`}`
`205`	`205`	`None => {`
`206`		`- return different(va, &r::Value::Null);`
	`206`	`+ return Some(different(va, &r::Value::Null));`
`207`	`207`	`}`
`208`	`208`	`}`
`209`	`209`	`}`
`210`	`210`	`None`
`211`	`211`	`}`
`212`		`- _ => different(a, b),`
	`212`	`+ _ => Some(different(a, b)),`
`213`	`213`	`},`
`214`	`214`	`}`
`215`	`215`	`}`