X-Git-Url: https://git.arvados.org/arvados.git/blobdiff_plain/743022a885b563e47bc5d31e144b5165ab4688c9..56edfaae396bd3e2c69d19425d887abe7e3bc0d5:/services/keepstore/volume_generic_test.go diff --git a/services/keepstore/volume_generic_test.go b/services/keepstore/volume_generic_test.go index c08c3f5f00..61088f10fa 100644 --- a/services/keepstore/volume_generic_test.go +++ b/services/keepstore/volume_generic_test.go @@ -2,6 +2,8 @@ package main import ( "bytes" + "crypto/md5" + "fmt" "os" "regexp" "sort" @@ -22,6 +24,7 @@ func DoGenericVolumeTests(t *testing.T, factory TestableVolumeFactory) { testGet(t, factory) testGetNoSuchBlock(t, factory) + testCompareNonexistent(t, factory) testCompareSameContent(t, factory, TestHash, TestBlock) testCompareSameContent(t, factory, EmptyHash, EmptyBlock) testCompareWithCollision(t, factory, TestHash, TestBlock, []byte("baddata")) @@ -58,6 +61,8 @@ func DoGenericVolumeTests(t *testing.T, factory TestableVolumeFactory) { testGetConcurrent(t, factory) testPutConcurrent(t, factory) + + testPutFullBlock(t, factory) } // Put a test block, get it and verify content @@ -70,7 +75,7 @@ func testGet(t *testing.T, factory TestableVolumeFactory) { buf, err := v.Get(TestHash) if err != nil { - t.Error(err) + t.Fatal(err) } bufs.Put(buf) @@ -91,6 +96,19 @@ func testGetNoSuchBlock(t *testing.T, factory TestableVolumeFactory) { } } +// Compare() should return os.ErrNotExist if the block does not exist. +// Otherwise, writing new data causes CompareAndTouch() to generate +// error logs even though everything is working fine. +func testCompareNonexistent(t *testing.T, factory TestableVolumeFactory) { + v := factory(t) + defer v.Teardown() + + err := v.Compare(TestHash, TestBlock) + if err != os.ErrNotExist { + t.Errorf("Got err %T %q, expected os.ErrNotExist", err, err) + } +} + // Put a test block and compare the locator with same content // Test should pass for both writable and read-only volumes func testCompareSameContent(t *testing.T, factory TestableVolumeFactory, testHash string, testData []byte) { @@ -182,14 +200,14 @@ func testPutBlockWithDifferentContent(t *testing.T, factory TestableVolumeFactor // Put must not return a nil error unless it has // overwritten the existing data. if bytes.Compare(buf, testDataB) != 0 { - t.Errorf("Put succeeded but Get returned %+v, expected %+v", buf, testDataB) + t.Errorf("Put succeeded but Get returned %+q, expected %+q", buf, testDataB) } } else { // It is permissible for Put to fail, but it must // leave us with either the original data, the new // data, or nothing at all. if getErr == nil && bytes.Compare(buf, testDataA) != 0 && bytes.Compare(buf, testDataB) != 0 { - t.Errorf("Put failed but Get returned %+v, which is neither %+v nor %+v", buf, testDataA, testDataB) + t.Errorf("Put failed but Get returned %+q, which is neither %+q nor %+q", buf, testDataA, testDataB) } } if getErr == nil { @@ -225,26 +243,32 @@ func testPutMultipleBlocks(t *testing.T, factory TestableVolumeFactory) { data, err := v.Get(TestHash) if err != nil { t.Error(err) - } else if bytes.Compare(data, TestBlock) != 0 { - t.Errorf("Block present, but content is incorrect: Expected: %v Found: %v", data, TestBlock) + } else { + if bytes.Compare(data, TestBlock) != 0 { + t.Errorf("Block present, but got %+q, expected %+q", data, TestBlock) + } + bufs.Put(data) } - bufs.Put(data) data, err = v.Get(TestHash2) if err != nil { t.Error(err) - } else if bytes.Compare(data, TestBlock2) != 0 { - t.Errorf("Block present, but content is incorrect: Expected: %v Found: %v", data, TestBlock2) + } else { + if bytes.Compare(data, TestBlock2) != 0 { + t.Errorf("Block present, but got %+q, expected %+q", data, TestBlock2) + } + bufs.Put(data) } - bufs.Put(data) data, err = v.Get(TestHash3) if err != nil { t.Error(err) - } else if bytes.Compare(data, TestBlock3) != 0 { - t.Errorf("Block present, but content is incorrect: Expected: %v Found: %v", data, TestBlock3) + } else { + if bytes.Compare(data, TestBlock3) != 0 { + t.Errorf("Block present, but to %+q, expected %+q", data, TestBlock3) + } + bufs.Put(data) } - bufs.Put(data) } // testPutAndTouch @@ -326,6 +350,13 @@ func testIndexTo(t *testing.T, factory TestableVolumeFactory) { v.PutRaw(TestHash2, TestBlock2) v.PutRaw(TestHash3, TestBlock3) + // Blocks whose names aren't Keep hashes should be omitted from + // index + v.PutRaw("fffffffffnotreallyahashfffffffff", nil) + v.PutRaw("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", nil) + v.PutRaw("f0000000000000000000000000000000f", nil) + v.PutRaw("f00", nil) + buf := new(bytes.Buffer) v.IndexTo("", buf) indexRows := strings.Split(string(buf.Bytes()), "\n") @@ -371,6 +402,7 @@ func testIndexTo(t *testing.T, factory TestableVolumeFactory) { func testDeleteNewBlock(t *testing.T, factory TestableVolumeFactory) { v := factory(t) defer v.Teardown() + blobSignatureTTL = 300 * time.Second if v.Writable() == false { return @@ -384,10 +416,12 @@ func testDeleteNewBlock(t *testing.T, factory TestableVolumeFactory) { data, err := v.Get(TestHash) if err != nil { t.Error(err) - } else if bytes.Compare(data, TestBlock) != 0 { - t.Error("Block still present, but content is incorrect: %+v != %+v", data, TestBlock) + } else { + if bytes.Compare(data, TestBlock) != 0 { + t.Errorf("Got data %+q, expected %+q", data, TestBlock) + } + bufs.Put(data) } - bufs.Put(data) } // Calling Delete() for a block with a timestamp older than @@ -396,19 +430,20 @@ func testDeleteNewBlock(t *testing.T, factory TestableVolumeFactory) { func testDeleteOldBlock(t *testing.T, factory TestableVolumeFactory) { v := factory(t) defer v.Teardown() + blobSignatureTTL = 300 * time.Second if v.Writable() == false { return } v.Put(TestHash, TestBlock) - v.TouchWithDate(TestHash, time.Now().Add(-2*blobSignatureTTL*time.Second)) + v.TouchWithDate(TestHash, time.Now().Add(-2*blobSignatureTTL)) if err := v.Delete(TestHash); err != nil { t.Error(err) } if _, err := v.Get(TestHash); err == nil || !os.IsNotExist(err) { - t.Errorf("os.IsNotExist(%v) should have been true", err.Error()) + t.Errorf("os.IsNotExist(%v) should have been true", err) } } @@ -623,3 +658,31 @@ func testPutConcurrent(t *testing.T, factory TestableVolumeFactory) { t.Errorf("Get #3: expected %s, got %s", string(TestBlock3), string(buf)) } } + +// Write and read back a full size block +func testPutFullBlock(t *testing.T, factory TestableVolumeFactory) { + v := factory(t) + defer v.Teardown() + + if !v.Writable() { + return + } + + wdata := make([]byte, BlockSize) + wdata[0] = 'a' + wdata[BlockSize-1] = 'z' + hash := fmt.Sprintf("%x", md5.Sum(wdata)) + err := v.Put(hash, wdata) + if err != nil { + t.Fatal(err) + } + rdata, err := v.Get(hash) + if err != nil { + t.Error(err) + } else { + defer bufs.Put(rdata) + } + if bytes.Compare(rdata, wdata) != 0 { + t.Error("rdata != wdata") + } +}