Update to latest crates, fix tests, fix clippy lints

Cargo.toml

@@ -30,13 +30,13 @@ exclude = [
 
 [dependencies]
 anyhow = "1.0"
-aws-config = "0.55.0"
-aws-sdk-s3 = "0.25.0"
-aws-types = "0.55.0"
+aws-config = "1.5.8"
+aws-sdk-s3 = "1.56.0"
+aws-types = "1.3.3"
 colored = "2"
 csv = "1.2"
 log = "0.4"
-pretty_env_logger = "0.4"
+pretty_env_logger = "0.5"
 serde_json = "1.0"
 
 [dependencies.clap]

src/s3/acl.rs

@@ -17,9 +17,7 @@ pub enum BucketAcl {
 
 impl From<GetBucketAclOutput> for BucketAcl {
     fn from(output: GetBucketAclOutput) -> Self {
-        let Some(grants) = output.grants() else {
-            return Self::Private;
-        };
+        let grants = output.grants();
 
         // Might have no grants
         if grants.is_empty() {
@@ -90,7 +88,8 @@ mod tests {
             .id("lovelace")
             .r#type(Type::from("N/A"))
             .uri(PRIVATE_GROUP)
-            .build();
+            .build()
+            .unwrap();
 
         let grant = Grant::builder()
             .grantee(grantee)
@@ -122,7 +121,8 @@ mod tests {
             .id("lovelace")
             .r#type(Type::from("N/A"))
             .uri(PUBLIC_GROUP)
-            .build();
+            .build()
+            .unwrap();
 
         let grant = Grant::builder()
             .grantee(grantee)

src/s3/client.rs

@@ -12,6 +12,7 @@ use crate::s3::{
     Reports,
 };
 use anyhow::Result;
+use aws_config::BehaviorVersion;
 use aws_config::meta::region::RegionProviderChain;
 use aws_sdk_s3::client::Client as S3Client;
 use aws_sdk_s3::error::SdkError;
@@ -52,15 +53,15 @@ impl Client {
             .or_default_provider()
             .or_else("us-east-1");
 
-        let config = aws_config::from_env()
+        let config = aws_config::defaults(BehaviorVersion::latest())
             .region(region_provider)
             .load()
             .await;
 
         let client = S3Client::new(&config);
 
         Self {
-            client: client,
+            client,
         }
     }
 
@@ -75,21 +76,20 @@ impl Client {
             .send()
             .await?;
 
-        let bucket_names = output.buckets().map_or_else(Vec::new, |buckets| {
-            buckets
-                .iter()
-                .filter_map(aws_sdk_s3::types::Bucket::name)
-                .collect()
-        });
+        let bucket_names: Vec<&str> = output
+            .buckets()
+            .iter()
+            .filter_map(aws_sdk_s3::types::Bucket::name)
+            .collect();
 
         let mut buckets: Vec<Bucket> = Vec::new();
 
         for bucket in bucket_names {
             let region = self.get_bucket_region(bucket).await?;
 
             let bucket = Bucket {
+                region,
                 name:   bucket.to_string(),
-                region: region,
             };
 
             buckets.push(bucket);
@@ -323,7 +323,7 @@ impl Client {
 
         // Both of these come from the Versioning API, so enabled either of
         // these needs to get the bucket versioning.
-        let versioning_audits = vec![
+        let versioning_audits = [
             Audit::MfaDelete,
             Audit::Versioning,
         ];
@@ -349,14 +349,14 @@ impl Client {
         };
 
         let report = Report {
-            name:                bucket.into(),
-            acl:                 acl,
-            encryption:          encryption,
-            logging:             logging,
-            policy:              policy,
-            public_access_block: public_access_block,
-            versioning:          versioning,
-            website:             website,
+            acl,
+            encryption,
+            logging,
+            policy,
+            public_access_block,
+            versioning,
+            website,
+            name: bucket.into(),
         };
 
         Ok(report)
@@ -373,8 +373,8 @@ impl Client {
             Some(bucket) => {
                 let region = self.get_bucket_region(&bucket).await?;
                 let bucket = Bucket {
+                    region,
                     name: bucket,
-                    region: region,
                 };
 
                 vec![bucket]

src/s3/encryption.rs

@@ -25,8 +25,9 @@ type EncryptionResult = Result<
 // Could probably replace a log of this with some .and_then shenanigans.
 impl From<GetBucketEncryptionOutput> for BucketEncryption {
     fn from(output: GetBucketEncryptionOutput) -> Self {
-        let sse_algorithm = output.server_side_encryption_configuration
-            .and_then(|config| config.rules)
+        let sse_algorithm = output
+            .server_side_encryption_configuration
+            .map(|config| config.rules)
             .and_then(|rules| {
                 if rules.is_empty() {
                     None
@@ -37,7 +38,7 @@ impl From<GetBucketEncryptionOutput> for BucketEncryption {
                 }
             })
             .and_then(|rule| rule.apply_server_side_encryption_by_default)
-            .and_then(|rule| rule.sse_algorithm);
+            .map(|rule| rule.sse_algorithm);
 
         match sse_algorithm {
             None                               => Self::None,
@@ -106,15 +107,17 @@ mod tests {
     fn test_from_default_encryption() {
         let default = ServerSideEncryptionByDefault::builder()
             .sse_algorithm(ServerSideEncryption::Aes256)
-            .build();
+            .build()
+            .unwrap();
 
         let rule = ServerSideEncryptionRule::builder()
             .apply_server_side_encryption_by_default(default)
             .build();
 
         let configuration = ServerSideEncryptionConfiguration::builder()
             .rules(rule)
-            .build();
+            .build()
+            .unwrap();
 
         let output = GetBucketEncryptionOutput::builder()
             .server_side_encryption_configuration(configuration)
@@ -132,15 +135,17 @@ mod tests {
         let default = ServerSideEncryptionByDefault::builder()
             .kms_master_key_id("arn:aws:foo:bar:test")
             .sse_algorithm(ServerSideEncryption::AwsKms)
-            .build();
+            .build()
+            .unwrap();
 
         let rule = ServerSideEncryptionRule::builder()
             .apply_server_side_encryption_by_default(default)
             .build();
 
         let configuration = ServerSideEncryptionConfiguration::builder()
             .rules(rule)
-            .build();
+            .build()
+            .unwrap();
 
         let output = GetBucketEncryptionOutput::builder()
             .server_side_encryption_configuration(configuration)
@@ -157,15 +162,17 @@ mod tests {
     fn test_from_unknown_encryption() {
         let default = ServerSideEncryptionByDefault::builder()
             .sse_algorithm(ServerSideEncryption::from("wat"))
-            .build();
+            .build()
+            .unwrap();
 
         let rule = ServerSideEncryptionRule::builder()
             .apply_server_side_encryption_by_default(default)
             .build();
 
         let configuration = ServerSideEncryptionConfiguration::builder()
             .rules(rule)
-            .build();
+            .build()
+            .unwrap();
 
         let output = GetBucketEncryptionOutput::builder()
             .server_side_encryption_configuration(configuration)
@@ -182,7 +189,8 @@ mod tests {
     fn test_from_no_rules() {
         let configuration = ServerSideEncryptionConfiguration::builder()
             .set_rules(Some(Vec::new()))
-            .build();
+            .build()
+            .unwrap();
 
         let output = GetBucketEncryptionOutput::builder()
             .server_side_encryption_configuration(configuration)

src/s3/logging.rs

@@ -12,8 +12,7 @@ pub enum BucketLogging {
 impl From<GetBucketLoggingOutput> for BucketLogging {
     fn from(output: GetBucketLoggingOutput) -> Self {
         output.logging_enabled.map_or(Self::Disabled, |logging| {
-            let target = logging.target_bucket.expect("target bucket");
-            Self::Enabled(target)
+            Self::Enabled(logging.target_bucket)
         })
     }
 }
@@ -44,7 +43,9 @@ mod tests {
     fn test_from_for_bucket_logging_enabled() {
         let logging_enabled = LoggingEnabled::builder()
             .target_bucket("foo")
-            .build();
+            .target_prefix("test")
+            .build()
+            .unwrap();
 
         let output = GetBucketLoggingOutput::builder()
             .set_logging_enabled(Some(logging_enabled))

src/s3/policy.rs

@@ -139,9 +139,10 @@ impl TryFrom<GetBucketPolicyOutput> for BucketPolicy {
         let statements_array = statements.as_array()
             .expect("Bucket policy has no Statements element");
 
-        for statement in statements_array.iter() {
+        for statement in statements_array {
             // Policies MUST have an effect. This should never fail.
-            let effect = statement["Effect"].as_str()
+            let effect = statement["Effect"]
+                .as_str()
                 .expect("Bucket policy statement does not have an explicit Effect");
 
             // If we're denying stuff, wildcards are fine and we can proceed
@@ -162,8 +163,8 @@ impl TryFrom<GetBucketPolicyOutput> for BucketPolicy {
         }
 
         Ok(Self {
-            actions: actions,
-            principals: principals,
+            actions,
+            principals,
         })
     }
 }

src/s3/public_access_block.rs

@@ -58,10 +58,10 @@ impl From<GetPublicAccessBlockOutput> for PublicAccessBlock {
         let config = output.public_access_block_configuration
             .expect("public_access_block_configuration");
 
-        let block_public_acls = config.block_public_acls;
-        let block_public_policy = config.block_public_policy;
-        let ignore_public_acls = config.ignore_public_acls;
-        let restrict_public_buckets = config.restrict_public_buckets;
+        let block_public_acls = config.block_public_acls.unwrap_or(false);
+        let block_public_policy = config.block_public_policy.unwrap_or(false);
+        let ignore_public_acls = config.ignore_public_acls.unwrap_or(false);
+        let restrict_public_buckets = config.restrict_public_buckets.unwrap_or(false);
 
         let blocks = vec![
             PublicAccessBlockType::BlockPublicAcls(block_public_acls),