10383: Merge branch 'master' into 10383-arv-put-incremental-upload

[arvados.git] / services / keepstore / volume_generic_test.go

diff --git a/services/keepstore/volume_generic_test.go b/services/keepstore/volume_generic_test.go
index d91092624ec6c0bb15ca78ecb50830429aa10297..7e72a8f246ee60410e7110417de3284ae4263ca3 100644 (file)
--- a/services/keepstore/volume_generic_test.go
+++ b/services/keepstore/volume_generic_test.go
@@ -93,7 +93,7 @@ func testGet(t TB, factory TestableVolumeFactory) {
        v.PutRaw(TestHash, TestBlock)
 
        buf := make([]byte, BlockSize)
-       n, err := v.Get(context.TODO(), TestHash, buf)
+       n, err := v.Get(context.Background(), TestHash, buf)
        if err != nil {
                t.Fatal(err)
        }
@@ -110,7 +110,7 @@ func testGetNoSuchBlock(t TB, factory TestableVolumeFactory) {
        defer v.Teardown()
 
        buf := make([]byte, BlockSize)
-       if _, err := v.Get(context.TODO(), TestHash2, buf); err == nil {
+       if _, err := v.Get(context.Background(), TestHash2, buf); err == nil {
                t.Errorf("Expected error while getting non-existing block %v", TestHash2)
        }
 }
@@ -122,7 +122,7 @@ func testCompareNonexistent(t TB, factory TestableVolumeFactory) {
        v := factory(t)
        defer v.Teardown()
 
-       err := v.Compare(context.TODO(), TestHash, TestBlock)
+       err := v.Compare(context.Background(), TestHash, TestBlock)
        if err != os.ErrNotExist {
                t.Errorf("Got err %T %q, expected os.ErrNotExist", err, err)
        }
@@ -137,7 +137,7 @@ func testCompareSameContent(t TB, factory TestableVolumeFactory, testHash string
        v.PutRaw(testHash, testData)
 
        // Compare the block locator with same content
-       err := v.Compare(context.TODO(), testHash, testData)
+       err := v.Compare(context.Background(), testHash, testData)
        if err != nil {
                t.Errorf("Got err %q, expected nil", err)
        }
@@ -155,7 +155,7 @@ func testCompareWithCollision(t TB, factory TestableVolumeFactory, testHash stri
        v.PutRaw(testHash, testDataA)
 
        // Compare the block locator with different content; collision
-       err := v.Compare(context.TODO(), TestHash, testDataB)
+       err := v.Compare(context.Background(), TestHash, testDataB)
        if err == nil {
                t.Errorf("Got err nil, expected error due to collision")
        }
@@ -171,7 +171,7 @@ func testCompareWithCorruptStoredData(t TB, factory TestableVolumeFactory, testH
 
        v.PutRaw(TestHash, testDataB)
 
-       err := v.Compare(context.TODO(), testHash, testDataA)
+       err := v.Compare(context.Background(), testHash, testDataA)
        if err == nil || err == CollisionError {
                t.Errorf("Got err %+v, expected non-collision error", err)
        }
@@ -187,12 +187,12 @@ func testPutBlockWithSameContent(t TB, factory TestableVolumeFactory, testHash s
                return
        }
 
-       err := v.Put(context.TODO(), testHash, testData)
+       err := v.Put(context.Background(), testHash, testData)
        if err != nil {
                t.Errorf("Got err putting block %q: %q, expected nil", TestBlock, err)
        }
 
-       err = v.Put(context.TODO(), testHash, testData)
+       err = v.Put(context.Background(), testHash, testData)
        if err != nil {
                t.Errorf("Got err putting block second time %q: %q, expected nil", TestBlock, err)
        }
@@ -210,9 +210,9 @@ func testPutBlockWithDifferentContent(t TB, factory TestableVolumeFactory, testH
 
        v.PutRaw(testHash, testDataA)
 
-       putErr := v.Put(context.TODO(), testHash, testDataB)
+       putErr := v.Put(context.Background(), testHash, testDataB)
        buf := make([]byte, BlockSize)
-       n, getErr := v.Get(context.TODO(), testHash, buf)
+       n, getErr := v.Get(context.Background(), testHash, buf)
        if putErr == nil {
                // Put must not return a nil error unless it has
                // overwritten the existing data.
@@ -239,23 +239,23 @@ func testPutMultipleBlocks(t TB, factory TestableVolumeFactory) {
                return
        }
 
-       err := v.Put(context.TODO(), TestHash, TestBlock)
+       err := v.Put(context.Background(), TestHash, TestBlock)
        if err != nil {
                t.Errorf("Got err putting block %q: %q, expected nil", TestBlock, err)
        }
 
-       err = v.Put(context.TODO(), TestHash2, TestBlock2)
+       err = v.Put(context.Background(), TestHash2, TestBlock2)
        if err != nil {
                t.Errorf("Got err putting block %q: %q, expected nil", TestBlock2, err)
        }
 
-       err = v.Put(context.TODO(), TestHash3, TestBlock3)
+       err = v.Put(context.Background(), TestHash3, TestBlock3)
        if err != nil {
                t.Errorf("Got err putting block %q: %q, expected nil", TestBlock3, err)
        }
 
        data := make([]byte, BlockSize)
-       n, err := v.Get(context.TODO(), TestHash, data)
+       n, err := v.Get(context.Background(), TestHash, data)
        if err != nil {
                t.Error(err)
        } else {
@@ -264,7 +264,7 @@ func testPutMultipleBlocks(t TB, factory TestableVolumeFactory) {
                }
        }
 
-       n, err = v.Get(context.TODO(), TestHash2, data)
+       n, err = v.Get(context.Background(), TestHash2, data)
        if err != nil {
                t.Error(err)
        } else {
@@ -273,7 +273,7 @@ func testPutMultipleBlocks(t TB, factory TestableVolumeFactory) {
                }
        }
 
-       n, err = v.Get(context.TODO(), TestHash3, data)
+       n, err = v.Get(context.Background(), TestHash3, data)
        if err != nil {
                t.Error(err)
        } else {
@@ -295,7 +295,7 @@ func testPutAndTouch(t TB, factory TestableVolumeFactory) {
                return
        }
 
-       if err := v.Put(context.TODO(), TestHash, TestBlock); err != nil {
+       if err := v.Put(context.Background(), TestHash, TestBlock); err != nil {
                t.Error(err)
        }
 
@@ -315,7 +315,7 @@ func testPutAndTouch(t TB, factory TestableVolumeFactory) {
        }
 
        // Write the same block again.
-       if err := v.Put(context.TODO(), TestHash, TestBlock); err != nil {
+       if err := v.Put(context.Background(), TestHash, TestBlock); err != nil {
                t.Error(err)
        }
 
@@ -438,13 +438,13 @@ func testDeleteNewBlock(t TB, factory TestableVolumeFactory) {
                return
        }
 
-       v.Put(context.TODO(), TestHash, TestBlock)
+       v.Put(context.Background(), TestHash, TestBlock)
 
        if err := v.Trash(TestHash); err != nil {
                t.Error(err)
        }
        data := make([]byte, BlockSize)
-       n, err := v.Get(context.TODO(), TestHash, data)
+       n, err := v.Get(context.Background(), TestHash, data)
        if err != nil {
                t.Error(err)
        } else if bytes.Compare(data[:n], TestBlock) != 0 {
@@ -464,14 +464,14 @@ func testDeleteOldBlock(t TB, factory TestableVolumeFactory) {
                return
        }
 
-       v.Put(context.TODO(), TestHash, TestBlock)
+       v.Put(context.Background(), TestHash, TestBlock)
        v.TouchWithDate(TestHash, time.Now().Add(-2*theConfig.BlobSignatureTTL.Duration()))
 
        if err := v.Trash(TestHash); err != nil {
                t.Error(err)
        }
        data := make([]byte, BlockSize)
-       if _, err := v.Get(context.TODO(), TestHash, data); err == nil || !os.IsNotExist(err) {
+       if _, err := v.Get(context.Background(), TestHash, data); err == nil || !os.IsNotExist(err) {
                t.Errorf("os.IsNotExist(%v) should have been true", err)
        }
 
@@ -480,7 +480,7 @@ func testDeleteOldBlock(t TB, factory TestableVolumeFactory) {
                t.Fatalf("os.IsNotExist(%v) should have been true", err)
        }
 
-       err = v.Compare(context.TODO(), TestHash, TestBlock)
+       err = v.Compare(context.Background(), TestHash, TestBlock)
        if err == nil || !os.IsNotExist(err) {
                t.Fatalf("os.IsNotExist(%v) should have been true", err)
        }
@@ -554,17 +554,17 @@ func testUpdateReadOnly(t TB, factory TestableVolumeFactory) {
        buf := make([]byte, BlockSize)
 
        // Get from read-only volume should succeed
-       _, err := v.Get(context.TODO(), TestHash, buf)
+       _, err := v.Get(context.Background(), TestHash, buf)
        if err != nil {
                t.Errorf("got err %v, expected nil", err)
        }
 
        // Put a new block to read-only volume should result in error
-       err = v.Put(context.TODO(), TestHash2, TestBlock2)
+       err = v.Put(context.Background(), TestHash2, TestBlock2)
        if err == nil {
                t.Errorf("Expected error when putting block in a read-only volume")
        }
-       _, err = v.Get(context.TODO(), TestHash2, buf)
+       _, err = v.Get(context.Background(), TestHash2, buf)
        if err == nil {
                t.Errorf("Expected error when getting block whose put in read-only volume failed")
        }
@@ -582,7 +582,7 @@ func testUpdateReadOnly(t TB, factory TestableVolumeFactory) {
        }
 
        // Overwriting an existing block in read-only volume should result in error
-       err = v.Put(context.TODO(), TestHash, TestBlock)
+       err = v.Put(context.Background(), TestHash, TestBlock)
        if err == nil {
                t.Errorf("Expected error when putting block in a read-only volume")
        }
@@ -601,7 +601,7 @@ func testGetConcurrent(t TB, factory TestableVolumeFactory) {
        sem := make(chan int)
        go func() {
                buf := make([]byte, BlockSize)
-               n, err := v.Get(context.TODO(), TestHash, buf)
+               n, err := v.Get(context.Background(), TestHash, buf)
                if err != nil {
                        t.Errorf("err1: %v", err)
                }
@@ -613,7 +613,7 @@ func testGetConcurrent(t TB, factory TestableVolumeFactory) {
 
        go func() {
                buf := make([]byte, BlockSize)
-               n, err := v.Get(context.TODO(), TestHash2, buf)
+               n, err := v.Get(context.Background(), TestHash2, buf)
                if err != nil {
                        t.Errorf("err2: %v", err)
                }
@@ -625,7 +625,7 @@ func testGetConcurrent(t TB, factory TestableVolumeFactory) {
 
        go func() {
                buf := make([]byte, BlockSize)
-               n, err := v.Get(context.TODO(), TestHash3, buf)
+               n, err := v.Get(context.Background(), TestHash3, buf)
                if err != nil {
                        t.Errorf("err3: %v", err)
                }
@@ -653,7 +653,7 @@ func testPutConcurrent(t TB, factory TestableVolumeFactory) {
 
        sem := make(chan int)
        go func(sem chan int) {
-               err := v.Put(context.TODO(), TestHash, TestBlock)
+               err := v.Put(context.Background(), TestHash, TestBlock)
                if err != nil {
                        t.Errorf("err1: %v", err)
                }
@@ -661,7 +661,7 @@ func testPutConcurrent(t TB, factory TestableVolumeFactory) {
        }(sem)
 
        go func(sem chan int) {
-               err := v.Put(context.TODO(), TestHash2, TestBlock2)
+               err := v.Put(context.Background(), TestHash2, TestBlock2)
                if err != nil {
                        t.Errorf("err2: %v", err)
                }
@@ -669,7 +669,7 @@ func testPutConcurrent(t TB, factory TestableVolumeFactory) {
        }(sem)
 
        go func(sem chan int) {
-               err := v.Put(context.TODO(), TestHash3, TestBlock3)
+               err := v.Put(context.Background(), TestHash3, TestBlock3)
                if err != nil {
                        t.Errorf("err3: %v", err)
                }
@@ -683,7 +683,7 @@ func testPutConcurrent(t TB, factory TestableVolumeFactory) {
 
        // Double check that we actually wrote the blocks we expected to write.
        buf := make([]byte, BlockSize)
-       n, err := v.Get(context.TODO(), TestHash, buf)
+       n, err := v.Get(context.Background(), TestHash, buf)
        if err != nil {
                t.Errorf("Get #1: %v", err)
        }
@@ -691,7 +691,7 @@ func testPutConcurrent(t TB, factory TestableVolumeFactory) {
                t.Errorf("Get #1: expected %s, got %s", string(TestBlock), string(buf[:n]))
        }
 
-       n, err = v.Get(context.TODO(), TestHash2, buf)
+       n, err = v.Get(context.Background(), TestHash2, buf)
        if err != nil {
                t.Errorf("Get #2: %v", err)
        }
@@ -699,7 +699,7 @@ func testPutConcurrent(t TB, factory TestableVolumeFactory) {
                t.Errorf("Get #2: expected %s, got %s", string(TestBlock2), string(buf[:n]))
        }
 
-       n, err = v.Get(context.TODO(), TestHash3, buf)
+       n, err = v.Get(context.Background(), TestHash3, buf)
        if err != nil {
                t.Errorf("Get #3: %v", err)
        }
@@ -721,12 +721,12 @@ func testPutFullBlock(t TB, factory TestableVolumeFactory) {
        wdata[0] = 'a'
        wdata[BlockSize-1] = 'z'
        hash := fmt.Sprintf("%x", md5.Sum(wdata))
-       err := v.Put(context.TODO(), hash, wdata)
+       err := v.Put(context.Background(), hash, wdata)
        if err != nil {
                t.Fatal(err)
        }
        buf := make([]byte, BlockSize)
-       n, err := v.Get(context.TODO(), hash, buf)
+       n, err := v.Get(context.Background(), hash, buf)
        if err != nil {
                t.Error(err)
        }
@@ -753,7 +753,7 @@ func testTrashUntrash(t TB, factory TestableVolumeFactory) {
        v.TouchWithDate(TestHash, time.Now().Add(-2*theConfig.BlobSignatureTTL.Duration()))
 
        buf := make([]byte, BlockSize)
-       n, err := v.Get(context.TODO(), TestHash, buf)
+       n, err := v.Get(context.Background(), TestHash, buf)
        if err != nil {
                t.Fatal(err)
        }
@@ -772,7 +772,7 @@ func testTrashUntrash(t TB, factory TestableVolumeFactory) {
                        t.Fatal(err)
                }
        } else {
-               _, err = v.Get(context.TODO(), TestHash, buf)
+               _, err = v.Get(context.Background(), TestHash, buf)
                if err == nil || !os.IsNotExist(err) {
                        t.Errorf("os.IsNotExist(%v) should have been true", err)
                }
@@ -785,7 +785,7 @@ func testTrashUntrash(t TB, factory TestableVolumeFactory) {
        }
 
        // Get the block - after trash and untrash sequence
-       n, err = v.Get(context.TODO(), TestHash, buf)
+       n, err = v.Get(context.Background(), TestHash, buf)
        if err != nil {
                t.Fatal(err)
        }
@@ -803,7 +803,7 @@ func testTrashEmptyTrashUntrash(t TB, factory TestableVolumeFactory) {
 
        checkGet := func() error {
                buf := make([]byte, BlockSize)
-               n, err := v.Get(context.TODO(), TestHash, buf)
+               n, err := v.Get(context.Background(), TestHash, buf)
                if err != nil {
                        return err
                }
@@ -816,7 +816,7 @@ func testTrashEmptyTrashUntrash(t TB, factory TestableVolumeFactory) {
                        return err
                }
 
-               err = v.Compare(context.TODO(), TestHash, TestBlock)
+               err = v.Compare(context.Background(), TestHash, TestBlock)
                if err != nil {
                        return err
                }