Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "httptest"
-version = "0.16.2"
+version = "0.16.3"
 authors = ["Glenn Griffin <ggriffiniii@gmail.com>"]
 edition = "2018"
 description = "HTTP testing facilities including a mock server"

src/server.rs

@@ -68,14 +68,19 @@ impl Server {
     /// Verify all registered expectations. Panic if any are not met, then clear
     /// all expectations leaving the server running in a clean state.
     pub fn verify_and_clear(&mut self) {
+        // If the test is already panicking don't double panic on drop.
+        // Instead simply print the message to stdout.
+        fn safe_panic(args: fmt::Arguments) {
+            if std::thread::panicking() {
+                println!("httptest: {}", args);
+            } else {
+                panic!("{}", args);
+            }
+        }
         let state = {
             let mut state = self.state.lock().expect("mutex poisoned");
             std::mem::take(&mut *state) // reset server to default state.
         };
-        if std::thread::panicking() {
-            // If the test is already panicking don't double panic on drop.
-            return;
-        }
         for expectation in state.expected.iter() {
             if !hit_count_is_valid(expectation.times, expectation.hit_count) {
                 let unexpected_requests_message = if state.unexpected_requests.is_empty() {
@@ -88,20 +93,20 @@ impl Server {
                     )
                 };
 
-                panic!(
+                safe_panic(format_args!(
                     "Unexpected number of requests for matcher '{:?}'; received {}; expected {}. {}",
                     matcher_name(&*expectation.matcher),
                     expectation.hit_count,
                     RangeDisplay(expectation.times),
                     unexpected_requests_message,
-                );
+                ));
             }
         }
         if !state.unexpected_requests.is_empty() {
-            panic!(
+            safe_panic(format_args!(
                 "received the following unexpected requests:\n{:#?}",
                 &state.unexpected_requests
-            );
+            ));
         }
     }
 }

tests/tests.rs

@@ -272,6 +272,30 @@ fn test_outside_of_tokio_context() {
     let _server = httptest::Server::run();
 }
 
+// verify the server does not produce a crash if the server is dropped due to a
+// panic. This can happen if the test panic's and the panic subsequently Drop's
+// the server. On Drop the server typically verifies the expectations and
+// panic's if any are unmet, but that would lead to a double panic which causes
+// an immediate crash.
+#[test]
+#[should_panic]
+fn test_dont_double_panic() {
+    let _ = pretty_env_logger::try_init();
+    // Setup a server to expect a single GET /foo request.
+    let server = httptest::Server::run();
+    server.expect(
+        Expectation::matching(all_of![request::method("GET"), request::path("/foo")])
+            .respond_with(status_code(200)),
+    );
+
+    // test panics before any server expectation validation happens.
+    assert_eq!(1, 2);
+
+    // panic above will drop the server which would normally panic due to the
+    // expectation not being met. However since that would cause a double panic
+    // the server will simply print the error message to stdout instead.
+}
+
 #[tokio::test]
 async fn test_server_custom() {
     let _ = pretty_env_logger::try_init();