chore: More verbose note import tests (0xMiden#1130)

* chore: improve verbosity of import_expected_notes

* chore: import status differs before/after sync

* chore: address PR review

Author: mmagician

tests/src/main_tests.rs

@@ -176,8 +176,11 @@ async fn import_expected_notes() {
         tx_request.expected_output_own_notes().pop().unwrap().clone().into();
     client_2.sync_state().await.unwrap();
 
-    // If the verification is requested before execution then the import should fail
-    assert!(client_2.import_note(NoteFile::NoteId(note.id())).await.is_err());
+    // Importing a public note before it's committed onchain should fail
+    assert!(matches!(
+        client_2.import_note(NoteFile::NoteId(note.id())).await.unwrap_err(),
+        ClientError::NoteNotFoundOnChain(_)
+    ));
     execute_tx_and_sync(&mut client_1, faucet_account.id(), tx_request).await;
 
     // Use client 1 to wait until a couple of blocks have passed
@@ -189,13 +192,13 @@ async fn import_expected_notes() {
     client_2.import_note(NoteFile::NoteId(note.clone().id())).await.unwrap();
     client_2.sync_state().await.unwrap();
     let input_note = client_2.get_input_note(note.id()).await.unwrap().unwrap();
+    // If imported after execution and syncing then the inclusion proof should be Some
+    assert!(input_note.inclusion_proof().is_some(), "Expected inclusion proof to be present");
+
     assert!(
         new_sync_data.block_num > input_note.inclusion_proof().unwrap().location().block_num() + 1
     );
 
-    // If imported after execution and syncing then the inclusion proof should be Some
-    assert!(input_note.inclusion_proof().is_some());
-
     // If client 2 successfully consumes the note, we confirm we have MMR and block header data
     let tx_id =
         consume_notes(&mut client_2, client_2_account.id(), &[input_note.try_into().unwrap()])
@@ -213,7 +216,7 @@ async fn import_expected_notes() {
     let note: InputNoteRecord =
         tx_request.expected_output_own_notes().pop().unwrap().clone().into();
 
-    // Import an uncommitted note without verification
+    // Import the node before it's committed onchain works if we have full `NoteDetails`
     client_2.add_note_tag(note.metadata().unwrap().tag()).await.unwrap();
     client_2
         .import_note(NoteFile::NoteDetails {
@@ -225,16 +228,16 @@ async fn import_expected_notes() {
         .unwrap();
     let input_note = client_2.get_input_note(note.id()).await.unwrap().unwrap();
 
-    // If imported before execution then the inclusion proof should be None
-    assert!(input_note.inclusion_proof().is_none());
+    // If imported before execution, the note should be imported in `Expected` state
+    assert!(matches!(input_note.state(), InputNoteState::Expected { .. }));
 
     execute_tx_and_sync(&mut client_1, faucet_account.id(), tx_request).await;
     client_2.sync_state().await.unwrap();
 
     // After sync, the imported note should have inclusion proof even if it's not relevant for its
     // accounts.
     let input_note = client_2.get_input_note(note.id()).await.unwrap().unwrap();
-    assert!(input_note.inclusion_proof().is_some());
+    assert!(input_note.inclusion_proof().is_some(), "Expected inclusion proof to be present");
 
     // If inclusion proof is invalid this should panic
     let tx_id =
@@ -315,9 +318,24 @@ async fn import_expected_notes_from_the_past_as_committed() {
 
     // Use client 1 to wait until a couple of blocks have passed
     wait_for_blocks(&mut client_1, 3).await;
+
+    // importing the note before client_2 is synced will result in a note with `Expected` state
+    let note_id = client_2
+        .import_note(NoteFile::NoteDetails {
+            details: note.clone().into(),
+            after_block_num: block_height_before,
+            tag: Some(note.metadata().unwrap().tag()),
+        })
+        .await
+        .unwrap();
+
+    let imported_note = client_2.get_input_note(note_id).await.unwrap().unwrap();
+
+    assert!(matches!(imported_note.state(), InputNoteState::Expected { .. }));
+
     client_2.sync_state().await.unwrap();
 
-    // If the verification is requested before execution then the import should fail
+    // import the note after syncing the client
     let note_id = client_2
         .import_note(NoteFile::NoteDetails {
             details: note.clone().into(),
@@ -333,6 +351,7 @@ async fn import_expected_notes_from_the_past_as_committed() {
     let client_1_note = client_1.get_input_note(note_id).await.unwrap().unwrap();
 
     assert_eq!(imported_note.state(), client_1_note.state());
+    assert!(matches!(imported_note.state(), InputNoteState::Committed { .. }));
 }
 
 #[tokio::test]