From b1c315b837375f03963c5df2c0c0ecfd026fa4c4 Mon Sep 17 00:00:00 2001 From: Chris Lu Date: Wed, 18 Nov 2026 14:25:15 -0800 Subject: [PATCH] s3api: report no ownership controls after DeleteBucketOwnershipControls (#12748) * test/s3: run tigrisdata-community s3-api-compat-tests in CI Runs the suite, pinned to a commit, against weed mini through a small provider patch, and fails on any test that is not in expected_failures.txt or on a listed test that starts passing. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_011UpvafvK8JpagF94MHWqwK * s3api: report no ownership controls after DeleteBucketOwnershipControls GetBucketOwnershipControls reports BucketOwnerEnforced for a bucket that never stored a setting, so it kept reporting it after the setting was deleted. The delete now records that it happened, and GET answers OwnershipControlsNotFoundError until ownership is put again. How objects are written after the delete is unchanged. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_011UpvafvK8JpagF94MHWqwK * s3api: answer DeleteBucketOwnershipControls with 204 No Content AWS answers a successful DeleteBucketOwnershipControls with 204 and no body; this answered 200 with an empty OwnershipControls document. Co-Authored-By: Claude Opus 5.5 --------- Co-authored-by: Claude Opus 5.5 --- .github/workflows/s3-tigris-compat-tests.yml | 57 +++++++++ test/s3/acl/s3_ownership_controls_test.go | 17 ++- test/s3/tigris_compat/.gitignore | 6 + test/s3/tigris_compat/Makefile | 115 ++++++++++++++++++ test/s3/tigris_compat/check_results.py | 61 ++++++++++ test/s3/tigris_compat/expected_failures.txt | 22 ++++ .../s3/tigris_compat/seaweedfs-provider.patch | 19 +++ test/s3/tigris_compat/test_s3.json | 20 +++ weed/s3api/s3_constants/extend_key.go | 1 + weed/s3api/s3api_bucket_config.go | 10 ++ weed/s3api/s3api_bucket_handlers.go | 17 ++- weed/s3api/s3api_bucket_handlers_misc_test.go | 49 ++++++++ 12 files changed, 383 insertions(+), 11 deletions(-) create mode 100644 .github/workflows/s3-tigris-compat-tests.yml create mode 100644 test/s3/tigris_compat/.gitignore create mode 100644 test/s3/tigris_compat/Makefile create mode 100644 test/s3/tigris_compat/check_results.py create mode 100644 test/s3/tigris_compat/expected_failures.txt create mode 100644 test/s3/tigris_compat/seaweedfs-provider.patch create mode 100644 test/s3/tigris_compat/test_s3.json diff --git a/.github/workflows/s3-tigris-compat-tests.yml b/.github/workflows/s3-tigris-compat-tests.yml new file mode 100644 index 0000000000..dbdb9f8cb0 --- /dev/null +++ b/.github/workflows/s3-tigris-compat-tests.yml @@ -0,0 +1,57 @@ +name: "S3 Tigris Compatibility Tests" + +on: + push: + branches: [ master ] + paths: + - 'weed/s3api/**' + - 'weed/server/filer_server_handlers_*.go' + - 'test/s3/tigris_compat/**' + - '.github/workflows/s3-tigris-compat-tests.yml' + pull_request: + branches: [ master ] + paths: + - 'weed/s3api/**' + - 'weed/server/filer_server_handlers_*.go' + - 'test/s3/tigris_compat/**' + - '.github/workflows/s3-tigris-compat-tests.yml' + +concurrency: + group: ${{ github.workflow }}-${{ github.event.pull_request.number || (github.event_name == 'push' && github.ref) || github.run_id }} + cancel-in-progress: ${{ github.event_name == 'pull_request' || (github.event_name == 'push' && !startsWith(github.ref, 'refs/tags/')) }} + +permissions: + contents: read + +jobs: + s3-tigris-compat-tests: + name: s3-api-compat-tests (Tigris) + runs-on: ubuntu-24.04 + timeout-minutes: 20 + steps: + - name: Check out code + uses: actions/checkout@v7 + + - name: Set up Go + uses: actions/setup-go@v7 + with: + go-version-file: 'go.mod' + cache: ${{ runner.environment == 'github-hosted' }} + + - name: Run s3-api-compat-tests + working-directory: test/s3/tigris_compat + run: make test + + - name: Show server log on failure + if: failure() + working-directory: test/s3/tigris_compat + run: tail -200 weed-test.log || true + + - name: Upload report + if: always() + uses: actions/upload-artifact@v7 + with: + name: s3-tigris-compat-results + path: test/s3/tigris_compat/results.json + if-no-files-found: ignore + retention-days: 7 diff --git a/test/s3/acl/s3_ownership_controls_test.go b/test/s3/acl/s3_ownership_controls_test.go index 257908b88d..5d5127f1da 100644 --- a/test/s3/acl/s3_ownership_controls_test.go +++ b/test/s3/acl/s3_ownership_controls_test.go @@ -2,13 +2,16 @@ package acl import ( "context" + "net/http" "strings" "testing" "time" "github.com/aws/aws-sdk-go-v2/aws" + awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/service/s3" "github.com/aws/aws-sdk-go-v2/service/s3/types" + smithyhttp "github.com/aws/smithy-go/transport/http" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) @@ -63,12 +66,22 @@ func TestBucketOwnershipControlsLifecycle(t *testing.T) { putObjectOwnership(t, client, bucketName, types.ObjectOwnershipBucketOwnerEnforced) assert.Equal(t, types.ObjectOwnershipBucketOwnerEnforced, getObjectOwnership(t, client, bucketName)) - _, err := client.DeleteBucketOwnershipControls(context.TODO(), &s3.DeleteBucketOwnershipControlsInput{ + deleted, err := client.DeleteBucketOwnershipControls(context.TODO(), &s3.DeleteBucketOwnershipControlsInput{ Bucket: aws.String(bucketName), }) require.NoError(t, err) + raw, ok := awsmiddleware.GetRawResponse(deleted.ResultMetadata).(*smithyhttp.Response) + require.True(t, ok) + assert.Equal(t, http.StatusNoContent, raw.StatusCode) - assert.Equal(t, types.ObjectOwnershipBucketOwnerEnforced, getObjectOwnership(t, client, bucketName)) + _, err = client.GetBucketOwnershipControls(context.TODO(), &s3.GetBucketOwnershipControlsInput{ + Bucket: aws.String(bucketName), + }) + require.Error(t, err) + assert.Contains(t, err.Error(), "OwnershipControlsNotFoundError") + + putObjectOwnership(t, client, bucketName, types.ObjectOwnershipBucketOwnerPreferred) + assert.Equal(t, types.ObjectOwnershipBucketOwnerPreferred, getObjectOwnership(t, client, bucketName)) } // A bucket with nothing stored already reports BucketOwnerEnforced, so this put has diff --git a/test/s3/tigris_compat/.gitignore b/test/s3/tigris_compat/.gitignore new file mode 100644 index 0000000000..8ff527ae7c --- /dev/null +++ b/test/s3/tigris_compat/.gitignore @@ -0,0 +1,6 @@ +s3-api-compat-tests/ +test-volume-data/ +compat-runner +results.json +weed-test.log +weed-server.pid diff --git a/test/s3/tigris_compat/Makefile b/test/s3/tigris_compat/Makefile new file mode 100644 index 0000000000..a31f818ca3 --- /dev/null +++ b/test/s3/tigris_compat/Makefile @@ -0,0 +1,115 @@ +# Runs https://github.com/tigrisdata-community/s3-api-compat-tests against a +# local SeaweedFS S3 gateway and compares the report with expected_failures.txt. + +.PHONY: all test help build-weed build-suite start-server stop-server run-suite test-with-server logs clean + +SUITE_REPO := https://github.com/tigrisdata-community/s3-api-compat-tests.git +SUITE_COMMIT := e846275e489ec30b324344d462e698252c3a1f67 +SUITE_DIR := s3-api-compat-tests + +WEED_BINARY := ../../../weed/weed_binary +S3_PORT ?= 8335 +MASTER_PORT ?= 9335 +VOLUME_PORT ?= 8085 +FILER_PORT ?= 8889 +WEBDAV_PORT ?= 7335 +ADMIN_PORT ?= 23647 +SERVER_DIR := ./test-volume-data +S3_CONFIG := ./test_s3.json + +.DEFAULT_GOAL := help + +all: test + +test: test-with-server + +help: + @echo "s3-api-compat-tests (Tigris) against SeaweedFS" + @echo "" + @echo " build-weed - Build the SeaweedFS binary" + @echo " build-suite - Fetch the suite at $(SUITE_COMMIT) and build it" + @echo " start-server - Start weed mini with S3 on port $(S3_PORT)" + @echo " run-suite - Run the suite and check expected_failures.txt" + @echo " stop-server - Stop the test server" + @echo " test-with-server - Start server, run suite, stop server" + @echo " logs - Show server logs" + @echo " clean - Remove test artifacts" + +build-weed: + @cd ../../../weed && go build -o weed_binary . + +build-suite: + @if [ "$$(git -C $(SUITE_DIR) rev-parse HEAD 2>/dev/null)" != "$(SUITE_COMMIT)" ]; then \ + rm -rf $(SUITE_DIR) && mkdir -p $(SUITE_DIR) && \ + git -C $(SUITE_DIR) init -q && \ + git -C $(SUITE_DIR) fetch -q --depth 1 $(SUITE_REPO) $(SUITE_COMMIT) && \ + git -C $(SUITE_DIR) checkout -q FETCH_HEAD && \ + git -C $(SUITE_DIR) apply ../seaweedfs-provider.patch; \ + fi + @cd $(SUITE_DIR) && go build -o ../compat-runner . + +start-server: build-weed + @rm -f weed-server.pid + @mkdir -p $(SERVER_DIR) + @if curl -sS -o /dev/null http://127.0.0.1:$(S3_PORT)/ >/dev/null 2>&1; then \ + echo "port $(S3_PORT) is already served by another process; refusing to test against it"; \ + exit 1; \ + fi + @$(WEED_BINARY) mini \ + -dir=$(SERVER_DIR) \ + -ip=127.0.0.1 \ + -ip.bind=127.0.0.1 \ + -master.port=$(MASTER_PORT) \ + -volume.port=$(VOLUME_PORT) \ + -filer.port=$(FILER_PORT) \ + -webdav.port=$(WEBDAV_PORT) \ + -admin.port=$(ADMIN_PORT) \ + -admin.port.legacy=0 \ + -s3.port=$(S3_PORT) \ + -s3.config=$(S3_CONFIG) \ + -master.peers=none \ + > weed-test.log 2>&1 & echo $$! > weed-server.pid + @for i in $$(seq 1 60); do \ + kill -0 $$(cat weed-server.pid) 2>/dev/null || { \ + echo "SeaweedFS server exited during startup"; \ + cat weed-test.log; \ + exit 1; \ + }; \ + if curl -sS -o /dev/null http://127.0.0.1:$(S3_PORT)/ >/dev/null 2>&1; then \ + echo "SeaweedFS S3 server is ready on port $(S3_PORT)"; \ + exit 0; \ + fi; \ + sleep 1; \ + done; \ + echo "SeaweedFS S3 server failed to start"; \ + cat weed-test.log; \ + $(MAKE) --no-print-directory stop-server; \ + exit 1 + +stop-server: + @if [ -f weed-server.pid ]; then \ + pid=$$(cat weed-server.pid); \ + if ps -p $$pid -o comm= 2>/dev/null | grep -q weed; then \ + kill $$pid 2>/dev/null || true; \ + sleep 2; \ + fi; \ + rm -f weed-server.pid; \ + fi + +run-suite: build-suite + SEAWEEDFS_S3_ENDPOINT=http://127.0.0.1:$(S3_PORT) \ + SEAWEEDFS_S3_ACCESS_KEY_ID=admin \ + SEAWEEDFS_S3_SECRET_ACCESS_KEY=admin \ + ./compat-runner --providers=seaweedfs --output=results.json + python3 check_results.py results.json expected_failures.txt + +test-with-server: + @$(MAKE) start-server; START_RESULT=$$?; \ + if [ $$START_RESULT -eq 0 ]; then $(MAKE) run-suite; TEST_RESULT=$$?; else TEST_RESULT=$$START_RESULT; fi; \ + $(MAKE) stop-server; exit $$TEST_RESULT + +logs: + @test -f weed-test.log && tail -100 weed-test.log || echo "No log file found" + +clean: stop-server + @rm -rf $(SERVER_DIR) $(SUITE_DIR) compat-runner results.json weed-test.log weed-server.pid diff --git a/test/s3/tigris_compat/check_results.py b/test/s3/tigris_compat/check_results.py new file mode 100644 index 0000000000..3d81168358 --- /dev/null +++ b/test/s3/tigris_compat/check_results.py @@ -0,0 +1,61 @@ +#!/usr/bin/env python3 +"""Compare an s3-api-compat-tests JSON report with expected_failures.txt. + +Fails on any test that did not pass and is not listed, and on any listed test +that now passes or did not run, so the list only ever shrinks. +""" +import json +import sys + + +def load_expected(path): + expected = set() + with open(path) as f: + for line in f: + name = line.split("#", 1)[0].strip() + if name: + expected.add(name) + return expected + + +def main(): + if len(sys.argv) != 3: + sys.exit("usage: check_results.py ") + with open(sys.argv[1]) as f: + report = json.load(f) + expected = load_expected(sys.argv[2]) + + providers = report.get("providers") or [] + results = providers[0].get("results") if providers else None + if not results: + sys.exit("no test results in the report: the suite could not start against the server") + + seen = set() + regressions, fixed = [], [] + for r in results: + name, status = r["operation"], r["status"] + seen.add(name) + detail = r.get("error") or r.get("notes") or "" + if status == "pass": + if name in expected: + fixed.append(name) + elif name not in expected: + regressions.append(f"{name} [{status}]: {detail}") + else: + print(f"expected failure: {name} [{status}]") + + missing = sorted(expected - seen) + print(f"{len(results)} tests, {len(regressions)} unexpected failures, " + f"{len(fixed)} unexpected passes, {len(missing)} listed but not run") + for line in regressions: + print(f"UNEXPECTED FAILURE: {line}") + for name in fixed: + print(f"UNEXPECTED PASS: {name} (remove it from expected_failures.txt)") + for name in missing: + print(f"NOT RUN: {name} (remove it from expected_failures.txt)") + if regressions or fixed or missing: + sys.exit(1) + + +if __name__ == "__main__": + main() diff --git a/test/s3/tigris_compat/expected_failures.txt b/test/s3/tigris_compat/expected_failures.txt new file mode 100644 index 0000000000..469e2f09b0 --- /dev/null +++ b/test/s3/tigris_compat/expected_failures.txt @@ -0,0 +1,22 @@ +# Tests from s3-api-compat-tests that SeaweedFS is expected to fail. +# check_results.py fails CI on any other failure, and on any test listed here +# that passes, so remove an entry together with the fix that makes it pass. + +# AWS answers GetBucketPolicyStatus on a bucket without a policy with +# NoSuchBucketPolicy, and so does SeaweedFS; the suite expects a status. +GetBucketPolicyStatus + +# Glacier restore: SeaweedFS has no archive storage class to restore from, and +# AWS also refuses RestoreObject on a STANDARD object (InvalidObjectState). +RestoreObject + +# SeaweedFS reads x-amz-rename-source as a literal key first and then, when it +# starts with the request's bucket, as bucket/key, because AWS documents both +# spellings. A leading slash is dropped since filer paths cannot hold it. +RenameObject_SourceIsLiteralKey + +# Not yet fixed in SeaweedFS. +PutBucketAccelerateConfiguration +GetBucketAccelerateConfiguration +PutBucketNotificationConfiguration +PutObjectTagging_VersionId diff --git a/test/s3/tigris_compat/seaweedfs-provider.patch b/test/s3/tigris_compat/seaweedfs-provider.patch new file mode 100644 index 0000000000..34ae8b6e3f --- /dev/null +++ b/test/s3/tigris_compat/seaweedfs-provider.patch @@ -0,0 +1,19 @@ +diff --git a/providers.go b/providers.go +index 149f94c..bc7aeeb 100644 +--- a/providers.go ++++ b/providers.go +@@ -180,6 +180,14 @@ func (p *Provider) CreateVersionedBucket(ctx context.Context, client *s3.Client, + // If names is non-empty, only those named providers are returned. + func LoadProviders(names []string) []Provider { + all := []Provider{ ++ { ++ Name: "seaweedfs", ++ Endpoint: os.Getenv("SEAWEEDFS_S3_ENDPOINT"), ++ Region: envOr("SEAWEEDFS_S3_REGION", "us-east-1"), ++ PathStyle: true, ++ AccessKey: os.Getenv("SEAWEEDFS_S3_ACCESS_KEY_ID"), ++ SecretKey: os.Getenv("SEAWEEDFS_S3_SECRET_ACCESS_KEY"), ++ }, + { + Name: "tigris", + Endpoint: "https://t3.storage.dev", diff --git a/test/s3/tigris_compat/test_s3.json b/test/s3/tigris_compat/test_s3.json new file mode 100644 index 0000000000..1f9b460008 --- /dev/null +++ b/test/s3/tigris_compat/test_s3.json @@ -0,0 +1,20 @@ +{ + "identities": [ + { + "name": "admin", + "credentials": [ + { + "accessKey": "admin", + "secretKey": "admin" + } + ], + "actions": [ + "Admin", + "Read", + "List", + "Tagging", + "Write" + ] + } + ] +} diff --git a/weed/s3api/s3_constants/extend_key.go b/weed/s3api/s3_constants/extend_key.go index 00c256e1ef..be89e13399 100644 --- a/weed/s3api/s3_constants/extend_key.go +++ b/weed/s3api/s3_constants/extend_key.go @@ -5,6 +5,7 @@ const ( ExtAmzOwnerKey = "Seaweed-X-Amz-Owner" ExtAmzAclKey = "Seaweed-X-Amz-Acl" ExtOwnershipKey = "Seaweed-X-Amz-Ownership" + ExtOwnershipDeletedKey = "Seaweed-X-Amz-Ownership-Deleted" ExtPublicAccessBlockKey = "Seaweed-X-Amz-Public-Access-Block" ExtVersioningKey = "Seaweed-X-Amz-Versioning" ExtVersionIdKey = "Seaweed-X-Amz-Version-Id" diff --git a/weed/s3api/s3api_bucket_config.go b/weed/s3api/s3api_bucket_config.go index 5b5a884376..77e3c8d4a9 100644 --- a/weed/s3api/s3api_bucket_config.go +++ b/weed/s3api/s3api_bucket_config.go @@ -36,6 +36,7 @@ type BucketConfig struct { Name string Versioning string // "Enabled", "Suspended", or "" Ownership string + OwnershipDeleted bool // DeleteBucketOwnershipControls removed it; GET reports none ACL []byte Owner string IdentityId string // identity that created the bucket @@ -432,6 +433,7 @@ func (s3a *S3ApiServer) newBucketConfigFromEntry(bucket string, entry *filer_pb. if ownership, exists := entry.Extended[s3_constants.ExtOwnershipKey]; exists { config.Ownership = string(ownership) } + config.OwnershipDeleted = len(entry.Extended[s3_constants.ExtOwnershipDeletedKey]) > 0 if data, exists := entry.Extended[s3_constants.ExtPublicAccessBlockKey]; exists && len(data) > 0 { if pab, err := parsePublicAccessBlock(data); err == nil { config.PublicAccessBlock = pab @@ -587,6 +589,11 @@ func applyBucketConfigToExtended(config *BucketConfig, ext map[string][]byte) er } setOrDelete(s3_constants.ExtVersioningKey, []byte(config.Versioning)) setOrDelete(s3_constants.ExtOwnershipKey, []byte(config.Ownership)) + if config.OwnershipDeleted && config.Ownership == "" { + ext[s3_constants.ExtOwnershipDeletedKey] = []byte("true") + } else { + delete(ext, s3_constants.ExtOwnershipDeletedKey) + } if config.PublicAccessBlock != nil { data, err := xml.Marshal(config.PublicAccessBlock) if err != nil { @@ -767,6 +774,9 @@ func (s3a *S3ApiServer) getBucketOwnership(bucket string) (string, s3err.ErrorCo if errCode != s3err.ErrNone { return "", errCode } + if config.OwnershipDeleted && config.Ownership == "" { + return "", s3err.OwnershipControlsNotFoundError + } return s3_constants.EffectiveOwnership(config.Ownership), s3err.ErrNone } diff --git a/weed/s3api/s3api_bucket_handlers.go b/weed/s3api/s3api_bucket_handlers.go index 1d734c164a..e905caf978 100644 --- a/weed/s3api/s3api_bucket_handlers.go +++ b/weed/s3api/s3api_bucket_handlers.go @@ -1505,7 +1505,7 @@ func (s3a *S3ApiServer) GetBucketOwnershipControls(w http.ResponseWriter, r *htt // DeleteBucketOwnershipControls https://docs.aws.amazon.com/AmazonS3/latest/API/API_DeleteBucketOwnershipControls.html func (s3a *S3ApiServer) DeleteBucketOwnershipControls(w http.ResponseWriter, r *http.Request) { bucket, _ := s3_constants.GetBucketAndObject(r) - glog.V(3).Infof("PutBucketOwnershipControls %s", bucket) + glog.V(3).Infof("DeleteBucketOwnershipControls %s", bucket) errCode := s3a.checkAccessByOwnership(r, bucket) if errCode != s3err.ErrNone { @@ -1529,17 +1529,16 @@ func (s3a *S3ApiServer) DeleteBucketOwnershipControls(w http.ResponseWriter, r * return } - delete(bucketEntry.Extended, s3_constants.ExtOwnershipKey) - err = s3a.updateEntry(s3a.option.BucketsPath, bucketEntry) - if err != nil { - s3err.WriteErrorResponse(w, r, s3err.ErrInternalError) + if errCode := s3a.updateBucketConfig(bucket, func(config *BucketConfig) error { + config.Ownership = "" + config.OwnershipDeleted = true + return nil + }); errCode != s3err.ErrNone { + s3err.WriteErrorResponse(w, r, errCode) return } - emptyOwnershipControls := &s3.OwnershipControls{ - Rules: []*s3.OwnershipControlsRule{}, - } - s3err.WriteAwsXMLResponse(w, r, http.StatusOK, emptyOwnershipControls) + s3err.WriteEmptyResponse(w, r, http.StatusNoContent) } // GetBucketVersioningHandler Get Bucket Versioning status diff --git a/weed/s3api/s3api_bucket_handlers_misc_test.go b/weed/s3api/s3api_bucket_handlers_misc_test.go index a9f2058f8c..97479748f3 100644 --- a/weed/s3api/s3api_bucket_handlers_misc_test.go +++ b/weed/s3api/s3api_bucket_handlers_misc_test.go @@ -207,6 +207,55 @@ func TestGetBucketOwnershipControlsDefaultsToBucketOwnerEnforced(t *testing.T) { } } +func TestGetBucketOwnershipControlsAfterDelete(t *testing.T) { + ownerID := AccountAdmin.Id + s3a := newMiscTestServer(t, "b") + s3a.bucketConfigCache.Set("b", &BucketConfig{Name: "b", OwnershipDeleted: true}) + s3a.bucketRegistry = NewBucketRegistry(nil) + s3a.bucketRegistry.setMetadataCache(&BucketMetaData{ + Name: "b", + Owner: &s3.Owner{ID: &ownerID}, + }) + req := newBucketRequest(http.MethodGet, "b", "ownershipControls=", "") + req.Header.Set(s3_constants.AmzAccountId, AccountAdmin.Id) + req = req.WithContext(s3_constants.SetIdentityInContext(req.Context(), &Identity{ + Name: "admin", + Account: &AccountAdmin, + Actions: []Action{s3_constants.ACTION_ADMIN}, + })) + rec := httptest.NewRecorder() + + s3a.GetBucketOwnershipControls(rec, req) + + if rec.Code != http.StatusNotFound || !strings.Contains(rec.Body.String(), "OwnershipControlsNotFoundError") { + t.Fatalf("status = %d, body=%s, want 404 OwnershipControlsNotFoundError", rec.Code, rec.Body.String()) + } +} + +func TestBucketConfigOwnershipDeletedRoundTrip(t *testing.T) { + s3a := &S3ApiServer{} + ext := map[string][]byte{s3_constants.ExtOwnershipKey: []byte(s3_constants.OwnershipObjectWriter)} + + deleted := &BucketConfig{OwnershipDeleted: true} + if err := applyBucketConfigToExtended(deleted, ext); err != nil { + t.Fatal(err) + } + if _, ok := ext[s3_constants.ExtOwnershipKey]; ok { + t.Fatalf("ownership still stored after delete: %v", ext) + } + if got := s3a.newBucketConfigFromEntry("b", &filer_pb.Entry{Extended: ext}); !got.OwnershipDeleted || got.Ownership != "" { + t.Fatalf("reloaded config = %+v, want deleted ownership", got) + } + + put := &BucketConfig{Ownership: s3_constants.OwnershipBucketOwnerEnforced, OwnershipDeleted: true} + if err := applyBucketConfigToExtended(put, ext); err != nil { + t.Fatal(err) + } + if got := s3a.newBucketConfigFromEntry("b", &filer_pb.Entry{Extended: ext}); got.OwnershipDeleted || got.Ownership != s3_constants.OwnershipBucketOwnerEnforced { + t.Fatalf("reloaded config = %+v, want stored BucketOwnerEnforced", got) + } +} + func TestGetBucketAccelerateConfiguration(t *testing.T) { s3a := newMiscTestServer(t, "b") req := newBucketRequest(http.MethodGet, "b", "accelerate=", "")