aboutsummaryrefslogtreecommitdiff
path: root/tests/largeobject_test.go
diff options
context:
space:
mode:
Diffstat (limited to 'tests/largeobject_test.go')
-rw-r--r--tests/largeobject_test.go134
1 files changed, 69 insertions, 65 deletions
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()
generated by cgit v1.2.3 (git 2.25.1) at 2026-06-08 14:29:39 +0000