8555: Add log messages for time-parsing errors.

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

diff --git a/services/keepstore/volume_unix_test.go b/services/keepstore/volume_unix_test.go
index 011471c7add67e95457a374df30cfdb679a7716d..c95538bc4da380f7af5561984d7a069324cea970 100644 (file)
--- a/services/keepstore/volume_unix_test.go
+++ b/services/keepstore/volume_unix_test.go
@@ -16,10 +16,10 @@ import (
 
 type TestableUnixVolume struct {
        UnixVolume
-       t *testing.T
+       t TB
 }
 
-func NewTestableUnixVolume(t *testing.T, serialize bool, readonly bool) *TestableUnixVolume {
+func NewTestableUnixVolume(t TB, serialize bool, readonly bool) *TestableUnixVolume {
        d, err := ioutil.TempDir("", "volume_test")
        if err != nil {
                t.Fatal(err)
@@ -64,41 +64,55 @@ func (v *TestableUnixVolume) Teardown() {
        }
 }
 
+// serialize = false; readonly = false
 func TestUnixVolumeWithGenericTests(t *testing.T) {
-       DoGenericVolumeTests(t, func(t *testing.T) TestableVolume {
+       DoGenericVolumeTests(t, func(t TB) TestableVolume {
                return NewTestableUnixVolume(t, false, false)
        })
 }
 
-func TestUnixVolumeWithGenericTestsSerialized(t *testing.T) {
-       DoGenericVolumeTests(t, func(t *testing.T) TestableVolume {
-               return NewTestableUnixVolume(t, true, false)
+// serialize = false; readonly = true
+func TestUnixVolumeWithGenericTestsReadOnly(t *testing.T) {
+       DoGenericVolumeTests(t, func(t TB) TestableVolume {
+               return NewTestableUnixVolume(t, false, true)
        })
 }
 
-func TestUnixReadOnlyVolumeWithGenericTests(t *testing.T) {
-       DoGenericReadOnlyVolumeTests(t, func(t *testing.T) TestableVolume {
-               return NewTestableUnixVolume(t, false, true)
+// serialize = true; readonly = false
+func TestUnixVolumeWithGenericTestsSerialized(t *testing.T) {
+       DoGenericVolumeTests(t, func(t TB) TestableVolume {
+               return NewTestableUnixVolume(t, true, false)
        })
 }
 
-func TestUnixReadOnlyVolumeWithGenericTestsSerialized(t *testing.T) {
-       DoGenericReadOnlyVolumeTests(t, func(t *testing.T) TestableVolume {
-               return NewTestableUnixVolume(t, true, true)
+// serialize = false; readonly = false
+func TestUnixVolumeHandlersWithGenericVolumeTests(t *testing.T) {
+       DoHandlersWithGenericVolumeTests(t, func(t TB) (*RRVolumeManager, []TestableVolume) {
+               vols := make([]Volume, 2)
+               testableUnixVols := make([]TestableVolume, 2)
+
+               for i := range vols {
+                       v := NewTestableUnixVolume(t, false, false)
+                       vols[i] = v
+                       testableUnixVols[i] = v
+               }
+
+               return MakeRRVolumeManager(vols), testableUnixVols
        })
 }
 
 func TestGetNotFound(t *testing.T) {
        v := NewTestableUnixVolume(t, false, false)
        defer v.Teardown()
-       v.Put(TEST_HASH, TEST_BLOCK)
+       v.Put(TestHash, TestBlock)
 
-       buf, err := v.Get(TEST_HASH_2)
+       buf := make([]byte, BlockSize)
+       n, err := v.Get(TestHash2, buf)
        switch {
        case os.IsNotExist(err):
                break
        case err == nil:
-               t.Errorf("Read should have failed, returned %s", string(buf))
+               t.Errorf("Read should have failed, returned %+q", buf[:n])
        default:
                t.Errorf("Read expected ErrNotExist, got: %s", err)
        }
@@ -108,16 +122,16 @@ func TestPut(t *testing.T) {
        v := NewTestableUnixVolume(t, false, false)
        defer v.Teardown()
 
-       err := v.Put(TEST_HASH, TEST_BLOCK)
+       err := v.Put(TestHash, TestBlock)
        if err != nil {
                t.Error(err)
        }
-       p := fmt.Sprintf("%s/%s/%s", v.root, TEST_HASH[:3], TEST_HASH)
+       p := fmt.Sprintf("%s/%s/%s", v.root, TestHash[:3], TestHash)
        if buf, err := ioutil.ReadFile(p); err != nil {
                t.Error(err)
-       } else if bytes.Compare(buf, TEST_BLOCK) != 0 {
+       } else if bytes.Compare(buf, TestBlock) != 0 {
                t.Errorf("Write should have stored %s, did store %s",
-                       string(TEST_BLOCK), string(buf))
+                       string(TestBlock), string(buf))
        }
 }
 
@@ -126,7 +140,7 @@ func TestPutBadVolume(t *testing.T) {
        defer v.Teardown()
 
        os.Chmod(v.root, 000)
-       err := v.Put(TEST_HASH, TEST_BLOCK)
+       err := v.Put(TestHash, TestBlock)
        if err == nil {
                t.Error("Write should have failed")
        }
@@ -136,24 +150,25 @@ func TestUnixVolumeReadonly(t *testing.T) {
        v := NewTestableUnixVolume(t, false, true)
        defer v.Teardown()
 
-       v.PutRaw(TEST_HASH, TEST_BLOCK)
+       v.PutRaw(TestHash, TestBlock)
 
-       _, err := v.Get(TEST_HASH)
+       buf := make([]byte, BlockSize)
+       _, err := v.Get(TestHash, buf)
        if err != nil {
                t.Errorf("got err %v, expected nil", err)
        }
 
-       err = v.Put(TEST_HASH, TEST_BLOCK)
+       err = v.Put(TestHash, TestBlock)
        if err != MethodDisabledError {
                t.Errorf("got err %v, expected MethodDisabledError", err)
        }
 
-       err = v.Touch(TEST_HASH)
+       err = v.Touch(TestHash)
        if err != MethodDisabledError {
                t.Errorf("got err %v, expected MethodDisabledError", err)
        }
 
-       err = v.Delete(TEST_HASH)
+       err = v.Trash(TestHash)
        if err != MethodDisabledError {
                t.Errorf("got err %v, expected MethodDisabledError", err)
        }
@@ -203,9 +218,9 @@ func TestUnixVolumeGetFuncWorkerError(t *testing.T) {
        v := NewTestableUnixVolume(t, false, false)
        defer v.Teardown()
 
-       v.Put(TEST_HASH, TEST_BLOCK)
+       v.Put(TestHash, TestBlock)
        mockErr := errors.New("Mock error")
-       err := v.getFunc(v.blockPath(TEST_HASH), func(rdr io.Reader) error {
+       err := v.getFunc(v.blockPath(TestHash), func(rdr io.Reader) error {
                return mockErr
        })
        if err != mockErr {
@@ -218,7 +233,7 @@ func TestUnixVolumeGetFuncFileError(t *testing.T) {
        defer v.Teardown()
 
        funcCalled := false
-       err := v.getFunc(v.blockPath(TEST_HASH), func(rdr io.Reader) error {
+       err := v.getFunc(v.blockPath(TestHash), func(rdr io.Reader) error {
                funcCalled = true
                return nil
        })
@@ -234,13 +249,13 @@ func TestUnixVolumeGetFuncWorkerWaitsOnMutex(t *testing.T) {
        v := NewTestableUnixVolume(t, false, false)
        defer v.Teardown()
 
-       v.Put(TEST_HASH, TEST_BLOCK)
+       v.Put(TestHash, TestBlock)
 
        mtx := NewMockMutex()
        v.locker = mtx
 
        funcCalled := make(chan struct{})
-       go v.getFunc(v.blockPath(TEST_HASH), func(rdr io.Reader) error {
+       go v.getFunc(v.blockPath(TestHash), func(rdr io.Reader) error {
                funcCalled <- struct{}{}
                return nil
        })
@@ -269,26 +284,26 @@ func TestUnixVolumeCompare(t *testing.T) {
        v := NewTestableUnixVolume(t, false, false)
        defer v.Teardown()
 
-       v.Put(TEST_HASH, TEST_BLOCK)
-       err := v.Compare(TEST_HASH, TEST_BLOCK)
+       v.Put(TestHash, TestBlock)
+       err := v.Compare(TestHash, TestBlock)
        if err != nil {
                t.Errorf("Got err %q, expected nil", err)
        }
 
-       err = v.Compare(TEST_HASH, []byte("baddata"))
+       err = v.Compare(TestHash, []byte("baddata"))
        if err != CollisionError {
                t.Errorf("Got err %q, expected %q", err, CollisionError)
        }
 
-       v.Put(TEST_HASH, []byte("baddata"))
-       err = v.Compare(TEST_HASH, TEST_BLOCK)
+       v.Put(TestHash, []byte("baddata"))
+       err = v.Compare(TestHash, TestBlock)
        if err != DiskHashError {
                t.Errorf("Got err %q, expected %q", err, DiskHashError)
        }
 
-       p := fmt.Sprintf("%s/%s/%s", v.root, TEST_HASH[:3], TEST_HASH)
+       p := fmt.Sprintf("%s/%s/%s", v.root, TestHash[:3], TestHash)
        os.Chmod(p, 000)
-       err = v.Compare(TEST_HASH, TEST_BLOCK)
+       err = v.Compare(TestHash, TestBlock)
        if err == nil || strings.Index(err.Error(), "permission denied") < 0 {
                t.Errorf("Got err %q, expected %q", err, "permission denied")
        }