vendor/github.com/peterbourgon/diskv/stream_test.go

package diskv

import (
	"bytes"
	"io/ioutil"
	"testing"
)

func TestBasicStreamCaching(t *testing.T) {
	d := New(Options{
		BasePath:     "test-data",
		CacheSizeMax: 1024,
	})
	defer d.EraseAll()

	input := "a1b2c3"
	key, writeBuf, sync := "a", bytes.NewBufferString(input), true
	if err := d.WriteStream(key, writeBuf, sync); err != nil {
		t.Fatal(err)
	}

	if d.isCached(key) {
		t.Fatalf("'%s' cached, but shouldn't be (yet)", key)
	}

	rc, err := d.ReadStream(key, false)
	if err != nil {
		t.Fatal(err)
	}

	readBuf, err := ioutil.ReadAll(rc)
	if err != nil {
		t.Fatal(err)
	}

	if !cmpBytes(readBuf, []byte(input)) {
		t.Fatalf("'%s' != '%s'", string(readBuf), input)
	}

	if !d.isCached(key) {
		t.Fatalf("'%s' isn't cached, but should be", key)
	}
}

func TestReadStreamDirect(t *testing.T) {
	var (
		basePath = "test-data"
	)
	dWrite := New(Options{
		BasePath:     basePath,
		CacheSizeMax: 0,
	})
	defer dWrite.EraseAll()
	dRead := New(Options{
		BasePath:     basePath,
		CacheSizeMax: 1024,
	})

	// Write
	key, val1, val2 := "a", []byte(`1234567890`), []byte(`aaaaaaaaaa`)
	if err := dWrite.Write(key, val1); err != nil {
		t.Fatalf("during first write: %s", err)
	}

	// First, caching read.
	val, err := dRead.Read(key)
	if err != nil {
		t.Fatalf("during initial read: %s", err)
	}
	t.Logf("read 1: %s => %s", key, string(val))
	if !cmpBytes(val1, val) {
		t.Errorf("expected %q, got %q", string(val1), string(val))
	}
	if !dRead.isCached(key) {
		t.Errorf("%q should be cached, but isn't", key)
	}

	// Write a different value.
	if err := dWrite.Write(key, val2); err != nil {
		t.Fatalf("during second write: %s", err)
	}

	// Second read, should hit cache and get the old value.
	val, err = dRead.Read(key)
	if err != nil {
		t.Fatalf("during second (cache-hit) read: %s", err)
	}
	t.Logf("read 2: %s => %s", key, string(val))
	if !cmpBytes(val1, val) {
		t.Errorf("expected %q, got %q", string(val1), string(val))
	}

	// Third, direct read, should get the updated value.
	rc, err := dRead.ReadStream(key, true)
	if err != nil {
		t.Fatalf("during third (direct) read, ReadStream: %s", err)
	}
	defer rc.Close()
	val, err = ioutil.ReadAll(rc)
	if err != nil {
		t.Fatalf("during third (direct) read, ReadAll: %s", err)
	}
	t.Logf("read 3: %s => %s", key, string(val))
	if !cmpBytes(val2, val) {
		t.Errorf("expected %q, got %q", string(val1), string(val))
	}

	// Fourth read, should hit cache and get the new value.
	val, err = dRead.Read(key)
	if err != nil {
		t.Fatalf("during fourth (cache-hit) read: %s", err)
	}
	t.Logf("read 4: %s => %s", key, string(val))
	if !cmpBytes(val2, val) {
		t.Errorf("expected %q, got %q", string(val1), string(val))
	}
}