0.1.2: fix path/lit str syntax, made B as Into<Option<Bytes>> instead

Author: auguwu

Cargo.toml

@@ -24,9 +24,9 @@ resolver = "2"
 members = ["crates/*"]
 
 [workspace.package]
-version = "0.1.1"
+version = "0.1.2"
 repository = "https://github.com/charted-dev/testkit"
 license = "MIT"
 edition = "2021"
-rust-version = "1.76"
+rust-version = "1.78"
 authors = ["Noel Towa <[email protected]>", "Noelware, LLC. <[email protected]>"]

crates/macros/src/attr.rs

@@ -20,15 +20,11 @@
 // SOFTWARE.
 
 use proc_macro2::Span;
-
-use syn::ExprCall;
-#[allow(unused_imports)]
 use syn::{
     bracketed,
     parse::{Parse, ParseStream},
     punctuated::Punctuated,
-    spanned::Spanned as _,
-    Expr, ExprLit, ExprPath, Ident, Lit, Path, PathSegment, Result, Token,
+    Expr, ExprCall, ExprLit, ExprPath, Ident, Lit, Path, PathSegment, Result, Token,
 };
 
 macro_rules! err {
@@ -190,16 +186,12 @@ fn router_path() -> Path {
 }
 
 fn parse_literal_or_path(input: ParseStream) -> Result<Path> {
-    let expr = input.parse::<Expr>()?;
-    if let Expr::Lit(ExprLit { lit: Lit::Str(s), .. }) = expr {
-        Ok(PathSegment::from(Ident::new(&s.value(), s.span())).into())
-    } else if let Expr::Path(ExprPath { path, .. }) = expr {
-        Ok(path)
+    let ahead = input.fork();
+    if let Ok(Lit::Str(s)) = ahead.parse() {
+        let ident = Ident::new(&s.value(), s.span());
+        Ok(PathSegment::from(ident).into())
     } else {
-        return Err(err!(
-            expr.span(),
-            "expected a literal string or valid path to a function for a teardown function"
-        ));
+        input.parse()
     }
 }
 

crates/macros/tests/ui/invalid_setup.stderr

@@ -1,17 +1,17 @@
-error: expected a literal string or valid path to a function for a teardown function
+error: expected identifier
   --> ./tests/ui/invalid_setup.rs:22:40
    |
 22 | #[charted_testkit_macros::test(setup = 123)]
    |                                        ^^^
 
-error: expected a literal string or valid path to a function for a teardown function
+error: expected identifier
   --> ./tests/ui/invalid_setup.rs:27:40
    |
 27 | #[charted_testkit_macros::test(setup = [123])]
-   |                                        ^^^^^
+   |                                        ^
 
-error: expected a literal string or valid path to a function for a teardown function
+error: expected identifier
   --> ./tests/ui/invalid_setup.rs:32:40
    |
 32 | #[charted_testkit_macros::test(setup = [true])]
-   |                                        ^^^^^^
+   |                                        ^

crates/macros/tests/ui/invalid_teardown.stderr

@@ -1,17 +1,17 @@
-error: expected a literal string or valid path to a function for a teardown function
+error: expected identifier
   --> ./tests/ui/invalid_teardown.rs:22:43
    |
 22 | #[charted_testkit_macros::test(teardown = 123)]
    |                                           ^^^
 
-error: expected a literal string or valid path to a function for a teardown function
+error: expected identifier
   --> ./tests/ui/invalid_teardown.rs:27:43
    |
 27 | #[charted_testkit_macros::test(teardown = [123])]
-   |                                           ^^^^^
+   |                                           ^
 
-error: expected a literal string or valid path to a function for a teardown function
+error: expected identifier
   --> ./tests/ui/invalid_teardown.rs:32:43
    |
 32 | #[charted_testkit_macros::test(teardown = [true])]
-   |                                           ^^^^^^
+   |                                           ^

crates/testkit/Cargo.toml

@@ -40,7 +40,7 @@ default = ["macros"]
 
 [dependencies]
 axum = "0.7.5"
-charted-testkit-macros = { version = "=0.1.1", path = "../macros", optional = true }
+charted-testkit-macros = { version = "=0.1.2", path = "../macros", optional = true }
 http-body-util = "0.1.2"
 hyper = { version = "1.4.1", features = ["client", "server", "http1"] }
 hyper-util = { version = "0.1.7", features = [

crates/testkit/src/lib.rs

@@ -167,16 +167,16 @@ impl TestContext {
     /// assert_eq!(charted_testkit::consume_body!(res), Bytes::from_static(b"Hello, world!"));
     /// # }
     /// ```
-    pub fn request<U: AsRef<str> + 'static, B: Into<Bytes>, F: Fn(&mut Request<Full<Bytes>>)>(
+    pub fn request<U: AsRef<str> + 'static, B: Into<Option<Bytes>>, F: Fn(&mut Request<Full<Bytes>>)>(
         &self,
         uri: U,
         method: Method,
-        body: Option<B>,
+        body: B,
         build: F,
     ) -> ResponseFuture {
         let addr = self.server_addr().expect("failed to get socket address");
 
-        let mut req = Request::<Full<Bytes>>::new(Full::new(body.map(Into::into).unwrap_or_default()));
+        let mut req = Request::<Full<Bytes>>::new(Full::new(body.into().unwrap_or_default()));
         *req.method_mut() = method;
         *req.uri_mut() = format!("http://{addr}{}", uri.as_ref())
             .parse()
@@ -268,6 +268,7 @@ impl TestContext {
 // Private APIs used by macros; do not use!
 #[doc(hidden)]
 pub mod __private {
+    pub use axum::http::header;
     pub use http_body_util::BodyExt;
 }
 
@@ -295,7 +296,7 @@ mod tests {
         ctx.serve(router()).await;
 
         let res = ctx
-            .request("/", Method::GET, None::<axum::body::Bytes>, |_| {})
+            .request("/", Method::GET, None, |_| {})
             .await
             .expect("unable to send request");
 

crates/testkit/src/macros.rs

@@ -36,6 +36,22 @@ macro_rules! assert_successful {
     };
 }
 
+/// Checks whenever if a [`Response`][axum::http::response::Response] failed.
+///
+/// ## Example
+/// ```rust
+/// # use axum::http::{response::Response, StatusCode};
+/// #
+/// let res = Response::builder().status(StatusCode::NOT_FOUND).body(()).expect("response to be avaliable");
+/// charted_testkit::assert_failure!(res);
+/// ```
+#[macro_export]
+macro_rules! assert_failure {
+    ($res:expr) => {
+        assert!(!($res).status().is_success());
+    };
+}
+
 /// Macro to easily assert if a given [response][axum::http::response::Response]'s status code
 /// is the same as one you provide.
 ///
@@ -95,6 +111,10 @@ macro_rules! consume_body {
 /// ```
 #[macro_export]
 macro_rules! assert_has_header {
+    ($res:expr, $header:ident) => {
+        $crate::assert_has_header!($res, $crate::__private::header::$header);
+    };
+
     ($res:expr, $header:expr) => {
         assert!($res.headers().get($header).is_some());
     };
@@ -111,6 +131,10 @@ macro_rules! assert_has_header {
 /// ```
 #[macro_export]
 macro_rules! assert_doesnt_have_header {
+    ($res:expr, $header:ident) => {
+        $crate::assert_has_header!($res, $crate::__private::header::$header);
+    };
+
     ($res:expr, $header:expr) => {
         assert!($res.headers().get($header).is_none());
     };