Deadline is no longer optional, also add expiration test

Author: mvines

feature-proposal/program/src/instruction.rs

@@ -76,7 +76,7 @@ pub enum FeatureProposalInstruction {
 
 impl Sealed for FeatureProposalInstruction {}
 impl Pack for FeatureProposalInstruction {
-    const LEN: usize = 26; // see `test_get_packed_len()` for justification of "18"
+    const LEN: usize = 25; // see `test_get_packed_len()` for justification of "18"
 
     fn pack_into_slice(&self, dst: &mut [u8]) {
         let data = self.pack_into_vec();
@@ -177,12 +177,15 @@ mod tests {
                 tokens_to_mint: 42,
                 acceptance_criteria: AcceptanceCriteria {
                     tokens_required: 0xdeadbeefdeadbeef,
-                    deadline: None,
+                    deadline: -1,
                 }
             }
             .try_to_vec()
             .unwrap(),
-            vec![0, 42, 0, 0, 0, 0, 0, 0, 0, 239, 190, 173, 222, 239, 190, 173, 222, 0]
+            vec![
+                0, 42, 0, 0, 0, 0, 0, 0, 0, 239, 190, 173, 222, 239, 190, 173, 222, 255, 255, 255,
+                255, 255, 255, 255, 255
+            ]
         );
     }
 

feature-proposal/program/src/processor.rs

@@ -324,14 +324,13 @@ pub fn process_instruction(
                         &[feature_id_bump_seed],
                     ];
 
-                    if let Some(deadline) = acceptance_criteria.deadline {
-                        if clock.unix_timestamp >= deadline {
-                            info!("Feature proposal expired");
-                            FeatureProposal::Expired
-                                .pack_into_slice(&mut feature_proposal_info.data.borrow_mut());
-                            return Ok(());
-                        }
+                    if clock.unix_timestamp >= acceptance_criteria.deadline {
+                        info!("Feature proposal expired");
+                        FeatureProposal::Expired
+                            .pack_into_slice(&mut feature_proposal_info.data.borrow_mut());
+                        return Ok(());
                     }
+
                     info!("Unpacking acceptance token account");
                     let acceptance_token =
                         spl_token::state::Account::unpack(&acceptance_token_info.data.borrow())?;

feature-proposal/program/src/state.rs

@@ -15,8 +15,7 @@ pub struct AcceptanceCriteria {
     pub tokens_required: u64,
 
     /// If the required tokens are not tallied by this deadline then the proposal will expire.
-    /// `None` if the proposal should never expire.
-    pub deadline: Option<UnixTimestamp>,
+    pub deadline: UnixTimestamp,
 }
 
 /// Contents of a Feature Proposal account
@@ -38,7 +37,7 @@ pub enum FeatureProposal {
 impl Sealed for FeatureProposal {}
 
 impl Pack for FeatureProposal {
-    const LEN: usize = 18; // see `test_get_packed_len()` for justification of "18"
+    const LEN: usize = 17; // see `test_get_packed_len()` for justification of "18"
 
     fn pack_into_slice(&self, dst: &mut [u8]) {
         let data = self.try_to_vec().unwrap();
@@ -77,21 +76,11 @@ mod tests {
         assert_eq!(
             FeatureProposal::Pending(AcceptanceCriteria {
                 tokens_required: 0xdeadbeefdeadbeef,
-                deadline: None,
+                deadline: -1,
             })
             .try_to_vec()
             .unwrap(),
-            vec![1, 239, 190, 173, 222, 239, 190, 173, 222, 0],
-        );
-
-        assert_eq!(
-            FeatureProposal::Pending(AcceptanceCriteria {
-                tokens_required: 0,
-                deadline: Some(-1),
-            })
-            .try_to_vec()
-            .unwrap(),
-            vec![1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 255, 255, 255, 255, 255, 255, 255, 255],
+            vec![1, 239, 190, 173, 222, 239, 190, 173, 222, 255, 255, 255, 255, 255, 255, 255, 255],
         );
     }
 

feature-proposal/program/tests/functional.rs

@@ -68,7 +68,7 @@ async fn test_basic() {
             42,
             AcceptanceCriteria {
                 tokens_required: 42,
-                deadline: None,
+                deadline: i64::MAX,
             },
         )],
         Some(&payer.pubkey()),
@@ -183,4 +183,41 @@ async fn test_basic() {
     ));
 }
 
-// TODO: more tests....
+#[tokio::test]
+async fn test_expired() {
+    let feature_proposal = Keypair::new();
+
+    let (mut banks_client, payer, recent_blockhash) = program_test().start().await;
+
+    // Create a new feature proposal
+    let mut transaction = Transaction::new_with_payer(
+        &[propose(
+            &payer.pubkey(),
+            &feature_proposal.pubkey(),
+            42,
+            AcceptanceCriteria {
+                tokens_required: 42,
+                deadline: 0, // <=== Already expired
+            },
+        )],
+        Some(&payer.pubkey()),
+    );
+    transaction.sign(&[&payer, &feature_proposal], recent_blockhash);
+    banks_client.process_transaction(transaction).await.unwrap();
+
+    assert!(matches!(
+        get_account_data::<FeatureProposal>(&mut banks_client, feature_proposal.pubkey()).await,
+        Ok(FeatureProposal::Pending(_))
+    ));
+
+    // Tally will cause the proposal to expire
+    let mut transaction =
+        Transaction::new_with_payer(&[tally(&feature_proposal.pubkey())], Some(&payer.pubkey()));
+    transaction.sign(&[&payer], recent_blockhash);
+    banks_client.process_transaction(transaction).await.unwrap();
+
+    assert!(matches!(
+        get_account_data::<FeatureProposal>(&mut banks_client, feature_proposal.pubkey()).await,
+        Ok(FeatureProposal::Expired)
+    ));
+}