Unverified Commit 55a484b2 authored by Nugine's avatar Nugine
Browse files

s3s-fs: it_aws: test_multipart

parent 969076ca

crates/s3s-fs/Cargo.toml

+1 −0
Original line number Diff line number Diff line
@@ -42,6 +42,7 @@ transform-stream = "0.2.0" 
uuid = { version = "1.2.2", features = ["v4"] }



[dev-dependencies]

anyhow = { version = "1.0.68", features = ["backtrace"] }

aws-config = "0.53.0"

aws-credential-types = { version = "0.53.0", features = ["test-util"] }

aws-sdk-s3 = "0.23.0"

crates/s3s-fs/tests/aws.rs→crates/s3s-fs/tests/it_aws.rs

+177 −0
Original line number Diff line number Diff line
@@ -5,16 +5,23 @@ 
)]



use s3s::service::S3Service;

use tokio::sync::MutexGuard;



use std::env;

use std::fs;



use aws_config::SdkConfig;

use aws_credential_types::provider::SharedCredentialsProvider;

use aws_sdk_s3::model::*;

use aws_sdk_s3::types::ByteStream;

use aws_sdk_s3::Client;

use aws_sdk_s3::Credentials;

use aws_sdk_s3::Region;



use anyhow::Result;

use once_cell::sync::Lazy;

use tokio::sync::Mutex;

use tracing::{debug, error};



const FS_ROOT: &str = concat!(env!("CARGO_TARGET_TMPDIR"), "/s3s-fs-tests-aws");

const DOMAIN_NAME: &str = "localhost:8014";
@@ -23,9 +30,14 @@ const REGION: &str = "us-west-2"; 
fn setup_tracing() {

    use tracing_subscriber::EnvFilter;



    if env::var("RUST_LOG").is_err() {

        env::set_var("RUST_LOG", "it_aws=debug,s3s_fs=debug,s3s=debug");

    }



    tracing_subscriber::fmt()

        .pretty()

        .with_env_filter(EnvFilter::from_default_env())

        .with_test_writer()

        .init()

}
@@ -58,18 +70,108 @@ fn config() -> &'static SdkConfig { 
    &CONFIG

}



async fn serial() -> MutexGuard<'static, ()> {

    static LOCK: Lazy<Mutex<()>> = Lazy::new(|| Mutex::new(()));

    LOCK.lock().await

}



async fn create_bucket(c: &Client, bucket: &str) -> Result<()> {

    let location = BucketLocationConstraint::from(REGION);

    let cfg = CreateBucketConfiguration::builder().location_constraint(location).build();



    c.create_bucket()

        .create_bucket_configuration(cfg)

        .bucket(bucket)

        .send()

        .await?;



    debug!("created bucket: {bucket:?}");

    Ok(())

}



#[tokio::test]

async fn list_buckets() {

    let client = Client::new(config());

    let result = client.list_buckets().send().await;

#[tracing::instrument]

async fn test_list_buckets() {

    let c = Client::new(config());

    let result = c.list_buckets().send().await;



    match result {

        Ok(ans) => {

            println!("{ans:#?}");

        Ok(ref ans) => debug!(?ans),

        Err(ref err) => error!(?err),

    }

        Err(err) => {

            println!("{err:#?}");

            panic!();



    let _ = result.unwrap();

}



#[tokio::test]

#[tracing::instrument]

async fn test_multipart() -> Result<()> {

    let _guard = serial().await;



    let c = Client::new(config());



    let bucket = format!("test-multipart-{}", uuid::Uuid::new_v4());

    let bucket = bucket.as_str();

    create_bucket(&c, bucket).await?;



    let key = "sample.txt";

    let content = "abcdefghijklmnopqrstuvwxyz/0123456789/!@#$%^&*();\n";



    let upload_id = {

        let ans = c.create_multipart_upload().bucket(bucket).key(key).send().await?;

        ans.upload_id.unwrap()

    };

    let upload_id = upload_id.as_str();



    let upload_parts = {

        let body = ByteStream::from_static(content.as_bytes());

        let part_number = 1;



        let ans = c

            .upload_part()

            .bucket(bucket)

            .key(key)

            .upload_id(upload_id)

            .body(body)

            .part_number(part_number)

            .send()

            .await?;



        let part = CompletedPart::builder()

            .e_tag(ans.e_tag.unwrap_or_default())

            .part_number(part_number)

            .build();



        vec![part]

    };



    {

        let upload = CompletedMultipartUpload::builder().set_parts(Some(upload_parts)).build();



        let _ = c

            .complete_multipart_upload()

            .bucket(bucket)

            .key(key)

            .multipart_upload(upload)

            .upload_id(upload_id)

            .send()

            .await?;

    }



    {

        let ans = c.get_object().bucket(bucket).key(key).send().await?;



        let content_length: usize = ans.content_length().try_into().unwrap();

        let body = ans.body.collect().await?.into_bytes();



        assert_eq!(content_length, content.len());

        assert_eq!(body.as_ref(), content.as_bytes());

    }



    {

        c.delete_object().bucket(bucket).key(key).send().await?;

        c.delete_bucket().bucket(bucket).send().await?;

    }



    Ok(())

}