chore: run cargo clippy --fix

46ki75 · 46ki75 · commit 613734469cce · 2025-09-10T21:48:33.000+09:00
diff --git a/lambda-events/src/encodings/http.rs b/lambda-events/src/encodings/http.rs
@@ -264,39 +264,39 @@ mod tests {
     fn from_str() {
         match Body::from(String::from("foo").as_str()) {
             Body::Text(_) => (),
-            not => panic!("expected Body::Text(...) got {:?}", not),
+            not => panic!("expected Body::Text(...) got {not:?}"),
         }
     }
 
     #[test]
     fn from_string() {
         match Body::from(String::from("foo")) {
             Body::Text(_) => (),
-            not => panic!("expected Body::Text(...) got {:?}", not),
+            not => panic!("expected Body::Text(...) got {not:?}"),
         }
     }
 
     #[test]
     fn from_cow_str() {
         match Body::from(Cow::from("foo")) {
             Body::Text(_) => (),
-            not => panic!("expected Body::Text(...) got {:?}", not),
+            not => panic!("expected Body::Text(...) got {not:?}"),
         }
     }
 
     #[test]
     fn from_cow_bytes() {
         match Body::from(Cow::from("foo".as_bytes())) {
             Body::Binary(_) => (),
-            not => panic!("expected Body::Binary(...) got {:?}", not),
+            not => panic!("expected Body::Binary(...) got {not:?}"),
         }
     }
 
     #[test]
     fn from_bytes() {
         match Body::from("foo".as_bytes()) {
             Body::Binary(_) => (),
-            not => panic!("expected Body::Binary(...) got {:?}", not),
+            not => panic!("expected Body::Binary(...) got {not:?}"),
         }
     }
 
@@ -325,12 +325,12 @@ mod tests {
     fn serialize_from_maybe_encoded() {
         match Body::from_maybe_encoded(false, "foo") {
             Body::Text(_) => (),
-            not => panic!("expected Body::Text(...) got {:?}", not),
+            not => panic!("expected Body::Text(...) got {not:?}"),
         }
 
         match Body::from_maybe_encoded(true, "Zm9v") {
             Body::Binary(b) => assert_eq!(&[102, 111, 111], b.as_slice()),
-            not => panic!("expected Body::Text(...) got {:?}", not),
+            not => panic!("expected Body::Text(...) got {not:?}"),
         }
     }
 }
diff --git a/lambda-events/src/event/dynamodb/attributes.rs b/lambda-events/src/event/dynamodb/attributes.rs
@@ -15,7 +15,7 @@ mod test {
         let attr: AttributeValue = serde_json::from_value(value.clone()).unwrap();
         match attr {
             AttributeValue::Null(true) => {}
-            other => panic!("unexpected value {:?}", other),
+            other => panic!("unexpected value {other:?}"),
         }
 
         let reparsed = serde_json::to_value(attr).unwrap();
@@ -31,7 +31,7 @@ mod test {
         let attr: AttributeValue = serde_json::from_value(value.clone()).unwrap();
         match attr {
             AttributeValue::S(ref s) => assert_eq!("value", s.as_str()),
-            other => panic!("unexpected value {:?}", other),
+            other => panic!("unexpected value {other:?}"),
         }
 
         let reparsed = serde_json::to_value(attr).unwrap();
@@ -47,7 +47,7 @@ mod test {
         let attr: AttributeValue = serde_json::from_value(value.clone()).unwrap();
         match attr {
             AttributeValue::N(ref n) => assert_eq!("123.45", n.as_str()),
-            other => panic!("unexpected value {:?}", other),
+            other => panic!("unexpected value {other:?}"),
         }
 
         let reparsed = serde_json::to_value(attr).unwrap();
@@ -68,7 +68,7 @@ mod test {
                     .unwrap();
                 assert_eq!(&expected, b)
             }
-            other => panic!("unexpected value {:?}", other),
+            other => panic!("unexpected value {other:?}"),
         }
 
         let reparsed = serde_json::to_value(attr).unwrap();
@@ -84,7 +84,7 @@ mod test {
         let attr: AttributeValue = serde_json::from_value(value.clone()).unwrap();
         match attr {
             AttributeValue::Bool(b) => assert!(b),
-            other => panic!("unexpected value {:?}", other),
+            other => panic!("unexpected value {other:?}"),
         }
 
         let reparsed = serde_json::to_value(attr).unwrap();
@@ -103,7 +103,7 @@ mod test {
                 let expected = vec!["Giraffe", "Hippo", "Zebra"];
                 assert_eq!(expected, s.iter().collect::<Vec<_>>());
             }
-            other => panic!("unexpected value {:?}", other),
+            other => panic!("unexpected value {other:?}"),
         }
 
         let reparsed = serde_json::to_value(attr).unwrap();
@@ -122,7 +122,7 @@ mod test {
                 let expected = vec!["42.2", "-19", "7.5", "3.14"];
                 assert_eq!(expected, s.iter().collect::<Vec<_>>());
             }
-            other => panic!("unexpected value {:?}", other),
+            other => panic!("unexpected value {other:?}"),
         }
 
         let reparsed = serde_json::to_value(attr).unwrap();
@@ -144,7 +144,7 @@ mod test {
                     .collect::<Vec<_>>();
                 assert_eq!(&expected, s);
             }
-            other => panic!("unexpected value {:?}", other),
+            other => panic!("unexpected value {other:?}"),
         }
 
         let reparsed = serde_json::to_value(attr).unwrap();
@@ -167,7 +167,7 @@ mod test {
                 ];
                 assert_eq!(&expected, s);
             }
-            other => panic!("unexpected value {:?}", other),
+            other => panic!("unexpected value {other:?}"),
         }
 
         let reparsed = serde_json::to_value(attr).unwrap();
@@ -188,7 +188,7 @@ mod test {
                 expected.insert("Age".into(), AttributeValue::N("35".into()));
                 assert_eq!(expected, s);
             }
-            other => panic!("unexpected value {:?}", other),
+            other => panic!("unexpected value {other:?}"),
         }
     }
 }
diff --git a/lambda-events/src/event/sns/mod.rs b/lambda-events/src/event/sns/mod.rs
@@ -412,7 +412,7 @@ mod test {
         }
 
         let parsed: SnsEventObj<CustStruct> = serde_json::from_slice(data).unwrap();
-        println!("{:?}", parsed);
+        println!("{parsed:?}");
 
         assert_eq!(parsed.records[0].sns.message.foo, "Hello world!");
         assert_eq!(parsed.records[0].sns.message.bar, 123);
diff --git a/lambda-http/src/deserializer.rs b/lambda-http/src/deserializer.rs
@@ -61,7 +61,7 @@ mod tests {
             LambdaRequest::ApiGatewayV1(req) => {
                 assert_eq!("12345678912", req.request_context.account_id.unwrap());
             }
-            other => panic!("unexpected request variant: {:?}", other),
+            other => panic!("unexpected request variant: {other:?}"),
         }
     }
 
@@ -74,7 +74,7 @@ mod tests {
             LambdaRequest::ApiGatewayV2(req) => {
                 assert_eq!("123456789012", req.request_context.account_id.unwrap());
             }
-            other => panic!("unexpected request variant: {:?}", other),
+            other => panic!("unexpected request variant: {other:?}"),
         }
     }
 
@@ -87,7 +87,7 @@ mod tests {
             LambdaRequest::ApiGatewayV1(req) => {
                 assert_eq!("123456789012", req.request_context.account_id.unwrap());
             }
-            other => panic!("unexpected request variant: {:?}", other),
+            other => panic!("unexpected request variant: {other:?}"),
         }
     }
 
@@ -100,7 +100,7 @@ mod tests {
             LambdaRequest::ApiGatewayV2(req) => {
                 assert_eq!("123456789012", req.request_context.account_id.unwrap());
             }
-            other => panic!("unexpected request variant: {:?}", other),
+            other => panic!("unexpected request variant: {other:?}"),
         }
     }
 
@@ -118,7 +118,7 @@ mod tests {
                     req.request_context.elb.target_group_arn.unwrap()
                 );
             }
-            other => panic!("unexpected request variant: {:?}", other),
+            other => panic!("unexpected request variant: {other:?}"),
         }
     }
 
@@ -132,7 +132,7 @@ mod tests {
             LambdaRequest::WebSocket(req) => {
                 assert_eq!("CONNECT", req.request_context.event_type.unwrap());
             }
-            other => panic!("unexpected request variant: {:?}", other),
+            other => panic!("unexpected request variant: {other:?}"),
         }
     }
 
diff --git a/lambda-runtime/src/runtime.rs b/lambda-runtime/src/runtime.rs
@@ -369,7 +369,7 @@ mod endpoint_tests {
         });
         let next_response = server.mock(|when, then| {
             when.method(POST)
-                .path(format!("/2018-06-01/runtime/invocation/{}/response", request_id))
+                .path(format!("/2018-06-01/runtime/invocation/{request_id}/response"))
                 .body("{}");
             then.status(200).body("");
         });
@@ -440,7 +440,7 @@ mod endpoint_tests {
 
         let next_response = server.mock(|when, then| {
             when.method(POST)
-                .path(format!("/2018-06-01/runtime/invocation/{}/error", request_id))
+                .path(format!("/2018-06-01/runtime/invocation/{request_id}/error"))
                 .header("lambda-runtime-function-error-type", "unhandled");
             then.status(200).body("");
         });

Original file line number	Diff line number	Diff line change
`@@ -264,39 +264,39 @@ mod tests {`
`264`	`264`	`fn from_str() {`
`265`	`265`	`match Body::from(String::from("foo").as_str()) {`
`266`	`266`	`Body::Text(_) => (),`
`267`		`- not => panic!("expected Body::Text(...) got {:?}", not),`
	`267`	`+ not => panic!("expected Body::Text(...) got {not:?}"),`
`268`	`268`	`}`
`269`	`269`	`}`
`270`	`270`
`271`	`271`	`#[test]`
`272`	`272`	`fn from_string() {`
`273`	`273`	`match Body::from(String::from("foo")) {`
`274`	`274`	`Body::Text(_) => (),`
`275`		`- not => panic!("expected Body::Text(...) got {:?}", not),`
	`275`	`+ not => panic!("expected Body::Text(...) got {not:?}"),`
`276`	`276`	`}`
`277`	`277`	`}`
`278`	`278`
`279`	`279`	`#[test]`
`280`	`280`	`fn from_cow_str() {`
`281`	`281`	`match Body::from(Cow::from("foo")) {`
`282`	`282`	`Body::Text(_) => (),`
`283`		`- not => panic!("expected Body::Text(...) got {:?}", not),`
	`283`	`+ not => panic!("expected Body::Text(...) got {not:?}"),`
`284`	`284`	`}`
`285`	`285`	`}`
`286`	`286`
`287`	`287`	`#[test]`
`288`	`288`	`fn from_cow_bytes() {`
`289`	`289`	`match Body::from(Cow::from("foo".as_bytes())) {`
`290`	`290`	`Body::Binary(_) => (),`
`291`		`- not => panic!("expected Body::Binary(...) got {:?}", not),`
	`291`	`+ not => panic!("expected Body::Binary(...) got {not:?}"),`
`292`	`292`	`}`
`293`	`293`	`}`
`294`	`294`
`295`	`295`	`#[test]`
`296`	`296`	`fn from_bytes() {`
`297`	`297`	`match Body::from("foo".as_bytes()) {`
`298`	`298`	`Body::Binary(_) => (),`
`299`		`- not => panic!("expected Body::Binary(...) got {:?}", not),`
	`299`	`+ not => panic!("expected Body::Binary(...) got {not:?}"),`
`300`	`300`	`}`
`301`	`301`	`}`
`302`	`302`
`@@ -325,12 +325,12 @@ mod tests {`
`325`	`325`	`fn serialize_from_maybe_encoded() {`
`326`	`326`	`match Body::from_maybe_encoded(false, "foo") {`
`327`	`327`	`Body::Text(_) => (),`
`328`		`- not => panic!("expected Body::Text(...) got {:?}", not),`
	`328`	`+ not => panic!("expected Body::Text(...) got {not:?}"),`
`329`	`329`	`}`
`330`	`330`
`331`	`331`	`match Body::from_maybe_encoded(true, "Zm9v") {`
`332`	`332`	`Body::Binary(b) => assert_eq!(&[102, 111, 111], b.as_slice()),`
`333`		`- not => panic!("expected Body::Text(...) got {:?}", not),`
	`333`	`+ not => panic!("expected Body::Text(...) got {not:?}"),`
`334`	`334`	`}`
`335`	`335`	`}`
`336`	`336`	`}`
Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,7 @@ mod test {`
`15`	`15`	`let attr: AttributeValue = serde_json::from_value(value.clone()).unwrap();`
`16`	`16`	`match attr {`
`17`	`17`	`AttributeValue::Null(true) => {}`
`18`		`- other => panic!("unexpected value {:?}", other),`
	`18`	`+ other => panic!("unexpected value {other:?}"),`
`19`	`19`	`}`
`20`	`20`
`21`	`21`	`let reparsed = serde_json::to_value(attr).unwrap();`
`@@ -31,7 +31,7 @@ mod test {`
`31`	`31`	`let attr: AttributeValue = serde_json::from_value(value.clone()).unwrap();`
`32`	`32`	`match attr {`
`33`	`33`	`AttributeValue::S(ref s) => assert_eq!("value", s.as_str()),`
`34`		`- other => panic!("unexpected value {:?}", other),`
	`34`	`+ other => panic!("unexpected value {other:?}"),`
`35`	`35`	`}`
`36`	`36`
`37`	`37`	`let reparsed = serde_json::to_value(attr).unwrap();`
`@@ -47,7 +47,7 @@ mod test {`
`47`	`47`	`let attr: AttributeValue = serde_json::from_value(value.clone()).unwrap();`
`48`	`48`	`match attr {`
`49`	`49`	`AttributeValue::N(ref n) => assert_eq!("123.45", n.as_str()),`
`50`		`- other => panic!("unexpected value {:?}", other),`
	`50`	`+ other => panic!("unexpected value {other:?}"),`
`51`	`51`	`}`
`52`	`52`
`53`	`53`	`let reparsed = serde_json::to_value(attr).unwrap();`
`@@ -68,7 +68,7 @@ mod test {`
`68`	`68`	`.unwrap();`
`69`	`69`	`assert_eq!(&expected, b)`
`70`	`70`	`}`
`71`		`- other => panic!("unexpected value {:?}", other),`
	`71`	`+ other => panic!("unexpected value {other:?}"),`
`72`	`72`	`}`
`73`	`73`
`74`	`74`	`let reparsed = serde_json::to_value(attr).unwrap();`
`@@ -84,7 +84,7 @@ mod test {`
`84`	`84`	`let attr: AttributeValue = serde_json::from_value(value.clone()).unwrap();`
`85`	`85`	`match attr {`
`86`	`86`	`AttributeValue::Bool(b) => assert!(b),`
`87`		`- other => panic!("unexpected value {:?}", other),`
	`87`	`+ other => panic!("unexpected value {other:?}"),`
`88`	`88`	`}`
`89`	`89`
`90`	`90`	`let reparsed = serde_json::to_value(attr).unwrap();`
`@@ -103,7 +103,7 @@ mod test {`
`103`	`103`	`let expected = vec!["Giraffe", "Hippo", "Zebra"];`
`104`	`104`	`assert_eq!(expected, s.iter().collect::<Vec<_>>());`
`105`	`105`	`}`
`106`		`- other => panic!("unexpected value {:?}", other),`
	`106`	`+ other => panic!("unexpected value {other:?}"),`
`107`	`107`	`}`
`108`	`108`
`109`	`109`	`let reparsed = serde_json::to_value(attr).unwrap();`
`@@ -122,7 +122,7 @@ mod test {`
`122`	`122`	`let expected = vec!["42.2", "-19", "7.5", "3.14"];`
`123`	`123`	`assert_eq!(expected, s.iter().collect::<Vec<_>>());`
`124`	`124`	`}`
`125`		`- other => panic!("unexpected value {:?}", other),`
	`125`	`+ other => panic!("unexpected value {other:?}"),`
`126`	`126`	`}`
`127`	`127`
`128`	`128`	`let reparsed = serde_json::to_value(attr).unwrap();`
`@@ -144,7 +144,7 @@ mod test {`
`144`	`144`	`.collect::<Vec<_>>();`
`145`	`145`	`assert_eq!(&expected, s);`
`146`	`146`	`}`
`147`		`- other => panic!("unexpected value {:?}", other),`
	`147`	`+ other => panic!("unexpected value {other:?}"),`
`148`	`148`	`}`
`149`	`149`
`150`	`150`	`let reparsed = serde_json::to_value(attr).unwrap();`
`@@ -167,7 +167,7 @@ mod test {`
`167`	`167`	`];`
`168`	`168`	`assert_eq!(&expected, s);`
`169`	`169`	`}`
`170`		`- other => panic!("unexpected value {:?}", other),`
	`170`	`+ other => panic!("unexpected value {other:?}"),`
`171`	`171`	`}`
`172`	`172`
`173`	`173`	`let reparsed = serde_json::to_value(attr).unwrap();`
`@@ -188,7 +188,7 @@ mod test {`
`188`	`188`	`expected.insert("Age".into(), AttributeValue::N("35".into()));`
`189`	`189`	`assert_eq!(expected, s);`
`190`	`190`	`}`
`191`		`- other => panic!("unexpected value {:?}", other),`
	`191`	`+ other => panic!("unexpected value {other:?}"),`
`192`	`192`	`}`
`193`	`193`	`}`
`194`	`194`	`}`
Original file line number	Diff line number	Diff line change
`@@ -412,7 +412,7 @@ mod test {`
`412`	`412`	`}`
`413`	`413`
`414`	`414`	`let parsed: SnsEventObj<CustStruct> = serde_json::from_slice(data).unwrap();`
`415`		`- println!("{:?}", parsed);`
	`415`	`+ println!("{parsed:?}");`
`416`	`416`
`417`	`417`	`assert_eq!(parsed.records[0].sns.message.foo, "Hello world!");`
`418`	`418`	`assert_eq!(parsed.records[0].sns.message.bar, 123);`
Original file line number	Diff line number	Diff line change
`@@ -61,7 +61,7 @@ mod tests {`
`61`	`61`	`LambdaRequest::ApiGatewayV1(req) => {`
`62`	`62`	`assert_eq!("12345678912", req.request_context.account_id.unwrap());`
`63`	`63`	`}`
`64`		`- other => panic!("unexpected request variant: {:?}", other),`
	`64`	`+ other => panic!("unexpected request variant: {other:?}"),`
`65`	`65`	`}`
`66`	`66`	`}`
`67`	`67`
`@@ -74,7 +74,7 @@ mod tests {`
`74`	`74`	`LambdaRequest::ApiGatewayV2(req) => {`
`75`	`75`	`assert_eq!("123456789012", req.request_context.account_id.unwrap());`
`76`	`76`	`}`
`77`		`- other => panic!("unexpected request variant: {:?}", other),`
	`77`	`+ other => panic!("unexpected request variant: {other:?}"),`
`78`	`78`	`}`
`79`	`79`	`}`
`80`	`80`
`@@ -87,7 +87,7 @@ mod tests {`
`87`	`87`	`LambdaRequest::ApiGatewayV1(req) => {`
`88`	`88`	`assert_eq!("123456789012", req.request_context.account_id.unwrap());`
`89`	`89`	`}`
`90`		`- other => panic!("unexpected request variant: {:?}", other),`
	`90`	`+ other => panic!("unexpected request variant: {other:?}"),`
`91`	`91`	`}`
`92`	`92`	`}`
`93`	`93`
`@@ -100,7 +100,7 @@ mod tests {`
`100`	`100`	`LambdaRequest::ApiGatewayV2(req) => {`
`101`	`101`	`assert_eq!("123456789012", req.request_context.account_id.unwrap());`
`102`	`102`	`}`
`103`		`- other => panic!("unexpected request variant: {:?}", other),`
	`103`	`+ other => panic!("unexpected request variant: {other:?}"),`
`104`	`104`	`}`
`105`	`105`	`}`
`106`	`106`
`@@ -118,7 +118,7 @@ mod tests {`
`118`	`118`	`req.request_context.elb.target_group_arn.unwrap()`
`119`	`119`	`);`
`120`	`120`	`}`
`121`		`- other => panic!("unexpected request variant: {:?}", other),`
	`121`	`+ other => panic!("unexpected request variant: {other:?}"),`
`122`	`122`	`}`
`123`	`123`	`}`
`124`	`124`
`@@ -132,7 +132,7 @@ mod tests {`
`132`	`132`	`LambdaRequest::WebSocket(req) => {`
`133`	`133`	`assert_eq!("CONNECT", req.request_context.event_type.unwrap());`
`134`	`134`	`}`
`135`		`- other => panic!("unexpected request variant: {:?}", other),`
	`135`	`+ other => panic!("unexpected request variant: {other:?}"),`
`136`	`136`	`}`
`137`	`137`	`}`
`138`	`138`