X-Git-Url: https://git.arvados.org/arvados.git/blobdiff_plain/b9e48b6cbfff91b05af44cf1410120468a385aba..acd1241cec9260d54c2dca55785e309644334c41:/services/keepstore/volume_generic_test.go diff --git a/services/keepstore/volume_generic_test.go b/services/keepstore/volume_generic_test.go index 9e2e6c639a..c08c3f5f00 100644 --- a/services/keepstore/volume_generic_test.go +++ b/services/keepstore/volume_generic_test.go @@ -11,24 +11,32 @@ import ( ) // A TestableVolumeFactory returns a new TestableVolume. The factory -// function, and the TestableVolume it returns, can use t to write +// function, and the TestableVolume it returns, can use "t" to write // logs, fail the current test, etc. type TestableVolumeFactory func(t *testing.T) TestableVolume // DoGenericVolumeTests runs a set of tests that every TestableVolume -// is expected to pass. It calls factory to create a new writable -// TestableVolume for each test case, to avoid leaking state between -// tests. +// is expected to pass. It calls factory to create a new TestableVolume +// for each test case, to avoid leaking state between tests. func DoGenericVolumeTests(t *testing.T, factory TestableVolumeFactory) { testGet(t, factory) testGetNoSuchBlock(t, factory) - testCompareSameContent(t, factory) - testCompareWithDifferentContent(t, factory) - testCompareWithBadData(t, factory) - - testPutBlockWithSameContent(t, factory) - testPutBlockWithDifferentContent(t, factory) + testCompareSameContent(t, factory, TestHash, TestBlock) + testCompareSameContent(t, factory, EmptyHash, EmptyBlock) + testCompareWithCollision(t, factory, TestHash, TestBlock, []byte("baddata")) + testCompareWithCollision(t, factory, TestHash, TestBlock, EmptyBlock) + testCompareWithCollision(t, factory, EmptyHash, EmptyBlock, TestBlock) + testCompareWithCorruptStoredData(t, factory, TestHash, TestBlock, []byte("baddata")) + testCompareWithCorruptStoredData(t, factory, TestHash, TestBlock, EmptyBlock) + testCompareWithCorruptStoredData(t, factory, EmptyHash, EmptyBlock, []byte("baddata")) + + testPutBlockWithSameContent(t, factory, TestHash, TestBlock) + testPutBlockWithSameContent(t, factory, EmptyHash, EmptyBlock) + testPutBlockWithDifferentContent(t, factory, TestHash, TestBlock, TestBlock2) + testPutBlockWithDifferentContent(t, factory, TestHash, EmptyBlock, TestBlock) + testPutBlockWithDifferentContent(t, factory, TestHash, TestBlock, EmptyBlock) + testPutBlockWithDifferentContent(t, factory, EmptyHash, EmptyBlock, TestBlock) testPutMultipleBlocks(t, factory) testPutAndTouch(t, factory) @@ -46,134 +54,142 @@ func DoGenericVolumeTests(t *testing.T, factory TestableVolumeFactory) { testString(t, factory) - testWritableTrue(t, factory) + testUpdateReadOnly(t, factory) testGetConcurrent(t, factory) testPutConcurrent(t, factory) } -// DoGenericReadOnlyVolumeTests runs a set of tests that every -// read-only TestableVolume is expected to pass. It calls factory -// to create a new read-only TestableVolume for each test case, -// to avoid leaking state between tests. -func DoGenericReadOnlyVolumeTests(t *testing.T, factory TestableVolumeFactory) { - testWritableFalse(t, factory) - testUpdateReadOnly(t, factory) -} - // Put a test block, get it and verify content +// Test should pass for both writable and read-only volumes func testGet(t *testing.T, factory TestableVolumeFactory) { v := factory(t) defer v.Teardown() - v.Put(TEST_HASH, TEST_BLOCK) - buf, err := v.Get(TEST_HASH) + v.PutRaw(TestHash, TestBlock) + + buf, err := v.Get(TestHash) if err != nil { t.Error(err) } bufs.Put(buf) - if bytes.Compare(buf, TEST_BLOCK) != 0 { - t.Errorf("expected %s, got %s", string(TEST_BLOCK), string(buf)) + if bytes.Compare(buf, TestBlock) != 0 { + t.Errorf("expected %s, got %s", string(TestBlock), string(buf)) } } // Invoke get on a block that does not exist in volume; should result in error +// Test should pass for both writable and read-only volumes func testGetNoSuchBlock(t *testing.T, factory TestableVolumeFactory) { v := factory(t) defer v.Teardown() - v.Put(TEST_HASH, TEST_BLOCK) - if _, err := v.Get(TEST_HASH_2); err == nil { - t.Errorf("Expected error while getting non-existing block %v", TEST_HASH_2) + if _, err := v.Get(TestHash2); err == nil { + t.Errorf("Expected error while getting non-existing block %v", TestHash2) } } // Put a test block and compare the locator with same content -func testCompareSameContent(t *testing.T, factory TestableVolumeFactory) { +// Test should pass for both writable and read-only volumes +func testCompareSameContent(t *testing.T, factory TestableVolumeFactory, testHash string, testData []byte) { v := factory(t) defer v.Teardown() - v.Put(TEST_HASH, TEST_BLOCK) + v.PutRaw(testHash, testData) // Compare the block locator with same content - err := v.Compare(TEST_HASH, TEST_BLOCK) + err := v.Compare(testHash, testData) if err != nil { t.Errorf("Got err %q, expected nil", err) } } -// Put a test block and compare the locator with a different content -// Expect error due to collision -func testCompareWithDifferentContent(t *testing.T, factory TestableVolumeFactory) { +// Test behavior of Compare() when stored data matches expected +// checksum but differs from new data we need to store. Requires +// testHash = md5(testDataA). +// +// Test should pass for both writable and read-only volumes +func testCompareWithCollision(t *testing.T, factory TestableVolumeFactory, testHash string, testDataA, testDataB []byte) { v := factory(t) defer v.Teardown() - v.Put(TEST_HASH, TEST_BLOCK) + v.PutRaw(testHash, testDataA) // Compare the block locator with different content; collision - err := v.Compare(TEST_HASH, []byte("baddata")) + err := v.Compare(TestHash, testDataB) if err == nil { - t.Errorf("Expected error due to collision") + t.Errorf("Got err nil, expected error due to collision") } } -// Put a test block with bad data (hash does not match, but Put does not verify) -// Compare the locator with good data whose has matches with locator -// Expect error due to corruption. -func testCompareWithBadData(t *testing.T, factory TestableVolumeFactory) { +// Test behavior of Compare() when stored data has become +// corrupted. Requires testHash = md5(testDataA) != md5(testDataB). +// +// Test should pass for both writable and read-only volumes +func testCompareWithCorruptStoredData(t *testing.T, factory TestableVolumeFactory, testHash string, testDataA, testDataB []byte) { v := factory(t) defer v.Teardown() - v.Put(TEST_HASH, []byte("baddata")) + v.PutRaw(TestHash, testDataB) - err := v.Compare(TEST_HASH, TEST_BLOCK) - if err == nil { - t.Errorf("Expected error due to corruption") + err := v.Compare(testHash, testDataA) + if err == nil || err == CollisionError { + t.Errorf("Got err %+v, expected non-collision error", err) } } // Put a block and put again with same content -func testPutBlockWithSameContent(t *testing.T, factory TestableVolumeFactory) { +// Test is intended for only writable volumes +func testPutBlockWithSameContent(t *testing.T, factory TestableVolumeFactory, testHash string, testData []byte) { v := factory(t) defer v.Teardown() - err := v.Put(TEST_HASH, TEST_BLOCK) + if v.Writable() == false { + return + } + + err := v.Put(testHash, testData) if err != nil { - t.Errorf("Got err putting block %q: %q, expected nil", TEST_BLOCK, err) + t.Errorf("Got err putting block %q: %q, expected nil", TestBlock, err) } - err = v.Put(TEST_HASH, TEST_BLOCK) + err = v.Put(testHash, testData) if err != nil { - t.Errorf("Got err putting block second time %q: %q, expected nil", TEST_BLOCK, err) + t.Errorf("Got err putting block second time %q: %q, expected nil", TestBlock, err) } } // Put a block and put again with different content -func testPutBlockWithDifferentContent(t *testing.T, factory TestableVolumeFactory) { +// Test is intended for only writable volumes +func testPutBlockWithDifferentContent(t *testing.T, factory TestableVolumeFactory, testHash string, testDataA, testDataB []byte) { v := factory(t) defer v.Teardown() - err := v.Put(TEST_HASH, TEST_BLOCK) + if v.Writable() == false { + return + } + + err := v.Put(testHash, testDataA) if err != nil { - t.Errorf("Got err putting block %q: %q, expected nil", TEST_BLOCK, err) + t.Errorf("Got err putting block %q: %q, expected nil", testDataA, err) } - putErr := v.Put(TEST_HASH, TEST_BLOCK_2) - buf, getErr := v.Get(TEST_HASH) + putErr := v.Put(testHash, testDataB) + buf, getErr := v.Get(testHash) if putErr == nil { // Put must not return a nil error unless it has // overwritten the existing data. - if bytes.Compare(buf, TEST_BLOCK_2) != 0 { - t.Errorf("Put succeeded but Get returned %+v, expected %+v", buf, TEST_BLOCK_2) + if bytes.Compare(buf, testDataB) != 0 { + t.Errorf("Put succeeded but Get returned %+v, expected %+v", 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, TEST_BLOCK) != 0 && bytes.Compare(buf, TEST_BLOCK_2) != 0 { - t.Errorf("Put failed but Get returned %+v, which is neither %+v nor %+v", buf, TEST_BLOCK, TEST_BLOCK_2) + 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) } } if getErr == nil { @@ -182,46 +198,51 @@ func testPutBlockWithDifferentContent(t *testing.T, factory TestableVolumeFactor } // Put and get multiple blocks +// Test is intended for only writable volumes func testPutMultipleBlocks(t *testing.T, factory TestableVolumeFactory) { v := factory(t) defer v.Teardown() - err := v.Put(TEST_HASH, TEST_BLOCK) + if v.Writable() == false { + return + } + + err := v.Put(TestHash, TestBlock) if err != nil { - t.Errorf("Got err putting block %q: %q, expected nil", TEST_BLOCK, err) + t.Errorf("Got err putting block %q: %q, expected nil", TestBlock, err) } - err = v.Put(TEST_HASH_2, TEST_BLOCK_2) + err = v.Put(TestHash2, TestBlock2) if err != nil { - t.Errorf("Got err putting block %q: %q, expected nil", TEST_BLOCK_2, err) + t.Errorf("Got err putting block %q: %q, expected nil", TestBlock2, err) } - err = v.Put(TEST_HASH_3, TEST_BLOCK_3) + err = v.Put(TestHash3, TestBlock3) if err != nil { - t.Errorf("Got err putting block %q: %q, expected nil", TEST_BLOCK_3, err) + t.Errorf("Got err putting block %q: %q, expected nil", TestBlock3, err) } - data, err := v.Get(TEST_HASH) + data, err := v.Get(TestHash) if err != nil { t.Error(err) - } else if bytes.Compare(data, TEST_BLOCK) != 0 { - t.Errorf("Block present, but content is incorrect: Expected: %v Found: %v", data, TEST_BLOCK) + } else if bytes.Compare(data, TestBlock) != 0 { + t.Errorf("Block present, but content is incorrect: Expected: %v Found: %v", data, TestBlock) } bufs.Put(data) - data, err = v.Get(TEST_HASH_2) + data, err = v.Get(TestHash2) if err != nil { t.Error(err) - } else if bytes.Compare(data, TEST_BLOCK_2) != 0 { - t.Errorf("Block present, but content is incorrect: Expected: %v Found: %v", data, TEST_BLOCK_2) + } else if bytes.Compare(data, TestBlock2) != 0 { + t.Errorf("Block present, but content is incorrect: Expected: %v Found: %v", data, TestBlock2) } bufs.Put(data) - data, err = v.Get(TEST_HASH_3) + data, err = v.Get(TestHash3) if err != nil { t.Error(err) - } else if bytes.Compare(data, TEST_BLOCK_3) != 0 { - t.Errorf("Block present, but content is incorrect: Expected: %v Found: %v", data, TEST_BLOCK_3) + } else if bytes.Compare(data, TestBlock3) != 0 { + t.Errorf("Block present, but content is incorrect: Expected: %v Found: %v", data, TestBlock3) } bufs.Put(data) } @@ -229,11 +250,16 @@ func testPutMultipleBlocks(t *testing.T, factory TestableVolumeFactory) { // testPutAndTouch // Test that when applying PUT to a block that already exists, // the block's modification time is updated. +// Test is intended for only writable volumes func testPutAndTouch(t *testing.T, factory TestableVolumeFactory) { v := factory(t) defer v.Teardown() - if err := v.Put(TEST_HASH, TEST_BLOCK); err != nil { + if v.Writable() == false { + return + } + + if err := v.Put(TestHash, TestBlock); err != nil { t.Error(err) } @@ -245,20 +271,20 @@ func testPutAndTouch(t *testing.T, factory TestableVolumeFactory) { // Set the stored block's mtime far enough in the past that we // can see the difference between "timestamp didn't change" // and "timestamp granularity is too low". - v.TouchWithDate(TEST_HASH, time.Now().Add(-20*time.Second)) + v.TouchWithDate(TestHash, time.Now().Add(-20*time.Second)) // Make sure v.Mtime() agrees the above Utime really worked. - if t0, err := v.Mtime(TEST_HASH); err != nil || t0.IsZero() || !t0.Before(threshold) { + if t0, err := v.Mtime(TestHash); err != nil || t0.IsZero() || !t0.Before(threshold) { t.Errorf("Setting mtime failed: %v, %v", t0, err) } // Write the same block again. - if err := v.Put(TEST_HASH, TEST_BLOCK); err != nil { + if err := v.Put(TestHash, TestBlock); err != nil { t.Error(err) } // Verify threshold < t1 - if t1, err := v.Mtime(TEST_HASH); err != nil { + if t1, err := v.Mtime(TestHash); err != nil { t.Error(err) } else if t1.Before(threshold) { t.Errorf("t1 %v should be >= threshold %v after v.Put ", t1, threshold) @@ -266,16 +292,18 @@ func testPutAndTouch(t *testing.T, factory TestableVolumeFactory) { } // Touching a non-existing block should result in error. +// Test should pass for both writable and read-only volumes func testTouchNoSuchBlock(t *testing.T, factory TestableVolumeFactory) { v := factory(t) defer v.Teardown() - if err := v.Touch(TEST_HASH); err == nil { + if err := v.Touch(TestHash); err == nil { t.Error("Expected error when attempted to touch a non-existing block") } } // Invoking Mtime on a non-existing block should result in error. +// Test should pass for both writable and read-only volumes func testMtimeNoSuchBlock(t *testing.T, factory TestableVolumeFactory) { v := factory(t) defer v.Teardown() @@ -289,35 +317,36 @@ func testMtimeNoSuchBlock(t *testing.T, factory TestableVolumeFactory) { // * no prefix // * with a prefix // * with no such prefix +// Test should pass for both writable and read-only volumes func testIndexTo(t *testing.T, factory TestableVolumeFactory) { v := factory(t) defer v.Teardown() - v.Put(TEST_HASH, TEST_BLOCK) - v.Put(TEST_HASH_2, TEST_BLOCK_2) - v.Put(TEST_HASH_3, TEST_BLOCK_3) + v.PutRaw(TestHash, TestBlock) + v.PutRaw(TestHash2, TestBlock2) + v.PutRaw(TestHash3, TestBlock3) buf := new(bytes.Buffer) v.IndexTo("", buf) - index_rows := strings.Split(string(buf.Bytes()), "\n") - sort.Strings(index_rows) - sorted_index := strings.Join(index_rows, "\n") + indexRows := strings.Split(string(buf.Bytes()), "\n") + sort.Strings(indexRows) + sortedIndex := strings.Join(indexRows, "\n") m, err := regexp.MatchString( - `^\n`+TEST_HASH+`\+\d+ \d+\n`+ - TEST_HASH_3+`\+\d+ \d+\n`+ - TEST_HASH_2+`\+\d+ \d+$`, - sorted_index) + `^\n`+TestHash+`\+\d+ \d+\n`+ + TestHash3+`\+\d+ \d+\n`+ + TestHash2+`\+\d+ \d+$`, + sortedIndex) if err != nil { t.Error(err) } else if !m { - t.Errorf("Got index %q for empty prefix", sorted_index) + t.Errorf("Got index %q for empty prefix", sortedIndex) } for _, prefix := range []string{"f", "f15", "f15ac"} { buf = new(bytes.Buffer) v.IndexTo(prefix, buf) - m, err := regexp.MatchString(`^`+TEST_HASH_2+`\+\d+ \d+\n$`, string(buf.Bytes())) + m, err := regexp.MatchString(`^`+TestHash2+`\+\d+ \d+\n$`, string(buf.Bytes())) if err != nil { t.Error(err) } else if !m { @@ -338,51 +367,64 @@ func testIndexTo(t *testing.T, factory TestableVolumeFactory) { // Calling Delete() for a block immediately after writing it (not old enough) // should neither delete the data nor return an error. +// Test is intended for only writable volumes func testDeleteNewBlock(t *testing.T, factory TestableVolumeFactory) { v := factory(t) defer v.Teardown() - v.Put(TEST_HASH, TEST_BLOCK) - if err := v.Delete(TEST_HASH); err != nil { + if v.Writable() == false { + return + } + + v.Put(TestHash, TestBlock) + + if err := v.Delete(TestHash); err != nil { t.Error(err) } - data, err := v.Get(TEST_HASH) + data, err := v.Get(TestHash) if err != nil { t.Error(err) - } else if bytes.Compare(data, TEST_BLOCK) != 0 { - t.Error("Block still present, but content is incorrect: %+v != %+v", data, TEST_BLOCK) + } else if bytes.Compare(data, TestBlock) != 0 { + t.Error("Block still present, but content is incorrect: %+v != %+v", data, TestBlock) } bufs.Put(data) } // Calling Delete() for a block with a timestamp older than -// blob_signature_ttl seconds in the past should delete the data. +// blobSignatureTTL seconds in the past should delete the data. +// Test is intended for only writable volumes func testDeleteOldBlock(t *testing.T, factory TestableVolumeFactory) { v := factory(t) defer v.Teardown() - v.Put(TEST_HASH, TEST_BLOCK) - v.TouchWithDate(TEST_HASH, time.Now().Add(-2*blob_signature_ttl*time.Second)) - if err := v.Delete(TEST_HASH); err != nil { + if v.Writable() == false { + return + } + + v.Put(TestHash, TestBlock) + v.TouchWithDate(TestHash, time.Now().Add(-2*blobSignatureTTL*time.Second)) + + if err := v.Delete(TestHash); err != nil { t.Error(err) } - if _, err := v.Get(TEST_HASH); err == nil || !os.IsNotExist(err) { + if _, err := v.Get(TestHash); err == nil || !os.IsNotExist(err) { t.Errorf("os.IsNotExist(%v) should have been true", err.Error()) } } // Calling Delete() for a block that does not exist should result in error. +// Test should pass for both writable and read-only volumes func testDeleteNoSuchBlock(t *testing.T, factory TestableVolumeFactory) { v := factory(t) defer v.Teardown() - v.Put(TEST_HASH, TEST_BLOCK) - if err := v.Delete(TEST_HASH_2); err == nil { + if err := v.Delete(TestHash2); err == nil { t.Errorf("Expected error when attempting to delete a non-existing block") } } // Invoke Status and verify that VolumeStatus is returned +// Test should pass for both writable and read-only volumes func testStatus(t *testing.T, factory TestableVolumeFactory) { v := factory(t) defer v.Teardown() @@ -403,6 +445,7 @@ func testStatus(t *testing.T, factory TestableVolumeFactory) { } // Invoke String for the volume; expect non-empty result +// Test should pass for both writable and read-only volumes func testString(t *testing.T, factory TestableVolumeFactory) { v := factory(t) defer v.Teardown() @@ -412,100 +455,96 @@ func testString(t *testing.T, factory TestableVolumeFactory) { } } -// Verify Writable is true on a writable volume -func testWritableTrue(t *testing.T, factory TestableVolumeFactory) { +// Putting, updating, touching, and deleting blocks from a read-only volume result in error. +// Test is intended for only read-only volumes +func testUpdateReadOnly(t *testing.T, factory TestableVolumeFactory) { v := factory(t) defer v.Teardown() - if v.Writable() == false { - t.Errorf("Expected writable to be true on a writable volume") + if v.Writable() == true { + return } -} -// Verify Writable is false on a read-only volume -func testWritableFalse(t *testing.T, factory TestableVolumeFactory) { - v := factory(t) - defer v.Teardown() - - if v.Writable() != false { - t.Errorf("Expected writable to be false on a read-only volume") - } -} + v.PutRaw(TestHash, TestBlock) -// Updating, touching, and deleting blocks from a read-only volume result in error. -func testUpdateReadOnly(t *testing.T, factory TestableVolumeFactory) { - v := factory(t) - defer v.Teardown() - - v.PutRaw(TEST_HASH, TEST_BLOCK) - - _, err := v.Get(TEST_HASH) + // Get from read-only volume should succeed + _, err := v.Get(TestHash) if err != nil { t.Errorf("got err %v, expected nil", err) } - err = v.Put(TEST_HASH_2, TEST_BLOCK_2) + // Put a new block to read-only volume should result in error + err = v.Put(TestHash2, TestBlock2) if err == nil { t.Errorf("Expected error when putting block in a read-only volume") } - _, err = v.Get(TEST_HASH_2) + _, err = v.Get(TestHash2) if err == nil { t.Errorf("Expected error when getting block whose put in read-only volume failed") } - err = v.Touch(TEST_HASH) + // Touch a block in read-only volume should result in error + err = v.Touch(TestHash) if err == nil { t.Errorf("Expected error when touching block in a read-only volume") } - err = v.Delete(TEST_HASH) + // Delete a block from a read-only volume should result in error + err = v.Delete(TestHash) if err == nil { t.Errorf("Expected error when deleting block from a read-only volume") } + + // Overwriting an existing block in read-only volume should result in error + err = v.Put(TestHash, TestBlock) + if err == nil { + t.Errorf("Expected error when putting block in a read-only volume") + } } // Launch concurrent Gets +// Test should pass for both writable and read-only volumes func testGetConcurrent(t *testing.T, factory TestableVolumeFactory) { v := factory(t) defer v.Teardown() - v.Put(TEST_HASH, TEST_BLOCK) - v.Put(TEST_HASH_2, TEST_BLOCK_2) - v.Put(TEST_HASH_3, TEST_BLOCK_3) + v.PutRaw(TestHash, TestBlock) + v.PutRaw(TestHash2, TestBlock2) + v.PutRaw(TestHash3, TestBlock3) sem := make(chan int) go func(sem chan int) { - buf, err := v.Get(TEST_HASH) + buf, err := v.Get(TestHash) if err != nil { t.Errorf("err1: %v", err) } bufs.Put(buf) - if bytes.Compare(buf, TEST_BLOCK) != 0 { - t.Errorf("buf should be %s, is %s", string(TEST_BLOCK), string(buf)) + if bytes.Compare(buf, TestBlock) != 0 { + t.Errorf("buf should be %s, is %s", string(TestBlock), string(buf)) } sem <- 1 }(sem) go func(sem chan int) { - buf, err := v.Get(TEST_HASH_2) + buf, err := v.Get(TestHash2) if err != nil { t.Errorf("err2: %v", err) } bufs.Put(buf) - if bytes.Compare(buf, TEST_BLOCK_2) != 0 { - t.Errorf("buf should be %s, is %s", string(TEST_BLOCK_2), string(buf)) + if bytes.Compare(buf, TestBlock2) != 0 { + t.Errorf("buf should be %s, is %s", string(TestBlock2), string(buf)) } sem <- 1 }(sem) go func(sem chan int) { - buf, err := v.Get(TEST_HASH_3) + buf, err := v.Get(TestHash3) if err != nil { t.Errorf("err3: %v", err) } bufs.Put(buf) - if bytes.Compare(buf, TEST_BLOCK_3) != 0 { - t.Errorf("buf should be %s, is %s", string(TEST_BLOCK_3), string(buf)) + if bytes.Compare(buf, TestBlock3) != 0 { + t.Errorf("buf should be %s, is %s", string(TestBlock3), string(buf)) } sem <- 1 }(sem) @@ -517,13 +556,18 @@ func testGetConcurrent(t *testing.T, factory TestableVolumeFactory) { } // Launch concurrent Puts +// Test is intended for only writable volumes func testPutConcurrent(t *testing.T, factory TestableVolumeFactory) { v := factory(t) defer v.Teardown() + if v.Writable() == false { + return + } + sem := make(chan int) go func(sem chan int) { - err := v.Put(TEST_HASH, TEST_BLOCK) + err := v.Put(TestHash, TestBlock) if err != nil { t.Errorf("err1: %v", err) } @@ -531,7 +575,7 @@ func testPutConcurrent(t *testing.T, factory TestableVolumeFactory) { }(sem) go func(sem chan int) { - err := v.Put(TEST_HASH_2, TEST_BLOCK_2) + err := v.Put(TestHash2, TestBlock2) if err != nil { t.Errorf("err2: %v", err) } @@ -539,7 +583,7 @@ func testPutConcurrent(t *testing.T, factory TestableVolumeFactory) { }(sem) go func(sem chan int) { - err := v.Put(TEST_HASH_3, TEST_BLOCK_3) + err := v.Put(TestHash3, TestBlock3) if err != nil { t.Errorf("err3: %v", err) } @@ -552,30 +596,30 @@ func testPutConcurrent(t *testing.T, factory TestableVolumeFactory) { } // Double check that we actually wrote the blocks we expected to write. - buf, err := v.Get(TEST_HASH) + buf, err := v.Get(TestHash) if err != nil { t.Errorf("Get #1: %v", err) } bufs.Put(buf) - if bytes.Compare(buf, TEST_BLOCK) != 0 { - t.Errorf("Get #1: expected %s, got %s", string(TEST_BLOCK), string(buf)) + if bytes.Compare(buf, TestBlock) != 0 { + t.Errorf("Get #1: expected %s, got %s", string(TestBlock), string(buf)) } - buf, err = v.Get(TEST_HASH_2) + buf, err = v.Get(TestHash2) if err != nil { t.Errorf("Get #2: %v", err) } bufs.Put(buf) - if bytes.Compare(buf, TEST_BLOCK_2) != 0 { - t.Errorf("Get #2: expected %s, got %s", string(TEST_BLOCK_2), string(buf)) + if bytes.Compare(buf, TestBlock2) != 0 { + t.Errorf("Get #2: expected %s, got %s", string(TestBlock2), string(buf)) } - buf, err = v.Get(TEST_HASH_3) + buf, err = v.Get(TestHash3) if err != nil { t.Errorf("Get #3: %v", err) } bufs.Put(buf) - if bytes.Compare(buf, TEST_BLOCK_3) != 0 { - t.Errorf("Get #3: expected %s, got %s", string(TEST_BLOCK_3), string(buf)) + if bytes.Compare(buf, TestBlock3) != 0 { + t.Errorf("Get #3: expected %s, got %s", string(TestBlock3), string(buf)) } }