Move TestS3 into a submodule

Author: jyn514

src/storage/s3.rs

@@ -10,6 +10,11 @@ use std::io::Read;
 use time::Timespec;
 use tokio::runtime::Runtime;
 
+#[cfg(test)]
+mod test_s3;
+#[cfg(test)]
+pub(crate) use test_s3::TestS3;
+
 pub(crate) static S3_BUCKET_NAME: &str = "rust-docs-rs";
 
 pub(crate) struct S3Backend<'a> {
@@ -95,10 +100,8 @@ impl<'a> S3Backend<'a> {
     }
 }
 
-// public for testing
-pub(crate) const TIME_FMT: &str = "%a, %d %b %Y %H:%M:%S %Z";
-
 fn parse_timespec(raw: &str) -> Result<Timespec, Error> {
+    const TIME_FMT: &str = "%a, %d %b %Y %H:%M:%S %Z";
     Ok(time::strptime(raw, TIME_FMT)?.to_timespec())
 }
 
@@ -129,90 +132,11 @@ pub(crate) fn s3_client() -> Option<S3Client> {
 }
 
 #[cfg(test)]
-pub(crate) mod tests {
+pub(crate) mod test {
     use super::*;
-    use crate::storage::test::*;
     use crate::test::*;
-
-    use crate::storage::s3::S3Backend;
-    use rusoto_s3::{
-        CreateBucketRequest, DeleteBucketRequest, DeleteObjectRequest, ListObjectsRequest, S3,
-    };
-
-    use std::cell::RefCell;
     use std::slice;
 
-    pub(crate) struct TestS3(RefCell<S3Backend<'static>>);
-
-    impl TestS3 {
-        pub(crate) fn new() -> Self {
-            // A random bucket name is generated and used for the current connection.
-            // This allows each test to create a fresh bucket to test with.
-            let bucket = format!("docs-rs-test-bucket-{}", rand::random::<u64>());
-            let client = s3_client().unwrap();
-            client
-                .create_bucket(CreateBucketRequest {
-                    bucket: bucket.clone(),
-                    ..Default::default()
-                })
-                .sync()
-                .expect("failed to create test bucket");
-            let bucket = Box::leak(bucket.into_boxed_str());
-            TestS3(RefCell::new(S3Backend::new(client, bucket)))
-        }
-        pub(crate) fn upload(&self, blobs: &[Blob]) -> Result<(), Error> {
-            self.0.borrow_mut().store_batch(blobs)
-        }
-        fn assert_404(&self, path: &'static str) {
-            use rusoto_core::RusotoError;
-            use rusoto_s3::GetObjectError;
-
-            let err = self.0.borrow().get(path).unwrap_err();
-            match err
-                .downcast_ref::<RusotoError<GetObjectError>>()
-                .expect("wanted GetObject")
-            {
-                RusotoError::Unknown(http) => assert_eq!(http.status, 404),
-                RusotoError::Service(GetObjectError::NoSuchKey(_)) => {}
-                x => panic!("wrong error: {:?}", x),
-            };
-        }
-        pub(crate) fn assert_blob(&self, blob: &Blob, path: &str) {
-            let actual = self.0.borrow().get(path).unwrap();
-            assert_blob_eq(blob, &actual);
-        }
-    }
-
-    impl Drop for TestS3 {
-        fn drop(&mut self) {
-            // delete the bucket when the test ends
-            // this has to delete all the objects in the bucket first or min.io will give an error
-            let inner = self.0.borrow();
-            let list_req = ListObjectsRequest {
-                bucket: inner.bucket.to_owned(),
-                ..Default::default()
-            };
-            let objects = inner.client.list_objects(list_req).sync().unwrap();
-            assert!(!objects.is_truncated.unwrap_or(false));
-            for path in objects.contents.unwrap() {
-                let delete_req = DeleteObjectRequest {
-                    bucket: inner.bucket.to_owned(),
-                    key: path.key.unwrap(),
-                    ..Default::default()
-                };
-                inner.client.delete_object(delete_req).sync().unwrap();
-            }
-            let delete_req = DeleteBucketRequest {
-                bucket: inner.bucket.to_owned(),
-            };
-            inner
-                .client
-                .delete_bucket(delete_req)
-                .sync()
-                .expect("failed to delete test bucket");
-        }
-    }
-
     #[test]
     fn test_parse_timespec() {
         // Test valid conversions

src/storage/s3/test_s3.rs

@@ -0,0 +1,77 @@
+use super::*;
+use crate::storage::test::assert_blob_eq;
+use rusoto_s3::{
+    CreateBucketRequest, DeleteBucketRequest, DeleteObjectRequest, ListObjectsRequest, S3,
+};
+use std::cell::RefCell;
+
+pub(crate) struct TestS3(RefCell<S3Backend<'static>>);
+
+impl TestS3 {
+    pub(crate) fn new() -> Self {
+        // A random bucket name is generated and used for the current connection.
+        // This allows each test to create a fresh bucket to test with.
+        let bucket = format!("docs-rs-test-bucket-{}", rand::random::<u64>());
+        let client = s3_client().unwrap();
+        client
+            .create_bucket(CreateBucketRequest {
+                bucket: bucket.clone(),
+                ..Default::default()
+            })
+            .sync()
+            .expect("failed to create test bucket");
+        let bucket = Box::leak(bucket.into_boxed_str());
+        TestS3(RefCell::new(S3Backend::new(client, bucket)))
+    }
+    pub(crate) fn upload(&self, blobs: &[Blob]) -> Result<(), Error> {
+        self.0.borrow_mut().store_batch(blobs)
+    }
+    pub(crate) fn assert_404(&self, path: &'static str) {
+        use rusoto_core::RusotoError;
+        use rusoto_s3::GetObjectError;
+
+        let err = self.0.borrow().get(path).unwrap_err();
+        match err
+            .downcast_ref::<RusotoError<GetObjectError>>()
+            .expect("wanted GetObject")
+        {
+            RusotoError::Unknown(http) => assert_eq!(http.status, 404),
+            RusotoError::Service(GetObjectError::NoSuchKey(_)) => {}
+            x => panic!("wrong error: {:?}", x),
+        };
+    }
+    pub(crate) fn assert_blob(&self, blob: &Blob, path: &str) {
+        let actual = self.0.borrow().get(path).unwrap();
+        assert_blob_eq(blob, &actual);
+    }
+}
+
+impl Drop for TestS3 {
+    fn drop(&mut self) {
+        // delete the bucket when the test ends
+        // this has to delete all the objects in the bucket first or min.io will give an error
+        let inner = self.0.borrow();
+        let list_req = ListObjectsRequest {
+            bucket: inner.bucket.to_owned(),
+            ..Default::default()
+        };
+        let objects = inner.client.list_objects(list_req).sync().unwrap();
+        assert!(!objects.is_truncated.unwrap_or(false));
+        for path in objects.contents.unwrap() {
+            let delete_req = DeleteObjectRequest {
+                bucket: inner.bucket.to_owned(),
+                key: path.key.unwrap(),
+                ..Default::default()
+            };
+            inner.client.delete_object(delete_req).sync().unwrap();
+        }
+        let delete_req = DeleteBucketRequest {
+            bucket: inner.bucket.to_owned(),
+        };
+        inner
+            .client
+            .delete_bucket(delete_req)
+            .sync()
+            .expect("failed to delete test bucket");
+    }
+}

src/test/mod.rs

@@ -1,6 +1,6 @@
 mod fakes;
 
-use crate::storage::s3::tests::TestS3;
+use crate::storage::s3::TestS3;
 use crate::web::Server;
 use failure::Error;
 use log::error;