test: Add state check for PoSt submission

Author: aidan46

pallets/storage-provider/src/deadline.rs

@@ -146,7 +146,7 @@ impl<BlockNumber: Clone + Copy + Ord> Deadline<BlockNumber> {
             // Add sectors to partition.
             partition
                 .add_sectors(&new_partition_sectors)
-                .expect("TODO: change this to explicit error");
+                .map_err(|_| DeadlineError::CouldNotAddSectors)?;
 
             // Save partition back.
             match partitions.get_mut(&(partition_idx as u32)) {
@@ -199,6 +199,7 @@ impl<BlockNumber: Clone + Copy + Ord> Deadlines<BlockNumber> {
     /// Constructor function.
     pub fn new() -> Self {
         let mut due = BoundedVec::new();
+        // Initialize deadlines as empty deadlines.
         for _ in 0..48 {
             let _ = due.try_push(Deadline::new());
         }
@@ -271,6 +272,19 @@ impl<BlockNumber: Clone + Copy + Ord> Deadlines<BlockNumber> {
         }
         Ok(())
     }
+
+    pub fn update_deadline(
+        &mut self,
+        deadline_idx: usize,
+        deadline: Deadline<BlockNumber>,
+    ) -> DeadlineResult<()> {
+        let dl = self
+            .due
+            .get_mut(deadline_idx)
+            .ok_or(DeadlineError::DeadlineNotFound)?;
+        dl.update_deadline(deadline);
+        Ok(())
+    }
 }
 
 #[derive(Clone, Debug, Decode, Encode, PartialEq, TypeInfo)]
@@ -394,7 +408,12 @@ pub enum DeadlineError {
     ProofUpdateFailed,
     /// Emitted when trying to get the next instance of a deadline that has not yet elapsed fails.
     FailedToGetNextDeadline,
+    /// Emitted when max partition for a given deadline have been reached.
     MaxPartitionsReached,
+    /// Emitted when trying to add sectors to a deadline fails
+    CouldNotAddSectors,
+    /// Emitted when assigning sectors to deadlines fails.
+    CouldNotAssignSectorsToDeadlines,
 }
 
 #[cfg(test)]

pallets/storage-provider/src/deadline/assignment.rs

@@ -197,7 +197,10 @@ pub fn assign_deadlines<BlockNumber: Clone + Copy + Ord>(
     let mut changes = vec![Vec::new(); w_post_period_deadlines as usize];
 
     for sector in sectors {
-        let info = &mut heap.peek_mut().unwrap().info;
+        let info = &mut heap
+            .peek_mut()
+            .ok_or(DeadlineError::CouldNotConstructDeadlineInfo)?
+            .info;
 
         if info.max_partitions_reached(partition_size, max_partitions) {
             return Err(DeadlineError::MaxPartitionsReached);

pallets/storage-provider/src/storage_provider.rs

@@ -146,7 +146,7 @@ where
 
     /// Assign new sector to a deadline.
     pub fn assign_sectors_to_deadlines(
-        &self,
+        &mut self,
         current_block: BlockNumber,
         mut sectors: Vec<SectorOnChainInfo<BlockNumber>>,
         partition_size: u64,
@@ -164,7 +164,7 @@ where
             "assign_sectors_to_deadlines: deadline len = {}",
             deadlines.len()
         );
-        deadlines.for_each(|deadline_idx, deadline| {
+        deadlines.clone().for_each(|deadline_idx, deadline| {
             // Skip deadlines that aren't currently mutable.
             if deadline_is_mutable(
                 self.current_proving_period_start(
@@ -191,16 +191,24 @@ where
             sectors,
             w_post_period_deadlines,
         )?;
+        let deadlines = self.get_deadlines_mut();
         for (deadline_idx, deadline_sectors) in deadline_to_sectors.into_iter().enumerate() {
             if deadline_sectors.is_empty() {
                 continue;
             }
 
-            let deadline = deadline_vec[deadline_idx].as_mut().unwrap();
+            let deadline =
+                deadline_vec[deadline_idx]
+                    .as_mut()
+                    .ok_or(StorageProviderError::DeadlineError(
+                        DeadlineError::CouldNotAssignSectorsToDeadlines,
+                    ))?;
 
             deadline.add_sectors(partition_size, &deadline_sectors)?;
 
-            // deadlines.update_deadline(policy, store, deadline_idx as u64, deadline)?;
+            deadlines
+                .update_deadline(deadline_idx, deadline.clone())
+                .map_err(|e| StorageProviderError::DeadlineError(e))?;
         }
         Ok(())
     }

pallets/storage-provider/src/tests/submit_windowed_post.rs

@@ -2,7 +2,7 @@ use frame_support::assert_ok;
 use sp_core::bounded_vec;
 
 use crate::{
-    pallet::Event,
+    pallet::{Event, StorageProviders},
     sector::ProveCommitSector,
     tests::{
         account, events, new_test_ext, register_storage_provider, run_to_block,
@@ -90,5 +90,10 @@ fn submit_windowed_post() {
                 }
             )]
         );
+        let state = StorageProviders::<Test>::get(account(ALICE)).unwrap();
+        let deadlines = state.deadlines;
+        let new_dl = deadlines.due.first().expect("Programmer error");
+        assert_eq!(new_dl.live_sectors, 1);
+        assert_eq!(new_dl.total_sectors, 1);
     });
 }