func TestLDBDataset(t *testing.T) {
assert := assert.New(t)
dir, err := ioutil.TempDir(os.TempDir(), "")
assert.NoError(err)
ldbPath := path.Join(dir, "name")
cs := chunks.NewLevelDBStoreUseFlags(ldbPath, "")
ds := datas.NewDatabase(cs)
id := "dsName"
set := dataset.NewDataset(ds, id)
commit := types.String("Commit Value")
set, err = set.Commit(commit)
assert.NoError(err)
ds.Close()
spec := fmt.Sprintf("ldb:%s::%s", ldbPath, id)
sp, err := ParseDatasetSpec(spec)
assert.NoError(err)
dataset, err := sp.Dataset()
assert.NoError(err)
assert.EqualValues(commit, dataset.HeadValue())
os.Remove(dir)
}
func TestReadRef(t *testing.T) {
assert := assert.New(t)
dir, err := ioutil.TempDir(os.TempDir(), "")
assert.NoError(err)
datasetId := "dsName"
ldbPath := path.Join(dir, "/name")
cs1 := chunks.NewLevelDBStoreUseFlags(ldbPath, "")
database1 := datas.NewDatabase(cs1)
dataset1 := dataset.NewDataset(database1, datasetId)
commit := types.String("Commit Value")
dataset1, err = dataset1.Commit(commit)
assert.NoError(err)
r1 := dataset1.Head().Hash()
dataset1.Database().Close()
spec2 := fmt.Sprintf("ldb:%s::%s", ldbPath, r1.String())
sp2, err := ParsePathSpec(spec2)
assert.NoError(err)
database, v2, err := sp2.Value()
assert.NoError(err)
assert.EqualValues(r1.String(), v2.Hash().String())
database.Close()
}
func assertEncoding(t *testing.T, expect []interface{}, v Value) {
vs := NewTestValueStore()
tw := &nomsTestWriter{}
enc := valueEncoder{tw, vs}
enc.writeValue(v)
assert.EqualValues(t, expect, tw.a)
ir := &nomsTestReader{expect, 0}
dec := valueDecoder{ir, vs, staticTypeCache}
v2 := dec.readValue()
assert.True(t, ir.atEnd())
assert.True(t, v.Equals(v2))
}
func TestMemDataset(t *testing.T) {
assert := assert.New(t)
spec := "mem::datasetTest"
sp1, err := ParseDatasetSpec(spec)
assert.NoError(err)
dataset1, err := sp1.Dataset()
assert.NoError(err)
commit := types.String("Commit Value")
dsTest, err := dataset1.Commit(commit)
assert.NoError(err)
assert.EqualValues(commit, dsTest.HeadValue())
}
func TestDatasetCommitTracker(t *testing.T) {
assert := assert.New(t)
id1 := "testdataset"
id2 := "othertestdataset"
cs := chunks.NewMemoryStore()
ds1 := NewDataset(datas.NewDatabase(cs), id1)
ds1Commit := types.String("Commit value for " + id1)
ds1, err := ds1.CommitValue(ds1Commit)
assert.NoError(err)
ds2 := NewDataset(datas.NewDatabase(cs), id2)
ds2Commit := types.String("Commit value for " + id2)
ds2, err = ds2.CommitValue(ds2Commit)
assert.NoError(err)
assert.EqualValues(ds1Commit, ds1.Head().Get(datas.ValueField))
assert.EqualValues(ds2Commit, ds2.Head().Get(datas.ValueField))
assert.False(ds2.Head().Get(datas.ValueField).Equals(ds1Commit))
assert.False(ds1.Head().Get(datas.ValueField).Equals(ds2Commit))
assert.Equal("tcu8fn066i70qi99pkd5u3gq0lqncek7", cs.Root().String())
}
func TestDatasetCommitTracker(t *testing.T) {
assert := assert.New(t)
id1 := "testdataset"
id2 := "othertestdataset"
cs := chunks.NewMemoryStore()
ds1 := NewDataset(datas.NewDatabase(cs), id1)
ds1Commit := types.String("Commit value for " + id1)
ds1, err := ds1.Commit(ds1Commit)
assert.NoError(err)
ds2 := NewDataset(datas.NewDatabase(cs), id2)
ds2Commit := types.String("Commit value for " + id2)
ds2, err = ds2.Commit(ds2Commit)
assert.NoError(err)
assert.EqualValues(ds1Commit, ds1.Head().Get(datas.ValueField))
assert.EqualValues(ds2Commit, ds2.Head().Get(datas.ValueField))
assert.False(ds2.Head().Get(datas.ValueField).Equals(ds1Commit))
assert.False(ds1.Head().Get(datas.ValueField).Equals(ds2Commit))
assert.Equal("sha1-898dfd332626292e92cd4a5d85e5c486dce1d57f", cs.Root().String())
}
func TestGetRequestBatch(t *testing.T) {
assert := assert.New(t)
r0 := hash.Parse("00000000000000000000000000000000")
c1 := NewChunk([]byte("abc"))
r1 := c1.Hash()
c2 := NewChunk([]byte("123"))
r2 := c2.Hash()
tally := func(b bool, trueCnt, falseCnt *int) {
if b {
*trueCnt++
} else {
*falseCnt++
}
}
req0chan := make(chan bool, 1)
req1chan := make(chan Chunk, 1)
req2chan := make(chan bool, 1)
req3chan := make(chan bool, 1)
req4chan := make(chan Chunk, 1)
batch := ReadBatch{
r0: []OutstandingRequest{OutstandingHas(req0chan), OutstandingGet(req1chan)},
r1: []OutstandingRequest{OutstandingHas(req2chan)},
r2: []OutstandingRequest{OutstandingHas(req3chan), OutstandingGet(req4chan)},
}
go func() {
for requestedRef, reqs := range batch {
for _, req := range reqs {
if requestedRef == r1 {
req.Satisfy(c1)
delete(batch, r1)
} else if requestedRef == r2 {
req.Satisfy(c2)
delete(batch, r2)
}
}
}
}()
var r1True, r1False, r2True, r2False int
for b := range req2chan {
tally(b, &r1True, &r1False)
}
for b := range req3chan {
tally(b, &r2True, &r2False)
}
for c := range req4chan {
assert.EqualValues(c2.Hash(), c.Hash())
}
assert.Equal(1, r1True)
assert.Equal(0, r1False)
assert.Equal(1, r2True)
assert.Equal(0, r2False)
go batch.Close()
var r0True, r0False int
for b := range req0chan {
tally(b, &r0True, &r0False)
}
for c := range req1chan {
assert.EqualValues(EmptyChunk.Hash(), c.Hash())
}
assert.Equal(0, r0True)
assert.Equal(1, r0False)
}
// EqualValues asserts that two objects are equal or convertable to the same types
// and equal.
//
// assert.EqualValues(t, uint32(123), int32(123), "123 and 123 should be equal")
//
// Returns whether the assertion was successful (true) or not (false).
func EqualValues(t TestingT, expected interface{}, actual interface{}, msgAndArgs ...interface{}) {
if !assert.EqualValues(t, expected, actual, msgAndArgs...) {
t.FailNow()
}
}