improved fuzz testing, check cache failures

Author: wasm-forge

fuzz-tests/src/bindings/fs_tests_backend.rs

@@ -97,6 +97,8 @@ impl FsTestsBackendCanister {
         )
     }
 }
+pub const CANISTER_ID: Principal =
+    Principal::from_slice(&[255, 255, 255, 255, 255, 224, 0, 2, 1, 1]); // lz3um-vp777-77777-aaaba-cai
 
 pub fn new(caller: &super::Caller, canister_id: Principal) -> FsTestsBackendCanister {
     FsTestsBackendCanister {
@@ -120,7 +122,7 @@ pub fn deploy(deployer: &super::Deployer) -> super::DeployBuilder<FsTestsBackend
     }
 }
 pub fn canister_id() -> Option<Principal> {
-    None
+    Some(Principal::from_text("lz3um-vp777-77777-aaaba-cai").unwrap())
 }
 
 pub fn wasm() -> Option<Vec<u8>> {

fuzz-tests/src/tests.rs

@@ -2,7 +2,7 @@ use std::{fs::OpenOptions, io::Write};
 
 use ic_test::IcpTest;
 
-use crate::test_setup;
+use crate::{bindings::fs_tests_backend, test_setup};
 
 #[tokio::test]
 async fn test_basic_fs_check() {
@@ -21,7 +21,20 @@ async fn test_fs_durability() {
 
     let env = test_setup::setup(IcpTest::new().await).await;
 
-    let c = env.fs_tests_backend.do_fs_test().call().await;
+    let icp_user = env.icp_test.icp.test_user(0);
+
+    let backend = env.fs_tests_backend;
+
+    let _c = backend.do_fs_test().call().await;
+
+    // re-deploy
+    let backend = fs_tests_backend::deploy(&icp_user)
+        .with_upgrade()
+        .call()
+        .await;
+
+    let c = backend.do_fs_test().call().await;
+
     let computed = c.trim();
 
     let e = std::fs::read_to_string("../target/release/report.txt").unwrap();
@@ -32,7 +45,7 @@ async fn test_fs_durability() {
     let expected_log = expected_log_.trim();
 
     if computed != expected {
-        let computed_log = env.fs_tests_backend.get_log().call().await;
+        let computed_log = backend.get_log().call().await;
 
         // write scans and logs into a separate files for comparisons
         let mut a = OpenOptions::new()

ic-test.json

@@ -29,7 +29,7 @@
         "candid_path": "test/canisters/fs_tests/src/fs_tests_backend/fs_tests_backend.did",
         "generate_bindings": true,
         "wasm": "target/wasm32-wasip1/release/fs_tests_backend_nowasi.wasm",
-        "specified_id": null
+        "specified_id": "lz3um-vp777-77777-aaaba-cai"
       }
     }
   }

test/canisters/fs_tests/src/fs_tests_backend/src/canister.rs

@@ -14,6 +14,7 @@ use std::{
     collections::BTreeMap,
     fs::{self, FileType, Permissions},
     io::{Seek, SeekFrom},
+    path::PathBuf,
 };
 
 pub struct SimpleRng {
@@ -69,12 +70,21 @@ pub fn get_seed() -> u64 {
 }
 
 pub(crate) fn new_log(path: &str) {
-    let file = fs::OpenOptions::new()
-        .create(true)
-        .write(true)
-        .truncate(true)
-        .open(path)
-        .unwrap();
+    let p = std::path::Path::new(path);
+
+    let file = if p.exists() {
+        fs::OpenOptions::new()
+            .create(false)
+            .append(true)
+            .open(path)
+            .unwrap()
+    } else {
+        fs::OpenOptions::new()
+            .create(true)
+            .append(true)
+            .open(path)
+            .unwrap()
+    };
 
     LOG.with(|log| {
         *log.borrow_mut() = Some(file);
@@ -112,6 +122,11 @@ fn init() {
     });
 }
 
+#[ic_cdk::post_upgrade]
+fn upgrade() {
+    init();
+}
+
 use sha2::{Digest, Sha256};
 use std::fs::File;
 use std::io::BufReader;
@@ -265,7 +280,28 @@ pub fn get_log() -> String {
 fn get_random_file(
     parent_path: &std::path::Path,
     op_count: u64,
+    opened_files: &mut BTreeMap<String, File>,
 ) -> anyhow::Result<std::path::PathBuf> {
+    // sometimes return an opened file
+    if next_rand(2) < 1 {
+        let len = opened_files.len();
+        let file = opened_files.iter().nth(next_rand(len as u64) as usize);
+
+        if let Some(f) = file {
+            let path = PathBuf::new().join(f.0);
+
+            // just recreate the file, if it doesn't exist
+            let _res = fs::OpenOptions::new()
+                .write(true)
+                .append(false)
+                .truncate(false)
+                .create(true)
+                .open(&path);
+
+            return Ok(path);
+        }
+    }
+
     let mut files: Vec<fs::DirEntry> = fs::read_dir(parent_path)?
         .filter_map(Result::ok)
         .filter(|e| e.path().is_file() && e.file_name().to_string_lossy() != "log.txt")
@@ -289,6 +325,9 @@ fn get_random_file(
 
     // no files, create a new one for writing
     let path = parent_path.join(format!("file{op_count}.txt"));
+
+    File::create(&path).unwrap();
+
     Ok(path)
 }
 
@@ -354,6 +393,7 @@ fn generate_random_file_structure(
     max_depth: u64,
 
     parent_path: &std::path::Path,
+
     opened_files: &mut BTreeMap<String, File>,
 ) -> anyhow::Result<u64> {
     let depth = depth + 1;
@@ -375,7 +415,7 @@ fn generate_random_file_structure(
                 // Create a new file
                 let path = parent_path.join(format!("file{current_op}.txt"));
                 log(&format!("Open or create file {path:?}"));
-                let mut file = File::create(&path)?;
+                let mut file = File::create(&path).unwrap();
                 file.flush()?;
                 opened_files.insert(path.as_path().to_string_lossy().to_string(), file);
             }
@@ -446,7 +486,7 @@ fn generate_random_file_structure(
             }
             4 => {
                 // Read text from a random file
-                let file = get_random_file(parent_path, current_op)?;
+                let file = get_random_file(parent_path, current_op, opened_files)?;
 
                 if file.exists() {
                     //
@@ -469,7 +509,7 @@ fn generate_random_file_structure(
             }
             5 => {
                 // Truncate file (delete its contents)
-                let file = get_random_file(parent_path, current_op)?;
+                let file = get_random_file(parent_path, current_op, opened_files)?;
 
                 log(&format!("Truncate {file:?}"));
 
@@ -483,7 +523,8 @@ fn generate_random_file_structure(
             }
             6 => {
                 // Rename file
-                let from = get_random_file(parent_path, current_op)?;
+                let from = get_random_file(parent_path, current_op, opened_files)?;
+
                 let to = parent_path.join(format!("file{current_op}_renamed.txt"));
                 log(&format!("Rename file from {from:?} to {to:?}"));
                 let res = fs::rename(&from, &to);
@@ -500,7 +541,8 @@ fn generate_random_file_structure(
             }
             7 => {
                 // Copy file
-                let from = get_random_file(parent_path, current_op)?;
+                let from = get_random_file(parent_path, current_op, opened_files)?;
+
                 let to = parent_path.join(format!("file{current_op}_copy.txt"));
                 log(&format!("Copy file from {from:?} to {to:?}"));
                 let res = fs::copy(&from, &to);
@@ -510,7 +552,7 @@ fn generate_random_file_structure(
             }
             8 => {
                 // Delete file
-                let path = get_random_file(parent_path, current_op)?;
+                let path = get_random_file(parent_path, current_op, opened_files)?;
 
                 // we do not have dangling file support yet, so do not try to delete an opened file...
                 if opened_files.contains_key(&path.as_path().to_string_lossy().to_string()) {
@@ -584,7 +626,8 @@ fn generate_random_file_structure(
                     .create(true)
                     .open(&save_path)?;
 
-                let path = get_random_file(parent_path, current_op)?;
+                let path = get_random_file(parent_path, current_op, opened_files)?;
+
                 let meta = fs::metadata(&path)?;
 
                 save.write_all(
@@ -634,7 +677,7 @@ fn generate_random_file_structure(
             }
             15 => {
                 // Move file into subdirectory
-                let from = get_random_file(parent_path, current_op)?;
+                let from = get_random_file(parent_path, current_op, opened_files)?;
                 let filename = from.file_name().unwrap().to_string_lossy().to_string();
 
                 let dir = get_random_dir(parent_path, current_op)?;
@@ -647,7 +690,7 @@ fn generate_random_file_structure(
             }
             16 => {
                 // write some prepared text into one of the files at a random position
-                let path = get_random_file(parent_path, current_op)?;
+                let path = get_random_file(parent_path, current_op, opened_files)?;
 
                 let mut save = fs::OpenOptions::new()
                     .write(true)

test/canisters/fs_tests/src/fs_tests_backend/src/main.rs

@@ -11,6 +11,9 @@ fn main() {
 
     env::set_current_dir("playground").unwrap();
 
+    // double fs_test call (for the canister upgrade imitation)
+    let _scan = canister::do_fs_test();
+    //
     let scan = canister::do_fs_test();
 
     println!("{scan}");

test/canisters/fs_tests/src/fs_tests_backend/src/tests.rs

@@ -1,16 +1,22 @@
-use std::{fs::File, io::Write};
+use std::{
+    fs::File,
+    io::{Seek, SeekFrom, Write},
+};
 
 use crate::canister::{generate_random_fs, new_log, scan_directory};
 
 pub fn do_fs_test_interal() -> String {
     new_log("log.txt");
-    generate_random_fs(5, 200, 20);
-    //failing_test();
+    generate_random_fs(42, 3500, 20);
+    //failing_dangling_file_test();
+    //open_file_test();
+    //cache_failure_test();
 
     scan_directory(".".to_string())
 }
 
 // we don't have dangling file support yet
+#[allow(dead_code)]
 pub fn failing_dangling_file_test() {
     let mut file_a = File::create("a.txt").unwrap();
     file_a.flush().unwrap();
@@ -21,15 +27,61 @@ pub fn failing_dangling_file_test() {
     }
 }
 
+#[allow(dead_code)]
 pub fn open_file_test() {
-    //truncate=false,write=false,append=false,create=true
     // special combination fails
-    let res = std::fs::OpenOptions::new()
-        .write(false)
-        .read(true)
-        .append(true)
-        .truncate(false)
-        .create(true)
-        .open("some_file.txt")
-        .unwrap();
+
+    for i in 0..32 {
+        let r = i % 2;
+        let w = (i >> 1) % 2;
+        let a = (i >> 2) % 2;
+        let t = (i >> 3) % 2;
+        let c = (i >> 4) % 2;
+
+        let fname = format!("r{r}w{w}a{a}t{t}c{c}.txt");
+
+        let _r = std::fs::OpenOptions::new()
+            .read(r == 1)
+            .write(w == 1)
+            .append(a == 1)
+            .truncate(t == 1)
+            .create(c == 1)
+            .open(&fname);
+    }
+}
+
+#[allow(dead_code)]
+pub fn cache_failure_test() {
+    let filename = "cache.txt";
+    let offset_step = 1024 * 64; // 64K - guarantees different chunks of every setup
+
+    {
+        // initial write
+        let mut file = std::fs::OpenOptions::new()
+            .read(true)
+            .write(true)
+            .create(true)
+            .truncate(true)
+            .open(filename)
+            .unwrap();
+
+        let _ = file.seek(SeekFrom::Start(offset_step));
+        let _ = file.write_all(&[2]);
+    }
+
+    {
+        // truncate file
+        let mut file = std::fs::OpenOptions::new()
+            .read(true)
+            .write(true)
+            .create(true)
+            .truncate(true)
+            .open(filename)
+            .unwrap();
+
+        let _ = file.seek(SeekFrom::Start(2 * offset_step));
+        let _ = file.write_all(&[7]);
+        let _ = file.seek(SeekFrom::Start(offset_step));
+        let _ = file.write_all(&[6]);
+    }
 }