aboutsummaryrefslogtreecommitdiff
path: root/tests
diff options
context:
space:
mode:
Diffstat (limited to 'tests')
-rw-r--r--tests/account_test.go15
-rw-r--r--tests/bulk_delete_test.go13
-rw-r--r--tests/bulk_upload_test.go4
-rw-r--r--tests/container_iterator_test.go39
-rw-r--r--tests/container_test.go21
-rw-r--r--tests/field_test.go7
-rw-r--r--tests/largeobject_test.go134
-rw-r--r--tests/object_iterator_test.go53
-rw-r--r--tests/object_test.go67
-rw-r--r--tests/shared_test.go10
10 files changed, 189 insertions, 174 deletions
diff --git a/tests/account_test.go b/tests/account_test.go
index dc108ad..c44bf7f 100644
--- a/tests/account_test.go
+++ b/tests/account_test.go
@@ -19,6 +19,7 @@
package tests
import (
+ "context"
"testing"
"github.com/majewsky/schwift"
@@ -26,7 +27,7 @@ import (
func TestAccountBasic(t *testing.T) {
testWithAccount(t, func(a *schwift.Account) {
- hdr, err := a.Headers()
+ hdr, err := a.Headers(context.TODO())
if !expectSuccess(t, err) {
t.FailNow()
}
@@ -46,12 +47,12 @@ func TestAccountMetadata(t *testing.T) {
hdr := schwift.NewAccountHeaders()
hdr.Metadata().Set("schwift-test1", "first")
hdr.Metadata().Set("schwift-test2", "second")
- err := a.Update(hdr, nil)
+ err := a.Update(context.TODO(), hdr, nil)
if !expectSuccess(t, err) {
t.FailNow()
}
- hdr, err = a.Headers()
+ hdr, err = a.Headers(context.TODO())
if !expectSuccess(t, err) {
t.FailNow()
}
@@ -61,12 +62,12 @@ func TestAccountMetadata(t *testing.T) {
// test deleting some metadata
hdr = schwift.NewAccountHeaders()
hdr.Metadata().Clear("schwift-test1")
- err = a.Update(hdr, nil)
+ err = a.Update(context.TODO(), hdr, nil)
if !expectSuccess(t, err) {
t.FailNow()
}
- hdr, err = a.Headers()
+ hdr, err = a.Headers(context.TODO())
if !expectSuccess(t, err) {
t.FailNow()
}
@@ -78,12 +79,12 @@ func TestAccountMetadata(t *testing.T) {
hdr.Metadata().Set("schwift-test1", "will not be set")
hdr.Metadata().Del("schwift-test1")
hdr.Metadata().Set("schwift-test2", "changed")
- err = a.Update(hdr, nil)
+ err = a.Update(context.TODO(), hdr, nil)
if !expectSuccess(t, err) {
t.FailNow()
}
- hdr, err = a.Headers()
+ hdr, err = a.Headers(context.TODO())
if !expectSuccess(t, err) {
t.FailNow()
}
diff --git a/tests/bulk_delete_test.go b/tests/bulk_delete_test.go
index 0643a7c..102d092 100644
--- a/tests/bulk_delete_test.go
+++ b/tests/bulk_delete_test.go
@@ -19,6 +19,7 @@
package tests
import (
+ "context"
"fmt"
"strings"
"testing"
@@ -30,18 +31,18 @@ import (
func TestBulkDeleteSuccess(t *testing.T) {
testWithAccount(t, func(a *schwift.Account) {
testWithAndWithoutBulkDeleteSupport(func() {
- c, err := a.Container("schwift-test-bulkdelete").EnsureExists()
+ c, err := a.Container("schwift-test-bulkdelete").EnsureExists(context.TODO())
expectSuccess(t, err)
objs, err := createTestObjects(c)
expectSuccess(t, err)
- numDeleted, numNotFound, err := c.Account().BulkDelete(objs, nil, nil)
+ numDeleted, numNotFound, err := c.Account().BulkDelete(context.TODO(), objs, nil, nil)
expectSuccess(t, err)
expectInt(t, numDeleted, len(objs))
expectInt(t, numNotFound, 0)
expectContainerExistence(t, c, true)
- numDeleted, numNotFound, err = c.Account().BulkDelete(objs, nil, nil)
+ numDeleted, numNotFound, err = c.Account().BulkDelete(context.TODO(), objs, nil, nil)
expectSuccess(t, err)
expectInt(t, numDeleted, 0)
expectInt(t, numNotFound, len(objs))
@@ -51,7 +52,7 @@ func TestBulkDeleteSuccess(t *testing.T) {
expectSuccess(t, err)
cs := []*schwift.Container{c}
- numDeleted, numNotFound, err = c.Account().BulkDelete(objs, cs, nil)
+ numDeleted, numNotFound, err = c.Account().BulkDelete(context.TODO(), objs, cs, nil)
expectSuccess(t, err)
expectInt(t, numDeleted, len(objs)+1)
expectInt(t, numNotFound, 0)
@@ -71,7 +72,7 @@ func TestBulkDeleteError(t *testing.T) {
// not deleting all objects should lead to 409 Conflict when deleting the Container
// (NOTE: actual Swift returns 400 here although I don't understand why
// even after reading its code)
- numDeleted, numNotFound, err := c.Account().BulkDelete(objs, cs, nil)
+ numDeleted, numNotFound, err := c.Account().BulkDelete(context.TODO(), objs, cs, nil)
expectInt(t, numDeleted, len(objs))
expectInt(t, numNotFound, 0)
t.Logf("err = %#v\n", err)
@@ -87,7 +88,7 @@ func createTestObjects(c *schwift.Container) ([]*schwift.Object, error) {
var objs []*schwift.Object
for idx := 1; idx <= 5; idx++ {
obj := c.Object(fmt.Sprintf("object%d", idx))
- err := obj.Upload(strings.NewReader("example"), nil, nil)
+ err := obj.Upload(context.TODO(), strings.NewReader("example"), nil, nil)
if err != nil {
return nil, err
}
diff --git a/tests/bulk_upload_test.go b/tests/bulk_upload_test.go
index cb64168..35285ea 100644
--- a/tests/bulk_upload_test.go
+++ b/tests/bulk_upload_test.go
@@ -21,6 +21,7 @@ package tests
import (
"archive/tar"
"bytes"
+ "context"
"strings"
"testing"
@@ -38,6 +39,7 @@ func TestBulkUploadSuccess(t *testing.T) {
obj2.FullName(): []byte("world"),
})
n, err := c.Account().BulkUpload(
+ context.TODO(),
"", // upload path
schwift.BulkUploadTar,
bytes.NewReader(archive),
@@ -56,6 +58,7 @@ func TestBulkUploadSuccess(t *testing.T) {
func TestBulkUploadArchiveError(t *testing.T) {
testWithContainer(t, func(c *schwift.Container) {
n, err := c.Account().BulkUpload(
+ context.TODO(),
c.Name(), // upload path
schwift.BulkUploadTar,
strings.NewReader("This is not the TAR archive you're looking for."),
@@ -81,6 +84,7 @@ func TestBulkUploadObjectError(t *testing.T) {
obj2.Name(): []byte("world"),
})
n, err := c.Account().BulkUpload(
+ context.TODO(),
c.Name(), // upload path
schwift.BulkUploadTar,
bytes.NewReader(archive),
diff --git a/tests/container_iterator_test.go b/tests/container_iterator_test.go
index cb482c1..91679f5 100644
--- a/tests/container_iterator_test.go
+++ b/tests/container_iterator_test.go
@@ -19,6 +19,7 @@
package tests
import (
+ "context"
"fmt"
"testing"
@@ -33,52 +34,52 @@ func TestContainerIterator(t *testing.T) {
// create test containers that can be listed
for idx := 1; idx <= 4; idx++ {
- _, err := a.Container(cname(idx)).EnsureExists()
+ _, err := a.Container(cname(idx)).EnsureExists(context.TODO())
expectSuccess(t, err)
}
// test iteration with empty last page
iter := a.Containers()
iter.Prefix = "schwift-test-listing"
- cs, err := iter.NextPage(2)
+ cs, err := iter.NextPage(context.TODO(), 2)
expectSuccess(t, err)
expectContainerNames(t, cs, cname(1), cname(2))
- cs, err = iter.NextPage(2)
+ cs, err = iter.NextPage(context.TODO(), 2)
expectSuccess(t, err)
expectContainerNames(t, cs, cname(3), cname(4))
- cs, err = iter.NextPage(2)
+ cs, err = iter.NextPage(context.TODO(), 2)
expectSuccess(t, err)
expectContainerNames(t, cs)
- cs, err = iter.NextPage(2)
+ cs, err = iter.NextPage(context.TODO(), 2)
expectSuccess(t, err)
expectContainerNames(t, cs)
// test iteration with partial last page
iter = a.Containers()
iter.Prefix = "schwift-test-listing"
- cs, err = iter.NextPage(3)
+ cs, err = iter.NextPage(context.TODO(), 3)
expectSuccess(t, err)
expectContainerNames(t, cs, cname(1), cname(2), cname(3))
- cs, err = iter.NextPage(3)
+ cs, err = iter.NextPage(context.TODO(), 3)
expectSuccess(t, err)
expectContainerNames(t, cs, cname(4))
- cs, err = iter.NextPage(4)
+ cs, err = iter.NextPage(context.TODO(), 4)
expectSuccess(t, err)
expectContainerNames(t, cs)
// test detailed iteration
iter = a.Containers()
iter.Prefix = "schwift-test-listing"
- cis, err := iter.NextPageDetailed(2)
+ cis, err := iter.NextPageDetailed(context.TODO(), 2)
expectSuccess(t, err)
expectContainerInfos(t, cis, cname(1), cname(2))
- cis, err = iter.NextPageDetailed(3)
+ cis, err = iter.NextPageDetailed(context.TODO(), 3)
expectSuccess(t, err)
expectContainerInfos(t, cis, cname(3), cname(4))
- cis, err = iter.NextPageDetailed(3)
+ cis, err = iter.NextPageDetailed(context.TODO(), 3)
expectSuccess(t, err)
expectContainerInfos(t, cis)
- cis, err = iter.NextPageDetailed(3)
+ cis, err = iter.NextPageDetailed(context.TODO(), 3)
expectSuccess(t, err)
expectContainerInfos(t, cis)
@@ -87,7 +88,7 @@ func TestContainerIterator(t *testing.T) {
iter = a.Containers()
iter.Prefix = "schwift-test-listing"
idx := 0
- expectSuccess(t, iter.Foreach(func(c *schwift.Container) error {
+ expectSuccess(t, iter.Foreach(context.TODO(), func(c *schwift.Container) error {
idx++
expectString(t, c.Name(), cname(idx))
return nil
@@ -100,7 +101,7 @@ func TestContainerIterator(t *testing.T) {
iter = a.Containers()
iter.Prefix = "schwift-test-listing"
idx = 0
- expectSuccess(t, iter.ForeachDetailed(func(info schwift.ContainerInfo) error {
+ expectSuccess(t, iter.ForeachDetailed(context.TODO(), func(info schwift.ContainerInfo) error {
idx++
expectString(t, info.Container.Name(), cname(idx))
return nil
@@ -111,29 +112,29 @@ func TestContainerIterator(t *testing.T) {
// test Collect
iter = a.Containers()
iter.Prefix = "schwift-test-listing"
- cs, err = iter.Collect()
+ cs, err = iter.Collect(context.TODO())
expectSuccess(t, err)
expectContainerNames(t, cs, cname(1), cname(2), cname(3), cname(4))
// test CollectDetailed
iter = a.Containers()
iter.Prefix = "schwift-test-listing"
- cis, err = iter.CollectDetailed()
+ cis, err = iter.CollectDetailed(context.TODO())
expectSuccess(t, err)
expectContainerInfos(t, cis, cname(1), cname(2), cname(3), cname(4))
// cleanup
iter = a.Containers()
iter.Prefix = "schwift-test-listing"
- expectSuccess(t, iter.Foreach(func(c *schwift.Container) error {
- return c.Delete(nil)
+ expectSuccess(t, iter.Foreach(context.TODO(), func(c *schwift.Container) error {
+ return c.Delete(context.TODO(), nil)
}))
})
}
func expectAccountHeadersCached(t *testing.T, a *schwift.Account) {
requestCountBefore := a.Backend().(*RequestCountingBackend).Count
- _, err := a.Headers()
+ _, err := a.Headers(context.TODO())
expectSuccess(t, err)
requestCountAfter := a.Backend().(*RequestCountingBackend).Count
diff --git a/tests/container_test.go b/tests/container_test.go
index da05506..0ddd3bb 100644
--- a/tests/container_test.go
+++ b/tests/container_test.go
@@ -19,6 +19,7 @@
package tests
import (
+ "context"
"fmt"
"net/http"
"testing"
@@ -36,35 +37,35 @@ func TestContainerLifecycle(t *testing.T) {
t.Errorf("expected c.Account() = %#v, got %#v instead\n", a, c.Account())
}
- exists, err := c.Exists()
+ exists, err := c.Exists(context.TODO())
expectSuccess(t, err)
expectBool(t, exists, false)
- _, err = c.Headers()
+ _, err = c.Headers(context.TODO())
expectError(t, err, fmt.Sprintf("could not HEAD %q in Swift: expected 204 response, got 404 instead", containerName))
expectBool(t, schwift.Is(err, http.StatusNotFound), true)
expectBool(t, schwift.Is(err, http.StatusNoContent), false)
// DELETE should be idempotent and not return success on non-existence, but
// OpenStack LOVES to be inconsistent with everything (including, notably, itself)
- err = c.Delete(nil)
+ err = c.Delete(context.TODO(), nil)
expectError(t, err, fmt.Sprintf("could not DELETE %q in Swift: expected 204 response, got 404 instead: <html><h1>Not Found</h1><p>The resource could not be found.</p></html>", containerName))
- err = c.Create(nil)
+ err = c.Create(context.TODO(), nil)
expectSuccess(t, err)
- exists, err = c.Exists()
+ exists, err = c.Exists(context.TODO())
expectSuccess(t, err)
expectBool(t, exists, true)
- err = c.Delete(nil)
+ err = c.Delete(context.TODO(), nil)
expectSuccess(t, err)
})
}
func TestContainerUpdate(t *testing.T) {
testWithContainer(t, func(c *schwift.Container) {
- hdr, err := c.Headers()
+ hdr, err := c.Headers(context.TODO())
expectSuccess(t, err)
expectBool(t, hdr.ObjectCount().Exists(), true)
expectUint64(t, hdr.ObjectCount().Get(), 0)
@@ -73,10 +74,10 @@ func TestContainerUpdate(t *testing.T) {
hdr.ObjectCountQuota().Set(23)
hdr.BytesUsedQuota().Set(42)
- err = c.Update(hdr, nil)
+ err = c.Update(context.TODO(), hdr, nil)
expectSuccess(t, err)
- hdr, err = c.Headers()
+ hdr, err = c.Headers(context.TODO())
expectSuccess(t, err)
expectUint64(t, hdr.BytesUsedQuota().Get(), 42)
expectUint64(t, hdr.ObjectCountQuota().Get(), 23)
@@ -86,7 +87,7 @@ func TestContainerUpdate(t *testing.T) {
func expectContainerExistence(t *testing.T, c *schwift.Container, expectedExists bool) {
t.Helper()
c.Invalidate()
- actualExists, err := c.Exists()
+ actualExists, err := c.Exists(context.TODO())
expectSuccess(t, err)
expectBool(t, actualExists, expectedExists)
}
diff --git a/tests/field_test.go b/tests/field_test.go
index cd27c99..868ed87 100644
--- a/tests/field_test.go
+++ b/tests/field_test.go
@@ -19,6 +19,7 @@
package tests
import (
+ "context"
"net/http"
"strconv"
"testing"
@@ -62,7 +63,7 @@ func TestFieldString(t *testing.T) {
func TestFieldTimestamp(t *testing.T) {
testWithAccount(t, func(a *schwift.Account) {
- hdr, err := a.Headers()
+ hdr, err := a.Headers(context.TODO())
if !expectSuccess(t, err) {
return
}
@@ -88,12 +89,12 @@ func TestFieldTimestamp(t *testing.T) {
func TestFieldHTTPTimestamp(t *testing.T) {
testWithContainer(t, func(c *schwift.Container) {
obj := c.Object("test")
- err := obj.Upload(nil, nil, nil)
+ err := obj.Upload(context.TODO(), nil, nil, nil)
if !expectSuccess(t, err) {
return
}
- hdr, err := obj.Headers()
+ hdr, err := obj.Headers(context.TODO())
if !expectSuccess(t, err) {
return
}
diff --git a/tests/largeobject_test.go b/tests/largeobject_test.go
index 96be854..ac171fd 100644
--- a/tests/largeobject_test.go
+++ b/tests/largeobject_test.go
@@ -20,6 +20,7 @@ package tests
import (
"bytes"
+ "context"
"fmt"
"strings"
"testing"
@@ -37,7 +38,7 @@ func TestLargeObjectsBasic(t *testing.T) {
testWithContainer(t, func(c *schwift.Container) {
foreachLargeObjectStrategy(func(strategy schwift.LargeObjectStrategy, strategyStr string) {
obj := c.Object(strategyStr + "-largeobject")
- _, err := obj.AsLargeObject()
+ _, err := obj.AsLargeObject(context.TODO())
expectError(t, err, schwift.ErrNotLarge.Error())
segment1 := getRandomSegmentContent(128)
@@ -46,14 +47,14 @@ func TestLargeObjectsBasic(t *testing.T) {
segment4 := getRandomSegmentContent(128)
// basic write example
- lo, err := obj.AsNewLargeObject(schwift.SegmentingOptions{
+ lo, err := obj.AsNewLargeObject(context.TODO(), schwift.SegmentingOptions{
SegmentContainer: c,
SegmentPrefix: strategyStr + "-segments/",
Strategy: strategy,
}, nil)
expectSuccess(t, err)
- expectSuccess(t, lo.Append(bytes.NewReader([]byte(segment1+segment2)), 128, nil))
- expectSuccess(t, lo.WriteManifest(nil))
+ expectSuccess(t, lo.Append(context.TODO(), bytes.NewReader([]byte(segment1+segment2)), 128, nil))
+ expectSuccess(t, lo.WriteManifest(context.TODO(), nil))
expectObjectContent(t, obj, []byte(segment1+segment2))
expectLargeObject(t, obj, []schwift.SegmentInfo{
@@ -70,12 +71,12 @@ func TestLargeObjectsBasic(t *testing.T) {
})
// basic append example
- lo, err = obj.AsLargeObject()
+ lo, err = obj.AsLargeObject(context.TODO())
expectSuccess(t, err)
expectLargeObjectSetup(t, lo, strategy,
fmt.Sprintf("%s/%s-segments/", c.Name(), strategyStr))
- expectSuccess(t, lo.Append(bytes.NewReader([]byte(segment3+segment4)), 128, nil))
- expectSuccess(t, lo.WriteManifest(nil))
+ expectSuccess(t, lo.Append(context.TODO(), bytes.NewReader([]byte(segment3+segment4)), 128, nil))
+ expectSuccess(t, lo.WriteManifest(context.TODO(), nil))
expectObjectContent(t, obj, []byte(segment1+segment2+segment3+segment4))
expectLargeObject(t, obj, []schwift.SegmentInfo{
@@ -102,9 +103,9 @@ func TestLargeObjectsBasic(t *testing.T) {
})
// basic truncate example
- lo, err = obj.AsLargeObject()
+ lo, err = obj.AsLargeObject(context.TODO())
expectSuccess(t, err)
- err = lo.Truncate(&schwift.TruncateOptions{
+ err = lo.Truncate(context.TODO(), &schwift.TruncateOptions{
DeleteSegments: true,
})
expectSuccess(t, err)
@@ -114,12 +115,12 @@ func TestLargeObjectsBasic(t *testing.T) {
// verify that segments were deleted
iter := c.Objects()
iter.Prefix = lo.SegmentPrefix()
- names, err := iter.Collect()
+ names, err := iter.Collect(context.TODO())
expectSuccess(t, err)
expectObjectNames(t, names)
- expectSuccess(t, lo.Append(bytes.NewReader([]byte(segment3+segment4)), 128, nil))
- expectSuccess(t, lo.WriteManifest(nil))
+ expectSuccess(t, lo.Append(context.TODO(), bytes.NewReader([]byte(segment3+segment4)), 128, nil))
+ expectSuccess(t, lo.WriteManifest(context.TODO(), nil))
expectObjectContent(t, obj, []byte(segment3+segment4))
expectLargeObject(t, obj, []schwift.SegmentInfo{
@@ -143,7 +144,7 @@ func TestLargeObjectExpiration(t *testing.T) {
foreachLargeObjectStrategy(func(strategy schwift.LargeObjectStrategy, strategyStr string) {
segment := getRandomSegmentContent(128)
obj := c.Object(strategyStr + "-largeobject")
- lo, err := obj.AsNewLargeObject(schwift.SegmentingOptions{
+ lo, err := obj.AsNewLargeObject(context.TODO(), schwift.SegmentingOptions{
SegmentContainer: c,
SegmentPrefix: strategyStr + "-segments/",
Strategy: strategy,
@@ -155,17 +156,17 @@ func TestLargeObjectExpiration(t *testing.T) {
headers := schwift.NewObjectHeaders()
headers.ExpiresAt().Set(expirationTime)
- expectSuccess(t, lo.Append(bytes.NewReader([]byte(segment)), 128, headers.ToOpts()))
- expectSuccess(t, lo.WriteManifest(headers.ToOpts()))
+ expectSuccess(t, lo.Append(context.TODO(), bytes.NewReader([]byte(segment)), 128, headers.ToOpts()))
+ expectSuccess(t, lo.WriteManifest(context.TODO(), headers.ToOpts()))
// check object expiration
- hdr, err := obj.Headers()
+ hdr, err := obj.Headers(context.TODO())
expectSuccess(t, err)
objectExpiration := hdr.ExpiresAt().Get().Format("2006-01-02 15:04:05 +00:00 MST")
expectString(t, objectExpiration, expirationTime.Format("2006-01-02 15:04:05 +00:00 MST"))
// check segment expiration
- hdr, err = c.Object(strategyStr + "-segments/0000000000000001").Headers()
+ hdr, err = c.Object(strategyStr + "-segments/0000000000000001").Headers(context.TODO())
expectSuccess(t, err)
objectExpiration = hdr.ExpiresAt().Get().Format("2006-01-02 15:04:05 +00:00 MST")
expectString(t, objectExpiration, expirationTime.Format("2006-01-02 15:04:05 +00:00 MST"))
@@ -179,7 +180,7 @@ func TestTruncateDuringOverwrite(t *testing.T) {
obj := c.Object("largeobject")
// setup phase: create a large object
- lo, err := obj.AsNewLargeObject(schwift.SegmentingOptions{
+ lo, err := obj.AsNewLargeObject(context.TODO(), schwift.SegmentingOptions{
SegmentContainer: c,
SegmentPrefix: "segments/",
Strategy: strategy,
@@ -188,24 +189,24 @@ func TestTruncateDuringOverwrite(t *testing.T) {
segment1 := getRandomSegmentContent(128)
segment2 := getRandomSegmentContent(128)
- expectSuccess(t, lo.Append(bytes.NewReader([]byte(segment1)), 0, nil))
- expectSuccess(t, lo.Append(bytes.NewReader([]byte(segment2)), 0, nil))
- expectSuccess(t, lo.WriteManifest(nil))
+ expectSuccess(t, lo.Append(context.TODO(), bytes.NewReader([]byte(segment1)), 0, nil))
+ expectSuccess(t, lo.Append(context.TODO(), bytes.NewReader([]byte(segment2)), 0, nil))
+ expectSuccess(t, lo.WriteManifest(context.TODO(), nil))
expectObjectExistence(t, c.Object("segments/0000000000000001"), true)
expectObjectExistence(t, c.Object("segments/0000000000000002"), true)
// test phase: truncate using AsNewLargeObject
- lo, err = obj.AsNewLargeObject(schwift.SegmentingOptions{
+ lo, err = obj.AsNewLargeObject(context.TODO(), schwift.SegmentingOptions{
SegmentContainer: c,
Strategy: strategy,
}, &schwift.TruncateOptions{
DeleteSegments: true,
})
expectSuccess(t, err)
- expectSuccess(t, lo.Append(bytes.NewReader([]byte(segment1)), 0, nil))
- expectSuccess(t, lo.Append(bytes.NewReader([]byte(segment2)), 0, nil))
- expectSuccess(t, lo.WriteManifest(nil))
+ expectSuccess(t, lo.Append(context.TODO(), bytes.NewReader([]byte(segment1)), 0, nil))
+ expectSuccess(t, lo.Append(context.TODO(), bytes.NewReader([]byte(segment2)), 0, nil))
+ expectSuccess(t, lo.WriteManifest(context.TODO(), nil))
expectObjectExistence(t, c.Object("segments/0000000000000001"), false)
expectObjectExistence(t, c.Object("segments/0000000000000002"), false)
@@ -216,8 +217,8 @@ func TestTruncateDuringOverwrite(t *testing.T) {
func TestOpenRegularObjectAsLargeObject(t *testing.T) {
testWithContainer(t, func(c *schwift.Container) {
o := c.Object("foo")
- expectSuccess(t, o.Upload(bytes.NewReader(objectExampleContent), nil, nil))
- _, err := o.AsLargeObject()
+ expectSuccess(t, o.Upload(context.TODO(), bytes.NewReader(objectExampleContent), nil, nil))
+ _, err := o.AsLargeObject(context.TODO())
expectError(t, err, schwift.ErrNotLarge.Error())
})
}
@@ -225,7 +226,7 @@ func TestOpenRegularObjectAsLargeObject(t *testing.T) {
func TestSLOWithDataSegment(t *testing.T) {
testWithContainer(t, func(c *schwift.Container) {
o := c.Object("foo")
- lo, err := o.AsNewLargeObject(schwift.SegmentingOptions{
+ lo, err := o.AsNewLargeObject(context.TODO(), schwift.SegmentingOptions{
SegmentContainer: c,
SegmentPrefix: "segments/",
Strategy: schwift.StaticLargeObject,
@@ -236,10 +237,10 @@ func TestSLOWithDataSegment(t *testing.T) {
dataSegment := schwift.SegmentInfo{Data: []byte("---")}
segment2 := getRandomSegmentContent(128)
- expectSuccess(t, lo.Append(bytes.NewReader([]byte(segment1)), 0, nil))
+ expectSuccess(t, lo.Append(context.TODO(), bytes.NewReader([]byte(segment1)), 0, nil))
expectSuccess(t, lo.AddSegment(dataSegment))
- expectSuccess(t, lo.Append(bytes.NewReader([]byte(segment2)), 0, nil))
- expectSuccess(t, lo.WriteManifest(nil))
+ expectSuccess(t, lo.Append(context.TODO(), bytes.NewReader([]byte(segment2)), 0, nil))
+ expectSuccess(t, lo.WriteManifest(context.TODO(), nil))
expectObjectContent(t, o, []byte(segment1+string(dataSegment.Data)+segment2))
expectLargeObject(t, o, []schwift.SegmentInfo{
@@ -258,7 +259,7 @@ func TestSLOWithDataSegment(t *testing.T) {
// check that truncating this does not try to delete the nil segment.Object
// in the data segment
- expectSuccess(t, lo.Truncate(&schwift.TruncateOptions{
+ expectSuccess(t, lo.Truncate(context.TODO(), &schwift.TruncateOptions{
DeleteSegments: true,
}))
})
@@ -268,10 +269,10 @@ func TestSLOWithRangeSegments(t *testing.T) {
testWithContainer(t, func(c *schwift.Container) {
segmentStr := "<aaa>X<bbb>X<ccc>"
segmentObj := c.Object("segment")
- expectSuccess(t, segmentObj.Upload(bytes.NewReader([]byte(segmentStr)), nil, nil))
+ expectSuccess(t, segmentObj.Upload(context.TODO(), bytes.NewReader([]byte(segmentStr)), nil, nil))
o := c.Object("largeobject")
- lo, err := o.AsNewLargeObject(schwift.SegmentingOptions{
+ lo, err := o.AsNewLargeObject(context.TODO(), schwift.SegmentingOptions{
SegmentContainer: c,
SegmentPrefix: "segments/",
Strategy: schwift.StaticLargeObject,
@@ -293,7 +294,7 @@ func TestSLOWithRangeSegments(t *testing.T) {
RangeOffset: -1,
RangeLength: 5,
}))
- expectSuccess(t, lo.WriteManifest(nil))
+ expectSuccess(t, lo.WriteManifest(context.TODO(), nil))
expectObjectContent(t, o, []byte(
strings.ReplaceAll(segmentStr, "X", ""),
@@ -328,7 +329,7 @@ func TestSLOGuessSegmentPrefix(t *testing.T) {
obj := c.Object("largeobject")
// setup phase: create an SLO
- lo, err := obj.AsNewLargeObject(schwift.SegmentingOptions{
+ lo, err := obj.AsNewLargeObject(context.TODO(), schwift.SegmentingOptions{
SegmentContainer: c,
SegmentPrefix: "foo/bar/baz/",
}, nil)
@@ -336,12 +337,12 @@ func TestSLOGuessSegmentPrefix(t *testing.T) {
segment1 := getRandomSegmentContent(128)
segment2 := getRandomSegmentContent(128)
- expectSuccess(t, lo.Append(bytes.NewReader([]byte(segment1)), 0, nil))
- expectSuccess(t, lo.Append(bytes.NewReader([]byte(segment2)), 0, nil))
- expectSuccess(t, lo.WriteManifest(nil))
+ expectSuccess(t, lo.Append(context.TODO(), bytes.NewReader([]byte(segment1)), 0, nil))
+ expectSuccess(t, lo.Append(context.TODO(), bytes.NewReader([]byte(segment2)), 0, nil))
+ expectSuccess(t, lo.WriteManifest(context.TODO(), nil))
// now create a fresh SLO and check if it infers the correct SegmentPrefix
- lo, err = obj.AsLargeObject()
+ lo, err = obj.AsLargeObject(context.TODO())
expectSuccess(t, err)
expectString(t, lo.SegmentContainer().Name(), c.Name())
expectString(t, lo.SegmentPrefix(), "foo/bar/baz/")
@@ -354,7 +355,7 @@ func TestDeleteLargeObjectAndKeepSegments(t *testing.T) {
obj := c.Object("largeobject")
// setup phase: create a large object
- lo, err := obj.AsNewLargeObject(schwift.SegmentingOptions{
+ lo, err := obj.AsNewLargeObject(context.TODO(), schwift.SegmentingOptions{
SegmentContainer: c,
SegmentPrefix: "foo/bar/baz/",
Strategy: strategy,
@@ -363,16 +364,16 @@ func TestDeleteLargeObjectAndKeepSegments(t *testing.T) {
segment1 := getRandomSegmentContent(128)
segment2 := getRandomSegmentContent(128)
- expectSuccess(t, lo.Append(bytes.NewReader([]byte(segment1)), 0, nil))
- expectSuccess(t, lo.Append(bytes.NewReader([]byte(segment2)), 0, nil))
- expectSuccess(t, lo.WriteManifest(nil))
+ expectSuccess(t, lo.Append(context.TODO(), bytes.NewReader([]byte(segment1)), 0, nil))
+ expectSuccess(t, lo.Append(context.TODO(), bytes.NewReader([]byte(segment2)), 0, nil))
+ expectSuccess(t, lo.WriteManifest(context.TODO(), nil))
// test deletion that keeps segments
- expectSuccess(t, obj.Delete(nil, nil))
+ expectSuccess(t, obj.Delete(context.TODO(), nil, nil))
iter := c.Objects()
iter.Prefix = lo.SegmentPrefix()
- names, err := iter.Collect()
+ names, err := iter.Collect(context.TODO())
expectSuccess(t, err)
expectObjectNames(t, names,
"foo/bar/baz/0000000000000001",
@@ -387,7 +388,7 @@ func TestDeleteLargeObjectIncludingSegments(t *testing.T) {
obj := c.Object("largeobject")
// setup phase: create a large object
- lo, err := obj.AsNewLargeObject(schwift.SegmentingOptions{
+ lo, err := obj.AsNewLargeObject(context.TODO(), schwift.SegmentingOptions{
SegmentContainer: c,
SegmentPrefix: "foo/bar/baz/",
Strategy: strategy,
@@ -396,16 +397,16 @@ func TestDeleteLargeObjectIncludingSegments(t *testing.T) {
segment1 := getRandomSegmentContent(128)
segment2 := getRandomSegmentContent(128)
- expectSuccess(t, lo.Append(bytes.NewReader([]byte(segment1)), 0, nil))
- expectSuccess(t, lo.Append(bytes.NewReader([]byte(segment2)), 0, nil))
- expectSuccess(t, lo.WriteManifest(nil))
+ expectSuccess(t, lo.Append(context.TODO(), bytes.NewReader([]byte(segment1)), 0, nil))
+ expectSuccess(t, lo.Append(context.TODO(), bytes.NewReader([]byte(segment2)), 0, nil))
+ expectSuccess(t, lo.WriteManifest(context.TODO(), nil))
// test deletion that keeps segments
- expectSuccess(t, obj.Delete(&schwift.DeleteOptions{DeleteSegments: true}, nil))
+ expectSuccess(t, obj.Delete(context.TODO(), &schwift.DeleteOptions{DeleteSegments: true}, nil))
iter := c.Objects()
iter.Prefix = lo.SegmentPrefix()
- names, err := iter.Collect()
+ names, err := iter.Collect(context.TODO())
expectSuccess(t, err)
expectObjectNames(t, names)
})
@@ -418,7 +419,7 @@ func TestOverwriteLargeObjectAndKeepSegments(t *testing.T) {
obj := c.Object("largeobject")
// setup phase: create a large object
- lo, err := obj.AsNewLargeObject(schwift.SegmentingOptions{
+ lo, err := obj.AsNewLargeObject(context.TODO(), schwift.SegmentingOptions{
SegmentContainer: c,
SegmentPrefix: "foo/bar/baz/",
Strategy: strategy,
@@ -427,16 +428,16 @@ func TestOverwriteLargeObjectAndKeepSegments(t *testing.T) {
segment1 := getRandomSegmentContent(128)
segment2 := getRandomSegmentContent(128)
- expectSuccess(t, lo.Append(bytes.NewReader([]byte(segment1)), 0, nil))
- expectSuccess(t, lo.Append(bytes.NewReader([]byte(segment2)), 0, nil))
- expectSuccess(t, lo.WriteManifest(nil))
+ expectSuccess(t, lo.Append(context.TODO(), bytes.NewReader([]byte(segment1)), 0, nil))
+ expectSuccess(t, lo.Append(context.TODO(), bytes.NewReader([]byte(segment2)), 0, nil))
+ expectSuccess(t, lo.WriteManifest(context.TODO(), nil))
// test overwriting that keeps segments
- expectSuccess(t, obj.Upload(bytes.NewReader(objectExampleContent), nil, nil))
+ expectSuccess(t, obj.Upload(context.TODO(), bytes.NewReader(objectExampleContent), nil, nil))
iter := c.Objects()
iter.Prefix = lo.SegmentPrefix()
- names, err := iter.Collect()
+ names, err := iter.Collect(context.TODO())
expectSuccess(t, err)
expectObjectNames(t, names,
"foo/bar/baz/0000000000000001",
@@ -451,7 +452,7 @@ func TestOverwriteLargeObjectIncludingSegments(t *testing.T) {
obj := c.Object("largeobject")
// setup phase: create a large object
- lo, err := obj.AsNewLargeObject(schwift.SegmentingOptions{
+ lo, err := obj.AsNewLargeObject(context.TODO(), schwift.SegmentingOptions{
SegmentContainer: c,
SegmentPrefix: "foo/bar/baz/",
Strategy: strategy,
@@ -460,12 +461,13 @@ func TestOverwriteLargeObjectIncludingSegments(t *testing.T) {
segment1 := getRandomSegmentContent(128)
segment2 := getRandomSegmentContent(128)
- expectSuccess(t, lo.Append(bytes.NewReader([]byte(segment1)), 0, nil))
- expectSuccess(t, lo.Append(bytes.NewReader([]byte(segment2)), 0, nil))
- expectSuccess(t, lo.WriteManifest(nil))
+ expectSuccess(t, lo.Append(context.TODO(), bytes.NewReader([]byte(segment1)), 0, nil))
+ expectSuccess(t, lo.Append(context.TODO(), bytes.NewReader([]byte(segment2)), 0, nil))
+ expectSuccess(t, lo.WriteManifest(context.TODO(), nil))
// test overwriting that deletes segments
expectSuccess(t, obj.Upload(
+ context.TODO(),
bytes.NewReader(objectExampleContent),
&schwift.UploadOptions{DeleteSegments: true},
nil,
@@ -473,12 +475,13 @@ func TestOverwriteLargeObjectIncludingSegments(t *testing.T) {
iter := c.Objects()
iter.Prefix = lo.SegmentPrefix()
- names, err := iter.Collect()
+ names, err := iter.Collect(context.TODO())
expectSuccess(t, err)
expectObjectNames(t, names)
// test overwriting that wants to delete segments, but there aren't any
expectSuccess(t, obj.Upload(
+ context.TODO(),
bytes.NewReader(objectExampleContent),
&schwift.UploadOptions{DeleteSegments: true},
nil,
@@ -486,6 +489,7 @@ func TestOverwriteLargeObjectIncludingSegments(t *testing.T) {
// while we're at it, test the same for deletion
expectSuccess(t, obj.Delete(
+ context.TODO(),
&schwift.DeleteOptions{DeleteSegments: true},
nil,
))
@@ -497,7 +501,7 @@ func TestAddInvalidSegments(t *testing.T) {
foreachLargeObjectStrategy(func(strategy schwift.LargeObjectStrategy, strategyStr string) {
testWithContainer(t, func(c *schwift.Container) {
obj := c.Object("largeobject")
- lo, err := obj.AsNewLargeObject(schwift.SegmentingOptions{
+ lo, err := obj.AsNewLargeObject(context.TODO(), schwift.SegmentingOptions{
SegmentContainer: c,
Strategy: strategy,
}, nil)
@@ -566,7 +570,7 @@ func TestAddInvalidSegments(t *testing.T) {
func expectLargeObject(t *testing.T, obj *schwift.Object, expected []schwift.SegmentInfo) {
t.Helper()
expectObjectExistence(t, obj, true)
- lo, err := obj.AsLargeObject()
+ lo, err := obj.AsLargeObject(context.TODO())
expectSuccess(t, err)
if lo == nil {
t.FailNow()
diff --git a/tests/object_iterator_test.go b/tests/object_iterator_test.go
index 2f9143d..b997562 100644
--- a/tests/object_iterator_test.go
+++ b/tests/object_iterator_test.go
@@ -20,6 +20,7 @@ package tests
import (
"bytes"
+ "context"
"fmt"
"strings"
"testing"
@@ -40,52 +41,52 @@ func TestObjectIterator(t *testing.T) {
for idx := 1; idx <= 4; idx++ {
hdr := schwift.NewObjectHeaders()
hdr.ContentType().Set("application/json")
- err := c.Object(oname(idx)).Upload(bytes.NewReader(objectExampleContent), nil, hdr.ToOpts())
+ err := c.Object(oname(idx)).Upload(context.TODO(), bytes.NewReader(objectExampleContent), nil, hdr.ToOpts())
expectSuccess(t, err)
}
// test iteration with empty last page
iter := c.Objects()
iter.Prefix = "schwift-test-listing"
- os, err := iter.NextPage(2)
+ os, err := iter.NextPage(context.TODO(), 2)
expectSuccess(t, err)
expectObjectNames(t, os, oname(1), oname(2))
- os, err = iter.NextPage(2)
+ os, err = iter.NextPage(context.TODO(), 2)
expectSuccess(t, err)
expectObjectNames(t, os, oname(3), oname(4))
- os, err = iter.NextPage(2)
+ os, err = iter.NextPage(context.TODO(), 2)
expectSuccess(t, err)
expectObjectNames(t, os)
- os, err = iter.NextPage(2)
+ os, err = iter.NextPage(context.TODO(), 2)
expectSuccess(t, err)
expectObjectNames(t, os)
// test iteration with partial last page
iter = c.Objects()
iter.Prefix = "schwift-test-listing"
- os, err = iter.NextPage(3)
+ os, err = iter.NextPage(context.TODO(), 3)
expectSuccess(t, err)
expectObjectNames(t, os, oname(1), oname(2), oname(3))
- os, err = iter.NextPage(3)
+ os, err = iter.NextPage(context.TODO(), 3)
expectSuccess(t, err)
expectObjectNames(t, os, oname(4))
- os, err = iter.NextPage(4)
+ os, err = iter.NextPage(context.TODO(), 4)
expectSuccess(t, err)
expectObjectNames(t, os)
// test detailed iteration
iter = c.Objects()
iter.Prefix = "schwift-test-listing"
- ois, err := iter.NextPageDetailed(2)
+ ois, err := iter.NextPageDetailed(context.TODO(), 2)
expectSuccess(t, err)
expectObjectInfos(t, ois, oname(1), oname(2))
- ois, err = iter.NextPageDetailed(3)
+ ois, err = iter.NextPageDetailed(context.TODO(), 3)
expectSuccess(t, err)
expectObjectInfos(t, ois, oname(3), oname(4))
- ois, err = iter.NextPageDetailed(3)
+ ois, err = iter.NextPageDetailed(context.TODO(), 3)
expectSuccess(t, err)
expectObjectInfos(t, ois)
- ois, err = iter.NextPageDetailed(3)
+ ois, err = iter.NextPageDetailed(context.TODO(), 3)
expectSuccess(t, err)
expectObjectInfos(t, ois)
@@ -94,7 +95,7 @@ func TestObjectIterator(t *testing.T) {
iter = c.Objects()
iter.Prefix = "schwift-test-listing"
idx := 0
- expectSuccess(t, iter.Foreach(func(o *schwift.Object) error {
+ expectSuccess(t, iter.Foreach(context.TODO(), func(o *schwift.Object) error {
idx++
expectString(t, o.Name(), oname(idx))
return nil
@@ -107,7 +108,7 @@ func TestObjectIterator(t *testing.T) {
iter = c.Objects()
iter.Prefix = "schwift-test-listing"
idx = 0
- expectSuccess(t, iter.ForeachDetailed(func(info schwift.ObjectInfo) error {
+ expectSuccess(t, iter.ForeachDetailed(context.TODO(), func(info schwift.ObjectInfo) error {
idx++
expectString(t, info.Object.Name(), oname(idx))
return nil
@@ -118,14 +119,14 @@ func TestObjectIterator(t *testing.T) {
// test Collect
iter = c.Objects()
iter.Prefix = "schwift-test-listing"
- os, err = iter.Collect()
+ os, err = iter.Collect(context.TODO())
expectSuccess(t, err)
expectObjectNames(t, os, oname(1), oname(2), oname(3), oname(4))
// test CollectDetailed
iter = c.Objects()
iter.Prefix = "schwift-test-listing"
- ois, err = iter.CollectDetailed()
+ ois, err = iter.CollectDetailed(context.TODO())
expectSuccess(t, err)
expectObjectInfos(t, ois, oname(1), oname(2), oname(3), oname(4))
})
@@ -146,20 +147,20 @@ func TestPseudoDirectories(t *testing.T) {
for _, name := range objectNames {
hdr := schwift.NewObjectHeaders()
hdr.ContentType().Set("application/json")
- err := c.Object(name).Upload(bytes.NewReader(objectExampleContent), nil, hdr.ToOpts())
+ err := c.Object(name).Upload(context.TODO(), bytes.NewReader(objectExampleContent), nil, hdr.ToOpts())
expectSuccess(t, err)
}
// test iteration with Delimiter and no Prefix
iter := c.Objects()
iter.Delimiter = "/"
- os, err := iter.Collect()
+ os, err := iter.Collect(context.TODO())
expectSuccess(t, err)
expectObjectNames(t, os, "foo/")
iter = c.Objects()
iter.Delimiter = "/"
- ois, err := iter.CollectDetailed()
+ ois, err := iter.CollectDetailed(context.TODO())
expectSuccess(t, err)
expectObjectInfos(t, ois, "subdir:foo/")
@@ -167,14 +168,14 @@ func TestPseudoDirectories(t *testing.T) {
iter = c.Objects()
iter.Prefix = "foo/"
iter.Delimiter = "/"
- os, err = iter.Collect()
+ os, err = iter.Collect(context.TODO())
expectSuccess(t, err)
expectObjectNames(t, os, "foo/1", "foo/2", "foo/3", "foo/bar", "foo/bar/")
iter = c.Objects()
iter.Prefix = "foo/"
iter.Delimiter = "/"
- ois, err = iter.CollectDetailed()
+ ois, err = iter.CollectDetailed(context.TODO())
expectSuccess(t, err)
expectObjectInfos(t, ois, "foo/1", "foo/2", "foo/3", "foo/bar", "subdir:foo/bar/")
})
@@ -190,20 +191,20 @@ func TestObjectIteratorWithSymlinks(t *testing.T) {
for _, name := range objectNames {
hdr := schwift.NewObjectHeaders()
hdr.ContentType().Set("application/json")
- err := c.Object(name).Upload(bytes.NewReader(objectExampleContent), nil, hdr.ToOpts())
+ err := c.Object(name).Upload(context.TODO(), bytes.NewReader(objectExampleContent), nil, hdr.ToOpts())
expectSuccess(t, err)
}
// create a test symlink
- expectSuccess(t, c.Object("foo/2").SymlinkTo(c.Object("foo/1"), nil, nil))
+ expectSuccess(t, c.Object("foo/2").SymlinkTo(context.TODO(), c.Object("foo/1"), nil, nil))
iter := c.Objects()
- os, err := iter.Collect()
+ os, err := iter.Collect(context.TODO())
expectSuccess(t, err)
expectObjectNames(t, os, "foo/1", "foo/2", "foo/3")
iter = c.Objects()
- ois, err := iter.CollectDetailed()
+ ois, err := iter.CollectDetailed(context.TODO())
expectSuccess(t, err)
expectObjectInfos(t, ois, "foo/1", "symlink:foo/2>foo/1", "foo/3")
})
@@ -211,7 +212,7 @@ func TestObjectIteratorWithSymlinks(t *testing.T) {
func expectContainerHeadersCached(t *testing.T, c *schwift.Container) {
requestCountBefore := c.Account().Backend().(*RequestCountingBackend).Count
- _, err := c.Headers()
+ _, err := c.Headers(context.TODO())
expectSuccess(t, err)
requestCountAfter := c.Account().Backend().(*RequestCountingBackend).Count
diff --git a/tests/object_test.go b/tests/object_test.go
index 81925d6..18c78f7 100644
--- a/tests/object_test.go
+++ b/tests/object_test.go
@@ -20,6 +20,7 @@ package tests
import (
"bytes"
+ "context"
"fmt"
"io"
"net/http"
@@ -41,22 +42,22 @@ func TestObjectLifecycle(t *testing.T) {
}
expectObjectExistence(t, o, false)
- _, err := o.Headers()
+ _, err := o.Headers(context.TODO())
expectError(t, err, fmt.Sprintf("could not HEAD %q in Swift: expected 200 response, got 404 instead", o.FullName()))
expectBool(t, schwift.Is(err, http.StatusNotFound), true)
expectBool(t, schwift.Is(err, http.StatusNoContent), false)
// DELETE should be idempotent and not return success on non-existence, but
// OpenStack LOVES to be inconsistent with everything (including, notably, itself)
- err = o.Delete(nil, nil)
+ err = o.Delete(context.TODO(), nil, nil)
expectError(t, err, fmt.Sprintf("could not DELETE %q in Swift: expected 204 response, got 404 instead: <html><h1>Not Found</h1><p>The resource could not be found.</p></html>", o.FullName()))
- err = o.Upload(bytes.NewReader([]byte("test")), nil, nil)
+ err = o.Upload(context.TODO(), bytes.NewReader([]byte("test")), nil, nil)
expectSuccess(t, err)
expectObjectExistence(t, o, true)
- err = o.Delete(nil, nil)
+ err = o.Delete(context.TODO(), nil, nil)
expectSuccess(t, err)
})
}
@@ -65,31 +66,31 @@ func TestObjectUpload(t *testing.T) {
testWithContainer(t, func(c *schwift.Container) {
// test upload with bytes.Reader
obj := c.Object("upload1")
- err := obj.Upload(bytes.NewReader(objectExampleContent), nil, nil)
+ err := obj.Upload(context.TODO(), bytes.NewReader(objectExampleContent), nil, nil)
expectSuccess(t, err)
expectObjectContent(t, obj, objectExampleContent)
// test upload with bytes.Buffer
obj = c.Object("upload2")
- err = obj.Upload(bytes.NewBuffer(objectExampleContent), nil, nil)
+ err = obj.Upload(context.TODO(), bytes.NewBuffer(objectExampleContent), nil, nil)
expectSuccess(t, err)
expectObjectContent(t, obj, objectExampleContent)
// test upload with strings.Reader
obj = c.Object("upload3")
- err = obj.Upload(strings.NewReader(string(objectExampleContent)), nil, nil)
+ err = obj.Upload(context.TODO(), strings.NewReader(string(objectExampleContent)), nil, nil)
expectSuccess(t, err)
expectObjectContent(t, obj, objectExampleContent)
// test upload with opaque io.Reader
obj = c.Object("upload4")
- err = obj.Upload(opaqueReader{bytes.NewReader(objectExampleContent)}, nil, nil)
+ err = obj.Upload(context.TODO(), opaqueReader{bytes.NewReader(objectExampleContent)}, nil, nil)
expectSuccess(t, err)
expectObjectContent(t, obj, objectExampleContent)
// test upload with io.Writer
obj = c.Object("upload5")
- err = obj.UploadFromWriter(nil, nil, func(w io.Writer) error {
+ err = obj.UploadFromWriter(context.TODO(), nil, nil, func(w io.Writer) error {
_, err := w.Write(objectExampleContent)
return err
})
@@ -98,13 +99,13 @@ func TestObjectUpload(t *testing.T) {
// test upload with empty reader (should create zero-byte-sized object)
obj = c.Object("upload6")
- err = obj.Upload(eofReader{}, nil, nil)
+ err = obj.Upload(context.TODO(), eofReader{}, nil, nil)
expectSuccess(t, err)
expectObjectContent(t, obj, nil)
// test upload without reader (should create zero-byte-sized object)
obj = c.Object("upload7")
- err = obj.Upload(nil, nil, nil)
+ err = obj.Upload(context.TODO(), nil, nil, nil)
expectSuccess(t, err)
expectObjectContent(t, obj, nil)
})
@@ -128,21 +129,21 @@ func TestObjectDownload(t *testing.T) {
testWithContainer(t, func(c *schwift.Container) {
// upload example object
obj := c.Object("example")
- err := obj.Upload(bytes.NewReader(objectExampleContent), nil, nil)
+ err := obj.Upload(context.TODO(), bytes.NewReader(objectExampleContent), nil, nil)
expectSuccess(t, err)
// test download as string
- str, err := obj.Download(nil).AsString()
+ str, err := obj.Download(context.TODO(), nil).AsString()
expectSuccess(t, err)
expectString(t, str, string(objectExampleContent))
// test download as byte slice
- buf, err := obj.Download(nil).AsByteSlice()
+ buf, err := obj.Download(context.TODO(), nil).AsByteSlice()
expectSuccess(t, err)
expectString(t, string(buf), string(objectExampleContent))
// test download as io.ReadCloser slice
- reader, err := obj.Download(nil).AsReadCloser()
+ reader, err := obj.Download(context.TODO(), nil).AsReadCloser()
expectSuccess(t, err)
buf = make([]byte, 4)
_, err = reader.Read(buf)
@@ -164,23 +165,23 @@ func TestObjectUpdate(t *testing.T) {
// test that metadata update fails for non-existing object
newHeaders := schwift.NewObjectHeaders()
newHeaders.ContentType().Set("application/json")
- err := obj.Update(newHeaders, nil)
+ err := obj.Update(context.TODO(), newHeaders, nil)
expectBool(t, schwift.Is(err, http.StatusNotFound), true)
expectError(t, err, fmt.Sprintf("could not POST %q in Swift: expected 202 response, got 404 instead: <html><h1>Not Found</h1><p>The resource could not be found.</p></html>", obj.FullName()))
// create object
- err = obj.Upload(nil, nil, nil)
+ err = obj.Upload(context.TODO(), nil, nil, nil)
expectSuccess(t, err)
- hdr, err := obj.Headers()
+ hdr, err := obj.Headers(context.TODO())
expectSuccess(t, err)
expectString(t, hdr.ContentType().Get(), "application/octet-stream")
// now the metadata update should work
- err = obj.Update(newHeaders, nil)
+ err = obj.Update(context.TODO(), newHeaders, nil)
expectSuccess(t, err)
obj.Invalidate()
- hdr, err = obj.Headers()
+ hdr, err = obj.Headers(context.TODO())
expectSuccess(t, err)
expectString(t, hdr.ContentType().Get(), "application/json")
})
@@ -189,12 +190,12 @@ func TestObjectUpdate(t *testing.T) {
func TestObjectCopy(t *testing.T) {
testWithContainer(t, func(c *schwift.Container) {
obj1 := c.Object("location1")
- err := obj1.Upload(bytes.NewReader(objectExampleContent), nil, nil)
+ err := obj1.Upload(context.TODO(), bytes.NewReader(objectExampleContent), nil, nil)
expectSuccess(t, err)
expectObjectExistence(t, obj1, true)
obj2 := c.Object("location2")
- expectSuccess(t, obj1.CopyTo(obj2, nil, nil))
+ expectSuccess(t, obj1.CopyTo(context.TODO(), obj2, nil, nil))
expectObjectExistence(t, obj1, true)
expectObjectExistence(t, obj2, true)
expectObjectContent(t, obj2, objectExampleContent)
@@ -205,39 +206,39 @@ func TestSymlinkOperations(t *testing.T) {
testWithContainer(t, func(c *schwift.Container) {
// create a test object that we can link to
obj1 := c.Object("target")
- err := obj1.Upload(bytes.NewReader(objectExampleContent), nil, nil)
+ err := obj1.Upload(context.TODO(), bytes.NewReader(objectExampleContent), nil, nil)
expectSuccess(t, err)
expectObjectExistence(t, obj1, true)
// create a symlink
obj2 := c.Object("symlink")
- expectSuccess(t, obj2.SymlinkTo(obj1, nil, nil))
+ expectSuccess(t, obj2.SymlinkTo(context.TODO(), obj1, nil, nil))
expectObjectExistence(t, obj2, true)
expectObjectSymlink(t, obj2, obj1)
expectObjectContent(t, obj2, objectExampleContent)
// overwrite symlink with normal object
otherContent := []byte("abc")
- expectSuccess(t, obj2.Upload(bytes.NewReader(otherContent), nil, nil))
+ expectSuccess(t, obj2.Upload(context.TODO(), bytes.NewReader(otherContent), nil, nil))
expectObjectExistence(t, obj2, true)
expectObjectSymlink(t, obj2, nil)
expectObjectContent(t, obj2, otherContent)
// overwrite normal object with symlink
- expectSuccess(t, obj2.SymlinkTo(obj1, nil, nil))
+ expectSuccess(t, obj2.SymlinkTo(context.TODO(), obj1, nil, nil))
expectObjectExistence(t, obj2, true)
expectObjectSymlink(t, obj2, obj1)
expectObjectContent(t, obj2, objectExampleContent)
// deep-copy symlink
obj3 := c.Object("copy")
- expectSuccess(t, obj2.CopyTo(obj3, nil, nil))
+ expectSuccess(t, obj2.CopyTo(context.TODO(), obj3, nil, nil))
expectObjectExistence(t, obj3, true)
expectObjectSymlink(t, obj3, nil)
expectObjectContent(t, obj3, objectExampleContent)
// shallow-copy symlink
- expectSuccess(t, obj2.CopyTo(obj3, &schwift.CopyOptions{
+ expectSuccess(t, obj2.CopyTo(context.TODO(), obj3, &schwift.CopyOptions{
ShallowCopySymlinks: true,
}, nil))
expectObjectExistence(t, obj3, true)
@@ -245,7 +246,7 @@ func TestSymlinkOperations(t *testing.T) {
expectObjectContent(t, obj3, objectExampleContent)
// delete symlink
- expectSuccess(t, obj2.Delete(nil, nil))
+ expectSuccess(t, obj2.Delete(context.TODO(), nil, nil))
expectObjectExistence(t, obj2, false)
})
}
@@ -256,18 +257,18 @@ func TestSymlinkOperations(t *testing.T) {
func expectObjectExistence(t *testing.T, obj *schwift.Object, expectedExists bool) {
t.Helper()
obj.Invalidate()
- actualExists, err := obj.Exists()
+ actualExists, err := obj.Exists(context.TODO())
expectSuccess(t, err)
expectBool(t, actualExists, expectedExists)
}
func expectObjectContent(t *testing.T, obj *schwift.Object, expected []byte) {
t.Helper()
- str, err := obj.Download(nil).AsString()
+ str, err := obj.Download(context.TODO(), nil).AsString()
expectSuccess(t, err)
expectString(t, str, string(expected))
obj.Invalidate()
- hdr, err := obj.Headers()
+ hdr, err := obj.Headers(context.TODO())
expectSuccess(t, err)
if !hdr.IsLargeObject() {
expectString(t, hdr.Etag().Get(), etagOf(expected))
@@ -276,7 +277,7 @@ func expectObjectContent(t *testing.T, obj *schwift.Object, expected []byte) {
func expectObjectSymlink(t *testing.T, source, expectedTarget *schwift.Object) {
t.Helper()
- _, target, err := source.SymlinkHeaders()
+ _, target, err := source.SymlinkHeaders(context.TODO())
if expectedTarget == nil {
switch err {
case nil:
diff --git a/tests/shared_test.go b/tests/shared_test.go
index a3ef610..1154b83 100644
--- a/tests/shared_test.go
+++ b/tests/shared_test.go
@@ -87,19 +87,19 @@ func testWithAccount(t *testing.T, testCode func(a *schwift.Account)) {
func testWithContainer(t *testing.T, testCode func(c *schwift.Container)) {
testWithAccount(t, func(a *schwift.Account) {
containerName := getRandomName()
- container, err := a.Container(containerName).EnsureExists()
+ container, err := a.Container(containerName).EnsureExists(context.TODO())
expectSuccess(t, err)
testCode(container)
// cleanup
- exists, err := container.Exists()
+ exists, err := container.Exists(context.TODO())
expectSuccess(t, err)
if exists {
- expectSuccess(t, container.Objects().Foreach(func(o *schwift.Object) error {
- return o.Delete(nil, nil)
+ expectSuccess(t, container.Objects().Foreach(context.TODO(), func(o *schwift.Object) error {
+ return o.Delete(context.TODO(), nil, nil)
}))
- err = container.Delete(nil)
+ err = container.Delete(context.TODO(), nil)
expectSuccess(t, err)
}
})
generated by cgit v1.2.3 (git 2.25.1) at 2026-06-08 13:41:39 +0000