opendal 0.1.9 → 0.1.11

data/core/tests/behavior/async_compose.rs

@@ -0,0 +1,297 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+use anyhow::Result;
+
+use crate::*;
+
+pub fn tests(op: &Operator, tests: &mut Vec<Trial>) {
+    let cap = op.info().capability();
+
+    if cap.read && cap.write && cap.compose {
+        tests.extend(async_trials!(
+            op,
+            test_compose_ordered_sources,
+            test_compose_incrementally,
+            test_compose_empty,
+            test_compose_self,
+            test_compose_more_than_provider_request_limit
+        ));
+    }
+
+    if cap.read && cap.write && cap.stat && cap.compose && cap.compose_with_content_type {
+        tests.extend(async_trials!(op, test_compose_with_content_type));
+    }
+
+    if cap.read && cap.write && cap.stat && cap.compose && cap.compose_with_source_version {
+        tests.extend(async_trials!(op, test_compose_with_source_version));
+    }
+
+    if cap.read
+        && cap.write
+        && cap.stat
+        && cap.compose
+        && (cap.compose_with_source_version || cap.compose_with_source_if_match)
+    {
+        tests.extend(async_trials!(op, test_compose_with_source_if_not_changed));
+    }
+
+    if cap.read && cap.write && cap.stat && cap.compose && cap.compose_with_if_version_match {
+        tests.extend(async_trials!(op, test_compose_with_if_version_match));
+    }
+
+    if cap.read
+        && cap.write
+        && cap.stat
+        && cap.compose
+        && (cap.compose_with_if_version_match || cap.compose_with_if_match)
+    {
+        tests.extend(async_trials!(op, test_compose_with_if_not_changed));
+    }
+
+    if cap.read && cap.write && cap.compose && cap.compose_with_if_not_exists {
+        tests.extend(async_trials!(op, test_compose_with_if_not_exists));
+    }
+}
+
+pub async fn test_compose_ordered_sources(op: Operator) -> Result<()> {
+    let first = TEST_FIXTURE.new_file_path();
+    let second = TEST_FIXTURE.new_file_path();
+    let target = TEST_FIXTURE.new_file_path();
+
+    op.write(&first, "hello").await?;
+    op.write(&second, " world").await?;
+    op.write(&target, "stale").await?;
+
+    op.compose([first.as_str(), second.as_str(), first.as_str()], &target)
+        .await?;
+
+    assert_eq!(
+        op.read(&target).await?.to_bytes().as_ref(),
+        b"hello worldhello"
+    );
+    assert_eq!(op.read(&first).await?.to_bytes().as_ref(), b"hello");
+    assert_eq!(op.read(&second).await?.to_bytes().as_ref(), b" world");
+    Ok(())
+}
+
+pub async fn test_compose_incrementally(op: Operator) -> Result<()> {
+    let first = TEST_FIXTURE.new_file_path();
+    let second = TEST_FIXTURE.new_file_path();
+    let target = TEST_FIXTURE.new_file_path();
+
+    op.write(&first, "a").await?;
+    op.write(&second, "b").await?;
+
+    let mut composer = op.composer_with(&target).concurrent(2).await?;
+    composer.compose(first.as_str()).await?;
+    composer
+        .compose_options(second.as_str(), options::ComposeSourceOptions::default())
+        .await?;
+    let metadata = composer.close().await?;
+
+    assert_eq!(metadata.content_length(), 2);
+    assert_eq!(op.read(&target).await?.to_bytes().as_ref(), b"ab");
+    assert_eq!(composer.close().await?.content_length(), 2);
+    Ok(())
+}
+
+pub async fn test_compose_empty(op: Operator) -> Result<()> {
+    let target = TEST_FIXTURE.new_file_path();
+    let err = op
+        .compose(Vec::<String>::new(), &target)
+        .await
+        .expect_err("empty composition must fail");
+    assert_eq!(err.kind(), ErrorKind::ConfigInvalid);
+
+    if op.info().capability().stat {
+        assert!(!op.exists(&target).await?);
+    }
+    Ok(())
+}
+
+pub async fn test_compose_self(op: Operator) -> Result<()> {
+    let path = TEST_FIXTURE.new_file_path();
+    op.write(&path, "content").await?;
+
+    let err = op
+        .compose([path.as_str()], &path)
+        .await
+        .expect_err("composing a destination from itself must fail");
+    assert_eq!(err.kind(), ErrorKind::IsSameFile);
+    assert_eq!(op.read(&path).await?.to_bytes().as_ref(), b"content");
+    Ok(())
+}
+
+pub async fn test_compose_more_than_provider_request_limit(op: Operator) -> Result<()> {
+    let target = TEST_FIXTURE.new_file_path();
+    let mut sources = Vec::with_capacity(65);
+
+    for index in 0..65_u8 {
+        let path = TEST_FIXTURE.new_file_path();
+        op.write(&path, vec![index]).await?;
+        sources.push(path);
+    }
+
+    op.compose_with(sources.iter().map(String::as_str), &target)
+        .concurrent(4)
+        .await?;
+
+    assert_eq!(
+        op.read(&target).await?.to_bytes(),
+        (0..65_u8).collect::<Vec<_>>()
+    );
+    Ok(())
+}
+
+pub async fn test_compose_with_content_type(op: Operator) -> Result<()> {
+    let source = TEST_FIXTURE.new_file_path();
+    let target = TEST_FIXTURE.new_file_path();
+    op.write(&source, "content").await?;
+
+    op.compose_with([source.as_str()], &target)
+        .content_type("text/plain")
+        .await?;
+
+    assert_eq!(op.stat(&target).await?.content_type(), Some("text/plain"));
+    Ok(())
+}
+
+pub async fn test_compose_with_source_version(op: Operator) -> Result<()> {
+    let source = TEST_FIXTURE.new_file_path();
+    let target = TEST_FIXTURE.new_file_path();
+    op.write(&source, "content").await?;
+    let metadata = op.stat(&source).await?;
+    let version = metadata
+        .version()
+        .expect("source version capability requires stat to return a version");
+
+    let mut composer = op.composer(&target).await?;
+    composer
+        .compose_with(source.as_str())
+        .version(version)
+        .await?;
+    composer.close().await?;
+
+    assert_eq!(op.read(&target).await?.to_bytes().as_ref(), b"content");
+    Ok(())
+}
+
+pub async fn test_compose_with_source_if_not_changed(op: Operator) -> Result<()> {
+    let source = TEST_FIXTURE.new_file_path();
+    let other = TEST_FIXTURE.new_file_path();
+    let target = TEST_FIXTURE.new_file_path();
+    let rejected_target = TEST_FIXTURE.new_file_path();
+
+    op.write(&source, "source").await?;
+    let expected = op.stat(&source).await?;
+
+    op.write(&other, "other").await?;
+    op.write(&other, "unrelated").await?;
+    let unrelated = op.stat(&other).await?;
+
+    op.compose(
+        [(
+            source.as_str(),
+            options::ComposeSourceOptions {
+                if_not_changed: Some(expected),
+                ..Default::default()
+            },
+        )],
+        &target,
+    )
+    .await?;
+
+    assert_eq!(op.read(&target).await?.to_bytes().as_ref(), b"source");
+    assert_eq!(op.read(&source).await?.to_bytes().as_ref(), b"source");
+
+    op.compose(
+        [(
+            source.as_str(),
+            options::ComposeSourceOptions {
+                if_not_changed: Some(unrelated),
+                ..Default::default()
+            },
+        )],
+        &rejected_target,
+    )
+    .await
+    .expect_err("an unrelated source identity must not be ignored");
+
+    assert!(!op.exists(&rejected_target).await?);
+    assert_eq!(op.read(&source).await?.to_bytes().as_ref(), b"source");
+    Ok(())
+}
+
+pub async fn test_compose_with_if_version_match(op: Operator) -> Result<()> {
+    let source = TEST_FIXTURE.new_file_path();
+    let target = TEST_FIXTURE.new_file_path();
+    op.write(&source, "new").await?;
+    op.write(&target, "old").await?;
+    let metadata = op.stat(&target).await?;
+    let version = metadata
+        .version()
+        .expect("version match capability requires stat to return a version");
+
+    op.compose_with([source.as_str()], &target)
+        .if_version_match(version)
+        .await?;
+
+    assert_eq!(op.read(&target).await?.to_bytes().as_ref(), b"new");
+    Ok(())
+}
+
+pub async fn test_compose_with_if_not_changed(op: Operator) -> Result<()> {
+    let source = TEST_FIXTURE.new_file_path();
+    let target = TEST_FIXTURE.new_file_path();
+
+    op.write(&source, "composed").await?;
+    op.write(&target, "initial").await?;
+    let expected = op.stat(&target).await?;
+
+    op.compose_with([source.as_str()], &target)
+        .if_not_changed(&expected)
+        .await?;
+    assert_eq!(op.read(&target).await?.to_bytes().as_ref(), b"composed");
+
+    let stale = op.stat(&target).await?;
+    op.write(&target, "replacement").await?;
+    let err = op
+        .compose_with([source.as_str()], &target)
+        .if_not_changed(&stale)
+        .await
+        .expect_err("stale destination metadata must fail");
+    assert_eq!(err.kind(), ErrorKind::ConditionNotMatch);
+    assert_eq!(op.read(&target).await?.to_bytes().as_ref(), b"replacement");
+    Ok(())
+}
+
+pub async fn test_compose_with_if_not_exists(op: Operator) -> Result<()> {
+    let source = TEST_FIXTURE.new_file_path();
+    let target = TEST_FIXTURE.new_file_path();
+    op.write(&source, "new").await?;
+    op.write(&target, "existing").await?;
+
+    let err = op
+        .compose_with([source.as_str()], &target)
+        .if_not_exists(true)
+        .await
+        .expect_err("composition must not replace an existing destination");
+    assert_eq!(err.kind(), ErrorKind::ConditionNotMatch);
+    assert_eq!(op.read(&target).await?.to_bytes().as_ref(), b"existing");
+    Ok(())
+}

data/core/tests/behavior/async_copy.rs

@@ -65,6 +65,28 @@ pub fn tests(op: &Operator, tests: &mut Vec<Trial>) {
         ))
     }
 
+    if cap.read && cap.write && cap.copy && cap.copy_with_if_none_match {
+        tests.extend(async_trials!(op, test_copy_with_if_none_match))
+    }
+
+    if cap.read
+        && cap.write
+        && cap.copy
+        && cap.copy_with_if_version_match
+        && cap.copy_with_if_version_not_match
+    {
+        tests.extend(async_trials!(op, test_copy_with_version_conditions))
+    }
+
+    if cap.read
+        && cap.write
+        && cap.stat
+        && cap.copy
+        && (cap.copy_with_if_match || cap.copy_with_if_version_match)
+    {
+        tests.extend(async_trials!(op, test_copy_if_not_changed))
+    }
+
     if cap.read && cap.write && cap.stat && cap.copy && cap.copy_with_source_version {
         tests.extend(async_trials!(
             op,
@@ -107,7 +129,10 @@ pub async fn test_copy_file_with_ascii_name(op: Operator) -> Result<()> {
 
     let target_path = uuid::Uuid::new_v4().to_string();
 
-    op.copy(&source_path, &target_path).await?;
+    let metadata = op.copy(&source_path, &target_path).await?;
+    if metadata.is_file() {
+        assert_eq!(metadata.content_length(), source_content.len() as u64);
+    }
 
     let target_content = op
         .read(&target_path)
@@ -437,11 +462,147 @@ pub async fn test_copy_with_if_match_mismatch(op: Operator) -> Result<()> {
         sha256_digest(&target_content),
     );
 
+    let missing_path = uuid::Uuid::new_v4().to_string();
+    let err = op
+        .copy_with(&source_path, &missing_path)
+        .if_match("\"00000000000000000000000000000000\"")
+        .await
+        .expect_err("missing destination must fail");
+    assert_eq!(err.kind(), ErrorKind::ConditionNotMatch);
+
     op.delete(&source_path).await.expect("delete must succeed");
     op.delete(&target_path).await.expect("delete must succeed");
     Ok(())
 }
 
+/// Copy with `If-None-Match` should reject equality and accept inequality or absence.
+pub async fn test_copy_with_if_none_match(op: Operator) -> Result<()> {
+    let source_path = TEST_FIXTURE.new_file_path();
+    let target_path = TEST_FIXTURE.new_file_path();
+    let missing_path = TEST_FIXTURE.new_file_path();
+    let (source_content, _) = gen_bytes(op.info().capability());
+    let (target_content, _) = gen_bytes(op.info().capability());
+    assert_ne!(source_content, target_content);
+
+    op.write(&source_path, source_content.clone()).await?;
+    op.write(&target_path, target_content).await?;
+    let etag = op
+        .stat(&target_path)
+        .await?
+        .etag()
+        .expect("etag must exist")
+        .to_string();
+
+    let err = op
+        .copy_with(&source_path, &target_path)
+        .if_none_match(&etag)
+        .await
+        .expect_err("equal ETag non-match must fail");
+    assert_eq!(err.kind(), ErrorKind::ConditionNotMatch);
+
+    op.copy_with(&source_path, &target_path)
+        .if_none_match("\"different-etag\"")
+        .await?;
+    op.copy_with(&source_path, &missing_path)
+        .if_none_match(&etag)
+        .await?;
+
+    assert_eq!(op.read(&target_path).await?.to_bytes(), source_content);
+    Ok(())
+}
+
+/// Version preconditions should compare against the current destination version.
+pub async fn test_copy_with_version_conditions(op: Operator) -> Result<()> {
+    let cap = op.info().capability();
+    let source_path = TEST_FIXTURE.new_file_path();
+    let target_path = TEST_FIXTURE.new_file_path();
+    let missing_path = TEST_FIXTURE.new_file_path();
+    let (source_content, _) = gen_bytes(cap);
+    let (first_target, _) = gen_bytes(cap);
+    let (second_target, _) = gen_bytes(cap);
+    assert_ne!(source_content, first_target);
+    assert_ne!(source_content, second_target);
+    assert_ne!(first_target, second_target);
+
+    op.write(&source_path, source_content).await?;
+    op.write(&target_path, first_target).await?;
+    let stale = op
+        .stat(&target_path)
+        .await?
+        .version()
+        .expect("version must exist")
+        .to_string();
+    op.write(&target_path, second_target).await?;
+    let current = op
+        .stat(&target_path)
+        .await?
+        .version()
+        .expect("version must exist")
+        .to_string();
+
+    let err = op
+        .copy_with(&source_path, &target_path)
+        .if_version_match(&stale)
+        .await
+        .expect_err("stale destination version must fail");
+    assert_eq!(err.kind(), ErrorKind::ConditionNotMatch);
+    let err = op
+        .copy_with(&source_path, &target_path)
+        .if_version_not_match(&current)
+        .await
+        .expect_err("equal destination version must fail");
+    assert_eq!(err.kind(), ErrorKind::ConditionNotMatch);
+
+    op.copy_with(&source_path, &target_path)
+        .if_version_match(&current)
+        .await?;
+    op.copy_with(&source_path, &target_path)
+        .if_version_not_match(&current)
+        .await?;
+
+    for result in [
+        op.copy_with(&source_path, &missing_path)
+            .if_version_match(&current)
+            .await,
+        op.copy_with(&source_path, &missing_path)
+            .if_version_not_match(&current)
+            .await,
+    ] {
+        assert_eq!(
+            result.expect_err("missing destination must fail").kind(),
+            ErrorKind::ConditionNotMatch
+        );
+    }
+
+    Ok(())
+}
+
+/// `if_not_changed` should guard the destination against a stale observation.
+pub async fn test_copy_if_not_changed(op: Operator) -> Result<()> {
+    let cap = op.info().capability();
+    let source_path = TEST_FIXTURE.new_file_path();
+    let target_path = TEST_FIXTURE.new_file_path();
+    let (source_content, _) = gen_bytes(cap);
+    let (target_content, _) = gen_bytes(cap);
+    assert_ne!(source_content, target_content);
+
+    op.write(&source_path, source_content).await?;
+    op.write(&target_path, target_content).await?;
+    let expected = op.stat(&target_path).await?;
+
+    op.copy_with(&source_path, &target_path)
+        .if_not_changed(&expected)
+        .await?;
+    let err = op
+        .copy_with(&source_path, &target_path)
+        .if_not_changed(&expected)
+        .await
+        .expect_err("stale destination metadata must fail");
+    assert_eq!(err.kind(), ErrorKind::ConditionNotMatch);
+
+    Ok(())
+}
+
 /// Copy with source_version should copy a specific source version to a new file.
 pub async fn test_copy_with_source_version_to_new_file(op: Operator) -> Result<()> {
     if !op.info().capability().copy_with_source_version {