How do I mock an external dependency in Rust

I have a method which calls the external dependency walkdir::WalkDir, and would like to test that I'm handling its output correctly. Ideally by mocking the response of the dependency.

My code looks like this:

use walkdir::{IntoIter,WalkDir};

pub struct MyStruct<'a> {
    pub path: &'a Path
}

impl MyStruct {
    fn _walk_wrapper(&self) -> IntoIter {
        WalkDir::new(self.path)
            .into_iter()
    }

    pub fn foo(&self) -> Vec<&str> {
        let walk = self._walk_wrapper();

        // do something with the walk results
        // return a vector of values
    }
}

Any help is appreciated

3 approaches:

1. Just conditionally implement this method differently.

use walkdir::{IntoIter,WalkDir};

pub struct MyStruct<'a> {
    pub path: &'a Path
}

impl MyStruct {
    #[cfg(not(test))]
    fn _walk_wrapper(&self) -> impl IntoIter {
        WalkDir::new(self.path)
            .into_iter()
    }

    #[cfg(test)]
    fn _walk_wrapper(&self) -> impl IntoIter {
        ["x.txt", "my_cat.jps"].into_iter()
    }

    pub fn foo(&self) -> Vec<&str> {
        let walk = self._walk_wrapper();

        // do something with the walk results
        // return a vector of values
    }
}

This approach has big downsides, for example, all your tests would get same output.
And you wouldn't be able test real behaviour in future.

You may try to use mockall for mocking tests.

2. Use generics and traits:

use walkdir::{IntoIter,WalkDir};

trait WalkDirImpl {
   type It: Iterator;
   fn get_values(path: &Path)->Self::It;
}

impl WalkDirImpl for WalkDir {
   type It: ...;
   fn get_values() -> Self::It{
        WalkDir::new(self.path)
            .into_iter()
    }
}

pub struct MyStruct<'a> {
    pub path: &'a Path
}

impl MyStruct {
    #[cfg(not(test))]
    fn _walk_wrapper(&self) -> impl IntoIter {
        WalkDir::new(self.path)
            .into_iter()
    }

    #[cfg(test)]
    fn _walk_wrapper(&self) -> impl IntoIter {
        ["x.txt", "my_cat.jps"].into_iter()
    }

    pub fn foo<WalkWrapper=WalkDir>(&self) -> Vec<&str>
       where WalkWrapper: WalkDirImpl
    {
        let walk = self._walk_wrapper();

        // do something with the walk results
        // return a vector of values
    }
}
#[test]
fn my_test() {
    struct TestProvider;
    impl WalkDirImpl for TestProvider{
       type It: ...;
       fn get_values() -> Self::It{
          ["x.txt", "my_cat.jps"].into_iter()
       }
    }
    
    MyStruct::foo::<TestProvider>
}

This approach has downsides too. For example, you start to leak foreign type from your public interface.
To prevent this, you can wrap your generic struct/methdod into some public struct/method and use inner private generic struct/method.

3. This is variation of first approach.

type OverrideFun = fn()->Vec<PathBuf>;
// Use thread local to store override function.
// Thread local because tests runs in parallel.
#[cfg(test)]
thread_local!{
   static OVERRIDE_FUN_PTR: Cell<Option<OverrideFun>> = Cell::new(None);
};

fn get_children(path:&Path)->Vec<PathBuf>{
   // If test, try to load override.
   #[cfg(test)]
   {
      let mut res = None;
      OVERRIDE_FUN_PTR.with(|cell|{
         let fun = cell.get();
         res = fun();
      });
      if let Some(res) = res{
         return res;
      }
   }


   WalkDir::new(path)
            .into_iter()
            .collect()
}

#[test]
fn my_test(){
   OVERRIDE_FUN_PTR.with(|cell|{
         cell.set(||vec!["x.txt", "my_cat.jpg"]);
   });
   assert_eq!(get_children(""), vec!["x.txt", "my_cat.jpg"]);
}

This version is good because it is configurable. Because #[cfg(test)] it only affects tests and wouldn't be compiled into your result binary.
And you could store anything in that threadlocal, really.