s3s-fs: tests: aws

tracing-subscriber = { version = "0.3.16", optional = true, features = ["env-filter", "time"] }

transform-stream = "0.2.0"

uuid = { version = "1.2.2", features = ["v4"] }

[dev-dependencies]

aws-config = "0.53.0"

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

aws-sdk-s3 = "0.23.0"

once_cell = "1.17.0"

s3s-aws = { version = "0.0.1", path = "../s3s-aws" }

tokio = { version = "1.24.1", features = ["full"] }

tracing-subscriber = { version = "0.3.16", features = ["env-filter", "time"] }

use s3s::service::S3Service;

use std::fs;

use aws_config::SdkConfig;

use aws_credential_types::provider::SharedCredentialsProvider;

use aws_sdk_s3::Client;

use aws_sdk_s3::Credentials;

use aws_sdk_s3::Region;

use once_cell::sync::Lazy;

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

const DOMAIN_NAME: &str = "localhost:8014";

const REGION: &str = "us-west-2";

fn setup_tracing() {

    use tracing_subscriber::EnvFilter;

    tracing_subscriber::fmt()

        .pretty()

        .with_env_filter(EnvFilter::from_default_env())

        .init()

}

fn config() -> &'static SdkConfig {

    static CONFIG: Lazy<SdkConfig> = Lazy::new(|| {

        setup_tracing();

        let cred = Credentials::for_tests();

        let conn = {

            fs::create_dir_all(FS_ROOT).unwrap();

            let fs = s3s_fs::FileSystem::new(FS_ROOT).unwrap();

            let mut auth = s3s::SimpleAuth::new();

            auth.register(cred.access_key_id().to_owned(), cred.secret_access_key().to_owned());

            let mut service = S3Service::new(Box::new(fs));

            service.set_auth(Box::new(auth));

            service.set_base_domain(DOMAIN_NAME);

            s3s_aws::Connector::from(service.into_shared())

        };

        SdkConfig::builder()

            .credentials_provider(SharedCredentialsProvider::new(cred))

            .http_connector(conn)

            .region(Region::new(REGION))

            .endpoint_url(format!("http://{DOMAIN_NAME}"))

            .build()

    });

    &CONFIG

}

#[tokio::test]

async fn list_buckets() {

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

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

    match result {

        Ok(ans) => {

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

        }

        Err(err) => {

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

            panic!();

        }

    }

}