CHANGELOG.md

@@ -4,6 +4,18 @@ All notable changes to this project will be documented in this file.
 This project adheres to [Semantic Versioning](http://semver.org/).
 
 
+## [ 0.12.1 ] - 2023-12-21
+
+### Fixed
+
+- Fixed using `#[mockall::concretize]` on functions whose generic types contain
+  trait bounds, yet are still object safe.
+  ([#531](https://github.com/asomers/mockall/pull/531))
+
+- Fixed mocking methods that use raw identifiers for their names.  This was a
+  regression in 0.12.0.
+  ([#534](https://github.com/asomers/mockall/pull/534))
+
 ## [ 0.12.0 ] - 2023-12-10
 
 ### Added

README.md

@@ -29,7 +29,7 @@ your `Cargo.toml`:
 
 ```toml
 [dev-dependencies]
-mockall = "0.12.0"
+mockall = "0.12.1"
 ```
 
 Then use it like this:

mockall/Cargo.toml

@@ -1,8 +1,8 @@
 [package]
 name = "mockall"
-version = "0.12.0"
+version = "0.12.1"
 authors = ["Alan Somers <asomers@gmail.com>"]
-license = "MIT/Apache-2.0"
+license = "MIT OR Apache-2.0"
 readme = "README.md"
 repository = "https://github.com/asomers/mockall"
 categories = ["development-tools::testing"]
@@ -44,12 +44,12 @@ fragile = "2.0"
 lazy_static = "1.1"
 predicates = { version = "3.0.0", default-features = false }
 predicates-tree = "1.0"
-mockall_derive = { version = "=0.12.0", path = "../mockall_derive" }
+mockall_derive = { version = "=0.12.1", path = "../mockall_derive" }
 
 [dev-dependencies]
 async-trait = "0.1.38"
 futures = "0.3.7"
-mockall_double = { version = "^0.3.0", path = "../mockall_double" }
+mockall_double = { version = "^0.3.1", path = "../mockall_double" }
 serde = "1.0"
 serde_derive = "1.0"
 serde_json = "1.0"

mockall/tests/mock_concretize_with_bounds.rs

@@ -0,0 +1,135 @@
+// vim: tw=80
+//! Using #[concretize] on generic types with trait bounds
+#![deny(warnings)]
+
+use mockall::*;
+use std::path::{Path, PathBuf};
+
+trait AsRefMut<T: ?Sized>: AsRef<T> + AsMut<T> {}
+impl<Q, T> AsRefMut<T> for Q where Q: AsRef<T> + AsMut<T>, T: ?Sized {}
+
+mock! {
+    Foo {
+        /// Base concretized function
+        #[mockall::concretize]
+        fn foo<P: AsRef<std::path::Path> + Send>(&self, x: P);
+
+        /// With a where clause
+        #[mockall::concretize]
+        fn boom<P>(&self, x: P) where P: AsRef<std::path::Path> + Send;
+
+        /// Static function
+        #[mockall::concretize]
+        fn bang<P: AsRef<std::path::Path> + Send>(x: P);
+
+        /// Reference argument
+        #[mockall::concretize]
+        fn boomref<P: AsRef<std::path::Path> + Send>(&self, x: &P);
+
+        /// Mutable reference argument
+        #[mockall::concretize]
+        fn boom_mutref<T: AsRefMut<str> + Send>(&self, x: &mut T);
+
+        /// Slice argument
+        #[mockall::concretize]
+        fn boomv<P>(&self, x: &[P]) where P: AsRef<std::path::Path> + Send;
+    }
+}
+
+mod generic_arg {
+    use super::*;
+
+    #[test]
+    fn withf() {
+        let mut foo = MockFoo::new();
+        foo.expect_foo()
+            .withf(|p| p.as_ref() == Path::new("/tmp"))
+            .times(3)
+            .return_const(());
+        foo.foo(Path::new("/tmp"));
+        foo.foo(PathBuf::from(Path::new("/tmp")));
+        foo.foo("/tmp");
+    }
+}
+
+mod where_clause {
+    use super::*;
+
+    #[test]
+    fn withf() {
+        let mut foo = MockFoo::new();
+        foo.expect_boom()
+            .withf(|p| p.as_ref() == Path::new("/tmp"))
+            .times(3)
+            .return_const(());
+        foo.boom(Path::new("/tmp"));
+        foo.boom(PathBuf::from(Path::new("/tmp")));
+        foo.boom("/tmp");
+    }
+}
+
+mod mutable_reference_arg {
+    use super::*;
+
+    #[test]
+    fn withf() {
+        let mut foo = MockFoo::new();
+        foo.expect_boom_mutref()
+            .withf(|p| p.as_ref() == "/tmp")
+            .once()
+            .returning(|s| s.as_mut().make_ascii_uppercase());
+        let mut s = String::from("/tmp");
+        foo.boom_mutref(&mut s);
+        assert_eq!(s, "/TMP");
+    }
+}
+
+mod reference_arg {
+    use super::*;
+
+    #[test]
+    fn withf() {
+        let mut foo = MockFoo::new();
+        foo.expect_boomref()
+            .withf(|p| p.as_ref() == Path::new("/tmp"))
+            .times(3)
+            .return_const(());
+        foo.boomref(&Path::new("/tmp"));
+        foo.boomref(&PathBuf::from(Path::new("/tmp")));
+        foo.boomref(&"/tmp");
+    }
+}
+
+mod slice {
+    use super::*;
+
+    #[test]
+    fn withf() {
+        let mut foo = MockFoo::new();
+        foo.expect_boomv()
+            .withf(|v|
+                   v[0].as_ref() == Path::new("/tmp") &&
+                   v[1].as_ref() == Path::new("/mnt")
+            ).times(3)
+            .return_const(());
+        foo.boomv(&[Path::new("/tmp"), Path::new("/mnt")]);
+        foo.boomv(&[PathBuf::from("/tmp"), PathBuf::from("/mnt")]);
+        foo.boomv(&["/tmp", "/mnt"]);
+    }
+}
+
+mod static_method {
+    use super::*;
+
+    #[test]
+    fn withf() {
+        let ctx = MockFoo::bang_context();
+        ctx.expect()
+            .withf(|p| p.as_ref() == Path::new("/tmp"))
+            .times(3)
+            .return_const(());
+        MockFoo::bang(Path::new("/tmp"));
+        MockFoo::bang(PathBuf::from(Path::new("/tmp")));
+        MockFoo::bang("/tmp");
+    }
+}

mockall/tests/raw_identifier.rs

@@ -0,0 +1,72 @@
+// vim: tw=80
+//! It should be possible to mock things that use raw identifiers
+#![deny(warnings)]
+#![allow(non_camel_case_types)]
+
+use mockall::*;
+
+#[automock]
+trait r#while {
+    fn r#match(&self);
+    fn r#loop();
+}
+
+#[automock]
+pub mod r#break {
+    pub fn r#if() {unimplemented!() }
+}
+
+mock! {
+    r#do {}
+    impl r#while for r#do {
+        fn r#match(&self);
+        fn r#loop();
+    }
+}
+
+struct r#else {}
+#[automock]
+impl r#while for r#else {
+    fn r#match(&self) {unimplemented!()}
+    fn r#loop() {unimplemented!()}
+}
+
+#[test]
+fn by_ref() {
+    let mut foo = Mockwhile::new();
+    foo.expect_match()
+        .return_const(());
+    foo.r#match();
+}
+
+#[test]
+fn static_method() {
+    let ctx = Mockwhile::loop_context();
+    ctx.expect()
+        .returning(|| ());
+    Mockwhile::r#loop();
+}
+
+#[test]
+fn manual_mock() {
+    let mut foo = Mockdo::new();
+    foo.expect_match()
+        .return_const(());
+    foo.r#match();
+}
+
+#[test]
+fn module() {
+    let ctx = mock_break::if_context();
+    ctx.expect()
+        .returning(|| ());
+    mock_break::r#if();
+}
+
+#[test]
+fn trait_impl() {
+    let mut mock = Mockelse::new();
+    mock.expect_match()
+        .returning(|| ());
+    mock.r#match();
+}

mockall_derive/Cargo.toml

@@ -1,8 +1,8 @@
 [package]
 name = "mockall_derive"
-version = "0.12.0"
+version = "0.12.1"
 authors = ["Alan Somers <asomers@gmail.com>"]
-license = "MIT/Apache-2.0"
+license = "MIT OR Apache-2.0"
 repository = "https://github.com/asomers/mockall"
 categories = ["development-tools::testing"]
 keywords = ["mock", "mocking", "testing"]