Another state machine test (#5875)

* another state machine test

* add more asserts and remove 'remov_then_append'

substrate/primitives/state-machine/src/lib.rs

@@ -1127,29 +1127,99 @@ mod tests {
 	}
 
 	#[test]
-	fn remove_then_append() {
+	fn remove_with_append_then_rollback_appended_then_append_again() {
-		let key = b"key".to_vec();
+
+		#[derive(codec::Encode, codec::Decode)]
+		enum Item { InitializationItem, DiscardedItem, CommitedItem }
+
+		let key = b"events".to_vec();
+		let mut cache = StorageTransactionCache::default();
 		let mut state = new_in_mem::<BlakeTwo256>();
 		let backend = state.as_trie_backend().unwrap();
-		let mut overlay = OverlayedChanges::default();
 		let mut offchain_overlay = OffchainOverlayedChanges::default();
-		let mut cache = StorageTransactionCache::default();
+		let mut overlay = OverlayedChanges::default();
 
-		let mut ext = Ext::new(
+		// For example, block initialization with event.
-			&mut overlay,
+		{
-			&mut offchain_overlay,
+			let mut ext = Ext::new(
-			&mut cache,
+				&mut overlay,
-			backend,
+				&mut offchain_overlay,
-			changes_trie::disabled_state::<_, u64>(),
+				&mut cache,
-			None,
+				backend,
-		);
+				changes_trie::disabled_state::<_, u64>(),
+				None,
+			);
+			ext.clear_storage(key.as_slice());
+			ext.storage_append(key.clone(), Item::InitializationItem.encode());
+		}
+		overlay.commit_prospective();
 
-		ext.clear_storage(key.as_slice());
+		// For example, first transaction resulted in panic during block building
-		ext.storage_append(key.clone(), b"Item".to_vec().encode());
+		{
-		assert_eq!(
+			let mut ext = Ext::new(
-			ext.storage(key.as_slice()),
+				&mut overlay,
-			Some(vec![b"Item".to_vec()].encode()),
+				&mut offchain_overlay,
-		);
+				&mut cache,
+				backend,
+				changes_trie::disabled_state::<_, u64>(),
+				None,
+			);
+
+			assert_eq!(
+				ext.storage(key.as_slice()),
+				Some(vec![Item::InitializationItem].encode()),
+			);
+
+			ext.storage_append(key.clone(), Item::DiscardedItem.encode());
+
+			assert_eq!(
+				ext.storage(key.as_slice()),
+				Some(vec![Item::InitializationItem, Item::DiscardedItem].encode()),
+			);
+		}
+		overlay.discard_prospective();
+
+		// Then we apply next transaction which is valid this time.
+		{
+			let mut ext = Ext::new(
+				&mut overlay,
+				&mut offchain_overlay,
+				&mut cache,
+				backend,
+				changes_trie::disabled_state::<_, u64>(),
+				None,
+			);
+
+			assert_eq!(
+				ext.storage(key.as_slice()),
+				Some(vec![Item::InitializationItem].encode()),
+			);
+
+			ext.storage_append(key.clone(), Item::CommitedItem.encode());
+
+			assert_eq!(
+				ext.storage(key.as_slice()),
+				Some(vec![Item::InitializationItem, Item::CommitedItem].encode()),
+			);
+
+		}
+		overlay.commit_prospective();
+
+		// Then only initlaization item and second (commited) item should persist.
+		{
+			let ext = Ext::new(
+				&mut overlay,
+				&mut offchain_overlay,
+				&mut cache,
+				backend,
+				changes_trie::disabled_state::<_, u64>(),
+				None,
+			);
+			assert_eq!(
+				ext.storage(key.as_slice()),
+				Some(vec![Item::InitializationItem, Item::CommitedItem].encode()),
+			);
+		}
 	}
 
 	#[test]