func TestTwoClientsWithEmptyDataset(t *testing.T) {
assert := assert.New(t)
id1 := "testdataset"
cs := chunks.NewMemoryStore()
dsx := newDS(id1, cs)
dsy := newDS(id1, cs)
// dsx: || -> |a|
a := types.String("a")
dsx, err := dsx.CommitValue(a)
assert.NoError(err)
assert.True(dsx.Head().Get(datas.ValueField).Equals(a))
// dsy: || -> |b|
_, ok := dsy.MaybeHead()
assert.False(ok)
b := types.String("b")
dsy, err = dsy.CommitValue(b)
assert.Error(err)
// Commit failed, but ds1 now has latest head, so we should be able to just try again.
// dsy: |a| -> |b|
dsy, err = dsy.CommitValue(b)
assert.NoError(err)
assert.True(dsy.Head().Get(datas.ValueField).Equals(b))
}
func TestConstructQueryString(t *testing.T) {
assert := assert.New(t)
prefix := "TestConstructQueryString"
d1, e1 := ioutil.TempDir(os.TempDir(), prefix)
defer os.RemoveAll(d1)
d2, e2 := ioutil.TempDir(os.TempDir(), prefix)
defer os.RemoveAll(d2)
assert.NoError(e1)
assert.NoError(e2)
qs, stores := constructQueryString([]string{
"foo=bar",
"store1=ldb:" + d1,
"store2=ldb:" + d2,
"store3=ldb:" + d1,
"hello=world",
})
assert.Equal(5, len(qs))
assert.Equal("bar", qs.Get("foo"))
assert.True(strings.HasPrefix(qs.Get("store1"), dsPathPrefix))
assert.True(strings.HasPrefix(qs.Get("store2"), dsPathPrefix))
assert.True(strings.HasPrefix(qs.Get("store3"), dsPathPrefix))
assert.Equal(qs.Get("store1"), qs.Get("store3"))
assert.NotEqual(qs.Get("store1"), qs.Get("store2"))
assert.Equal(2, len(stores))
}
func TestTotalOrdering(t *testing.T) {
assert := assert.New(t)
// values in increasing order. Some of these are compared by ref so changing the serialization might change the ordering.
values := []Value{
Bool(false), Bool(true),
Number(-10), Number(0), Number(10),
String("a"), String("b"), String("c"),
// The order of these are done by the hash.
NewSet(Number(0), Number(1), Number(2), Number(3)),
BoolType,
// Value - values cannot be value
// Cycle - values cannot be cycle
// Union - values cannot be unions
}
for i, vi := range values {
for j, vj := range values {
if i == j {
assert.True(vi.Equals(vj))
} else if i < j {
x := vi.Less(vj)
assert.True(x)
} else {
x := vi.Less(vj)
assert.False(x)
}
}
}
}
func TestTypes(t *testing.T) {
assert := assert.New(t)
vs := NewTestValueStore()
mapType := MakeMapType(StringType, NumberType)
setType := MakeSetType(StringType)
mahType := MakeStructType("MahStruct",
[]string{"Field1", "Field2"},
[]*Type{
StringType,
BoolType,
},
)
recType := MakeStructType("RecursiveStruct", []string{"self"}, []*Type{MakeCycleType(0)})
mRef := vs.WriteValue(mapType).TargetHash()
setRef := vs.WriteValue(setType).TargetHash()
mahRef := vs.WriteValue(mahType).TargetHash()
recRef := vs.WriteValue(recType).TargetHash()
assert.True(mapType.Equals(vs.ReadValue(mRef)))
assert.True(setType.Equals(vs.ReadValue(setRef)))
assert.True(mahType.Equals(vs.ReadValue(mahRef)))
assert.True(recType.Equals(vs.ReadValue(recRef)))
}
func TestSetHas2(t *testing.T) {
if testing.Short() {
t.Skip("Skipping test in short mode.")
}
smallTestChunks()
defer normalProductionChunks()
assert := assert.New(t)
vs := NewTestValueStore()
doTest := func(ts testSet) {
set := ts.toSet()
set2 := vs.ReadValue(vs.WriteValue(set).TargetHash()).(Set)
for _, v := range ts {
assert.True(set.Has(v))
assert.True(set2.Has(v))
}
diffSetTest(assert, set, set2, 0, 0)
}
doTest(getTestNativeOrderSet(16))
doTest(getTestRefValueOrderSet(2))
doTest(getTestRefToNativeOrderSet(2, vs))
doTest(getTestRefToValueOrderSet(2, vs))
}
func SkipTestIncrementalAddRef(t *testing.T) {
assert := assert.New(t)
cs := chunks.NewTestStore()
vs := newLocalValueStore(cs)
expectedItem := Number(42)
ref := vs.WriteValue(expectedItem)
expected := NewList(ref)
ref = vs.WriteValue(expected)
actualVar := vs.ReadValue(ref.TargetHash())
assert.Equal(1, cs.Reads)
assert.True(expected.Equals(actualVar))
actual := actualVar.(List)
actualItem := actual.Get(0)
assert.Equal(2, cs.Reads)
assert.True(expectedItem.Equals(actualItem))
// do it again to make sure caching works.
actualItem = actual.Get(0)
assert.Equal(2, cs.Reads)
assert.True(expectedItem.Equals(actualItem))
}
func TestTypes(t *testing.T) {
assert := assert.New(t)
vs := NewTestValueStore()
mapType := MakeMapType(StringType, NumberType)
setType := MakeSetType(StringType)
mahType := MakeStructType("MahStruct", TypeMap{
"Field1": StringType,
"Field2": BoolType,
})
recType := MakeStructType("RecursiveStruct", TypeMap{
"self": nil,
})
recType.Desc.(StructDesc).SetField("self", recType)
mRef := vs.WriteValue(mapType).TargetHash()
setRef := vs.WriteValue(setType).TargetHash()
mahRef := vs.WriteValue(mahType).TargetHash()
recRef := vs.WriteValue(recType).TargetHash()
assert.True(mapType.Equals(vs.ReadValue(mRef)))
assert.True(setType.Equals(vs.ReadValue(setRef)))
assert.True(mahType.Equals(vs.ReadValue(mahRef)))
assert.True(recType.Equals(vs.ReadValue(recRef)))
}
func TestStreamingListCreation(t *testing.T) {
smallTestChunks()
defer normalProductionChunks()
if testing.Short() {
t.Skip("Skipping test in short mode.")
}
assert := assert.New(t)
vs := NewTestValueStore()
simpleList := getTestList()
cl := NewList(simpleList...)
valueChan := make(chan Value)
listChan := NewStreamingList(vs, valueChan)
for _, v := range simpleList {
valueChan <- v
}
close(valueChan)
sl := <-listChan
assert.True(cl.Equals(sl))
cl.Iter(func(v Value, idx uint64) (done bool) {
done = !assert.True(v.Equals(sl.Get(idx)))
return
})
}
func TestListTypeAfterMutations(t *testing.T) {
smallTestChunks()
defer normalProductionChunks()
assert := assert.New(t)
test := func(n int, c interface{}) {
values := generateNumbersAsValues(n)
l := NewList(values...)
assert.Equal(l.Len(), uint64(n))
assert.IsType(c, l.sequence())
assert.True(l.Type().Equals(MakeListType(NumberType)))
l = l.Append(String("a"))
assert.Equal(l.Len(), uint64(n+1))
assert.IsType(c, l.sequence())
assert.True(l.Type().Equals(MakeListType(MakeUnionType(NumberType, StringType))))
l = l.Splice(l.Len()-1, 1)
assert.Equal(l.Len(), uint64(n))
assert.IsType(c, l.sequence())
assert.True(l.Type().Equals(MakeListType(NumberType)))
}
test(15, listLeafSequence{})
test(1500, indexedMetaSequence{})
}
func TestMapIter2(t *testing.T) {
assert := assert.New(t)
smallTestChunks()
defer normalProductionChunks()
doTest := func(tm testMap) {
m := tm.toMap()
sort.Sort(tm.entries)
idx := uint64(0)
endAt := uint64(64)
m.Iter(func(k, v Value) (done bool) {
assert.True(tm.entries[idx].key.Equals(k))
assert.True(tm.entries[idx].value.Equals(v))
if idx == endAt {
done = true
}
idx++
return
})
assert.Equal(endAt, idx-1)
}
doTest(getTestNativeOrderMap(16))
doTest(getTestRefValueOrderMap(2))
doTest(getTestRefToNativeOrderMap(2, NewTestValueStore()))
doTest(getTestRefToValueOrderMap(2, NewTestValueStore()))
}
func TestMapIterAll(t *testing.T) {
if testing.Short() {
t.Skip("Skipping test in short mode.")
}
smallTestChunks()
defer normalProductionChunks()
assert := assert.New(t)
doTest := func(tm testMap) {
m := tm.toMap()
sort.Sort(tm.entries)
idx := uint64(0)
m.IterAll(func(k, v Value) {
assert.True(tm.entries[idx].key.Equals(k))
assert.True(tm.entries[idx].value.Equals(v))
idx++
})
}
doTest(getTestNativeOrderMap(16))
doTest(getTestRefValueOrderMap(2))
doTest(getTestRefToNativeOrderMap(2, NewTestValueStore()))
doTest(getTestRefToValueOrderMap(2, NewTestValueStore()))
}
func TestMapHas(t *testing.T) {
if testing.Short() {
t.Skip("Skipping test in short mode.")
}
smallTestChunks()
defer normalProductionChunks()
assert := assert.New(t)
vs := NewTestValueStore()
doTest := func(tm testMap) {
m := tm.toMap()
m2 := vs.ReadValue(vs.WriteValue(m).TargetHash()).(Map)
for _, entry := range tm.entries {
k, v := entry.key, entry.value
assert.True(m.Has(k))
assert.True(m.Get(k).Equals(v))
assert.True(m2.Has(k))
assert.True(m2.Get(k).Equals(v))
}
diffMapTest(assert, m, m2, 0, 0, 0)
}
doTest(getTestNativeOrderMap(16))
doTest(getTestRefValueOrderMap(2))
doTest(getTestRefToNativeOrderMap(2, vs))
doTest(getTestRefToValueOrderMap(2, vs))
}
func TestMapMaybeGet(t *testing.T) {
if testing.Short() {
t.Skip("Skipping test in short mode.")
}
smallTestChunks()
defer normalProductionChunks()
assert := assert.New(t)
doTest := func(tm testMap) {
m := tm.toMap()
for _, entry := range tm.entries {
v, ok := m.MaybeGet(entry.key)
if assert.True(ok, "%v should have been in the map!", entry.key) {
assert.True(v.Equals(entry.value), "%v != %v", v, entry.value)
}
}
_, ok := m.MaybeGet(tm.knownBadKey)
assert.False(ok, "m should not contain %v", tm.knownBadKey)
}
doTest(getTestNativeOrderMap(2))
doTest(getTestRefValueOrderMap(2))
doTest(getTestRefToNativeOrderMap(2, NewTestValueStore()))
doTest(getTestRefToValueOrderMap(2, NewTestValueStore()))
}
func TestReadToMap(t *testing.T) {
assert := assert.New(t)
ds := datas.NewDatabase(chunks.NewMemoryStore())
dataString := `a,1,true
b,2,false
`
r := NewCSVReader(bytes.NewBufferString(dataString), ',')
headers := []string{"A", "B", "C"}
kinds := KindSlice{types.StringKind, types.NumberKind, types.BoolKind}
m := ReadToMap(r, headers, 0, kinds, ds)
assert.Equal(uint64(2), m.Len())
assert.True(m.Type().Equals(
types.MakeMapType(types.StringType, types.MakeStructType("", map[string]*types.Type{
"B": types.NumberType,
"C": types.BoolType,
}))))
assert.True(m.Get(types.String("a")).Equals(types.NewStruct("", map[string]types.Value{
"B": types.Number(1),
"C": types.Bool(true),
})))
assert.True(m.Get(types.String("b")).Equals(types.NewStruct("", map[string]types.Value{
"B": types.Number(2),
"C": types.Bool(false),
})))
}
func TestListRemoveAtMiddle(t *testing.T) {
if testing.Short() {
t.Skip("Skipping test in short mode.")
}
assert := assert.New(t)
smallTestChunks()
defer normalProductionChunks()
cl := getTestList().toList()
cl2 := cl.RemoveAt(100)
cl3 := cl2.RemoveAt(200)
expected := getTestList()
assert.Equal(expected, testListFromNomsList(cl))
assert.Equal(getTestListLen(), cl.Len())
assert.True(expected.toList().Equals(cl))
expected = expected.RemoveAt(100)
assert.Equal(expected, testListFromNomsList(cl2))
assert.Equal(getTestListLen()-1, cl2.Len())
assert.True(expected.toList().Equals(cl2))
expected = expected.RemoveAt(200)
assert.Equal(expected, testListFromNomsList(cl3))
assert.Equal(getTestListLen()-2, cl3.Len())
assert.True(expected.toList().Equals(cl3))
}
func TestCursorGetMaxNPrevItemsWithSingleItemSequence(t *testing.T) {
assert := assert.New(t)
cur := newTestSequenceCursor([]interface{}{[]interface{}{100}, []interface{}{101}, []interface{}{102}})
assert.Equal([]sequenceItem{}, cur.maxNPrevItems(0))
assert.Equal([]sequenceItem{}, cur.maxNPrevItems(1))
assert.Equal([]sequenceItem{}, cur.maxNPrevItems(2))
assert.Equal([]sequenceItem{}, cur.maxNPrevItems(3))
assert.Equal(0, cur.idx)
assert.True(cur.advance())
assert.Equal([]sequenceItem{}, cur.maxNPrevItems(0))
assert.Equal([]sequenceItem{100}, cur.maxNPrevItems(1))
assert.Equal([]sequenceItem{100}, cur.maxNPrevItems(2))
assert.Equal([]sequenceItem{100}, cur.maxNPrevItems(3))
assert.Equal(0, cur.idx)
assert.True(cur.advance())
assert.Equal([]sequenceItem{}, cur.maxNPrevItems(0))
assert.Equal([]sequenceItem{101}, cur.maxNPrevItems(1))
assert.Equal([]sequenceItem{100, 101}, cur.maxNPrevItems(2))
assert.Equal([]sequenceItem{100, 101}, cur.maxNPrevItems(3))
assert.Equal(0, cur.idx)
assert.False(cur.advance())
assert.Equal([]sequenceItem{102}, cur.maxNPrevItems(1))
assert.Equal([]sequenceItem{101, 102}, cur.maxNPrevItems(2))
assert.Equal([]sequenceItem{100, 101, 102}, cur.maxNPrevItems(3))
assert.Equal([]sequenceItem{100, 101, 102}, cur.maxNPrevItems(4))
assert.Equal(1, cur.idx)
}
func TestMapTypeAfterMutations(t *testing.T) {
assert := assert.New(t)
test := func(n int, c interface{}) {
values := make([]Value, 2*n)
for i := 0; i < n; i++ {
values[2*i] = Number(i)
values[2*i+1] = Number(i)
}
m := NewMap(values...)
assert.Equal(m.Len(), uint64(n))
assert.IsType(c, m.sequence())
assert.True(m.Type().Equals(MakeMapType(NumberType, NumberType)))
m = m.Set(String("a"), String("a"))
assert.Equal(m.Len(), uint64(n+1))
assert.IsType(c, m.sequence())
assert.True(m.Type().Equals(MakeMapType(MakeUnionType(NumberType, StringType), MakeUnionType(NumberType, StringType))))
m = m.Remove(String("a"))
assert.Equal(m.Len(), uint64(n))
assert.IsType(c, m.sequence())
assert.True(m.Type().Equals(MakeMapType(NumberType, NumberType)))
}
test(10, mapLeafSequence{})
test(1000, orderedMetaSequence{})
}
func TestHintsOnCache(t *testing.T) {
assert := assert.New(t)
cvs := newLocalValueStore(chunks.NewTestStore())
cr1 := cvs.WriteValue(Number(1))
cr2 := cvs.WriteValue(Number(2))
s1 := NewStruct("", structData{
"a": cr1,
"b": cr2,
})
r := cvs.WriteValue(s1)
v := cvs.ReadValue(r.TargetHash())
if assert.True(v.Equals(s1)) {
cr3 := cvs.WriteValue(Number(3))
s2 := NewStruct("", structData{
"a": cr1,
"b": cr2,
"c": cr3,
})
hints := cvs.chunkHintsFromCache(s2)
if assert.Len(hints, 1) {
for _, hash := range []hash.Hash{r.TargetHash()} {
_, present := hints[hash]
assert.True(present)
}
}
}
}
func TestSetTypeAfterMutations(t *testing.T) {
assert := assert.New(t)
smallTestChunks()
defer normalProductionChunks()
test := func(n int, c interface{}) {
values := generateNumbersAsValues(n)
s := NewSet(values...)
assert.Equal(s.Len(), uint64(n))
assert.IsType(c, s.sequence())
assert.True(s.Type().Equals(MakeSetType(NumberType)))
s = s.Insert(String("a"))
assert.Equal(s.Len(), uint64(n+1))
assert.IsType(c, s.sequence())
assert.True(s.Type().Equals(MakeSetType(MakeUnionType(NumberType, StringType))))
s = s.Remove(String("a"))
assert.Equal(s.Len(), uint64(n))
assert.IsType(c, s.sequence())
assert.True(s.Type().Equals(MakeSetType(NumberType)))
}
test(10, setLeafSequence{})
test(2000, orderedMetaSequence{})
}
func TestSetUniqueKeysString(t *testing.T) {
assert := assert.New(t)
s1 := NewSet(String("hello"), String("world"), String("hello"))
assert.Equal(uint64(2), s1.Len())
assert.True(s1.Has(String("hello")))
assert.True(s1.Has(String("world")))
assert.False(s1.Has(String("foo")))
}
func validateSet(t *testing.T, s Set, values ValueSlice) {
assert.True(t, s.Equals(NewSet(values...)))
out := ValueSlice{}
s.IterAll(func(v Value) {
out = append(out, v)
})
assert.True(t, out.Equals(values))
}
func validateList(t *testing.T, l List, values ValueSlice) {
assert.True(t, l.Equals(NewList(values...)))
out := ValueSlice{}
l.IterAll(func(v Value, idx uint64) {
out = append(out, v)
})
assert.True(t, out.Equals(values))
}
func TestNewMap(t *testing.T) {
assert := assert.New(t)
m := NewMap()
assert.Equal(uint64(0), m.Len())
m = NewMap(String("foo1"), String("bar1"), String("foo2"), String("bar2"))
assert.Equal(uint64(2), m.Len())
assert.True(String("bar1").Equals(m.Get(String("foo1"))))
assert.True(String("bar2").Equals(m.Get(String("foo2"))))
}
func TestIsEmpty(t *testing.T) {
r1 := Hash{}
assert.True(t, r1.IsEmpty())
r2 := Parse("sha1-0000000000000000000000000000000000000000")
assert.True(t, r2.IsEmpty())
r3 := Parse("sha1-a9993e364706816aba3e25717850c26c9cd0d89d")
assert.False(t, r3.IsEmpty())
}
func TestIsEmpty(t *testing.T) {
r1 := Hash{}
assert.True(t, r1.IsEmpty())
r2 := Parse("00000000000000000000000000000000")
assert.True(t, r2.IsEmpty())
r3 := Parse("rmnjb8cjc5tblj21ed4qs821649eduie")
assert.False(t, r3.IsEmpty())
}
func TestSetUniqueKeysNumber(t *testing.T) {
assert := assert.New(t)
s1 := NewSet(Number(4), Number(1), Number(0), Number(0), Number(1), Number(3))
assert.Equal(uint64(4), s1.Len())
assert.True(s1.Has(Number(4)))
assert.True(s1.Has(Number(1)))
assert.True(s1.Has(Number(0)))
assert.True(s1.Has(Number(3)))
assert.False(s1.Has(Number(2)))
}
func TestCompoundMapWithValuesOfEveryType(t *testing.T) {
assert := assert.New(t)
v := Number(42)
kvs := []Value{
// Values
Bool(true), v,
Number(0), v,
String("hello"), v,
NewBlob(bytes.NewBufferString("buf")), v,
NewSet(Bool(true)), v,
NewList(Bool(true)), v,
NewMap(Bool(true), Number(0)), v,
NewStruct("", StructData{"field": Bool(true)}), v,
// Refs of values
NewRef(Bool(true)), v,
NewRef(Number(0)), v,
NewRef(String("hello")), v,
NewRef(NewBlob(bytes.NewBufferString("buf"))), v,
NewRef(NewSet(Bool(true))), v,
NewRef(NewList(Bool(true))), v,
NewRef(NewMap(Bool(true), Number(0))), v,
NewRef(NewStruct("", StructData{"field": Bool(true)})), v,
}
m := NewMap(kvs...)
for i := 1; !isMetaSequence(m.sequence()); i++ {
k := Number(i)
kvs = append(kvs, k, v)
m = m.Set(k, v)
}
assert.Equal(len(kvs)/2, int(m.Len()))
fk, fv := m.First()
assert.True(bool(fk.(Bool)))
assert.True(v.Equals(fv))
for i, kOrV := range kvs {
if i%2 == 0 {
assert.True(m.Has(kOrV))
assert.True(v.Equals(m.Get(kOrV)))
} else {
assert.True(v.Equals(kOrV))
}
}
for len(kvs) > 0 {
k := kvs[0]
kvs = kvs[2:]
m = m.Remove(k)
assert.False(m.Has(k))
assert.Equal(len(kvs)/2, int(m.Len()))
}
}
func validateMap(t *testing.T, m Map, entries mapEntrySlice) {
tm := testMap{entries: entries}
assert.True(t, m.Equals(tm.toMap()))
out := mapEntrySlice{}
m.IterAll(func(k Value, v Value) {
out = append(out, mapEntry{k, v})
})
assert.True(t, out.Equals(entries))
}
func TestSetEmptyInsertRemove(t *testing.T) {
assert := assert.New(t)
s := NewSet()
assert.True(s.Empty())
s = s.Insert(Bool(false))
assert.False(s.Empty())
assert.Equal(uint64(1), s.Len())
s = s.Remove(Bool(false))
assert.True(s.Empty())
assert.Equal(uint64(0), s.Len())
}
func TestSetIterAll(t *testing.T) {
assert := assert.New(t)
s := NewSet(Number(0), Number(1), Number(2), Number(3), Number(4))
acc := NewSet()
s.IterAll(func(v Value) {
_, ok := v.(Number)
assert.True(ok)
acc = acc.Insert(v)
})
assert.True(s.Equals(acc))
}
