func TestSetChunks(t *testing.T) {
assert := assert.New(t)
l1 := NewSet(Number(0))
c1 := l1.Chunks()
assert.Len(c1, 0)
l2 := NewSet(NewRef(Number(0)))
c2 := l2.Chunks()
assert.Len(c2, 1)
}
func TestMapChunks(t *testing.T) {
assert := assert.New(t)
l1 := NewMap(Number(0), Number(1))
c1 := l1.Chunks()
assert.Len(c1, 0)
l2 := NewMap(NewRef(Number(0)), Number(1))
c2 := l2.Chunks()
assert.Len(c2, 1)
l3 := NewMap(Number(0), NewRef(Number(1)))
c3 := l3.Chunks()
assert.Len(c3, 1)
}
func TestHandleWriteValueBackpressure(t *testing.T) {
assert := assert.New(t)
cs := &backpressureCS{ChunkStore: chunks.NewMemoryStore()}
ds := NewDatabase(cs)
l := types.NewList(
ds.WriteValue(types.Bool(true)),
ds.WriteValue(types.Bool(false)),
)
ds.WriteValue(l)
hint := l.Hash()
newItem := types.NewEmptyBlob()
itemChunk := types.EncodeValue(newItem, nil)
l2 := l.Insert(1, types.NewRef(newItem))
listChunk := types.EncodeValue(l2, nil)
body := &bytes.Buffer{}
serializeHints(body, map[hash.Hash]struct{}{hint: struct{}{}})
sz := chunks.NewSerializer(body)
sz.Put(itemChunk)
sz.Put(listChunk)
sz.Close()
w := httptest.NewRecorder()
HandleWriteValue(w, &http.Request{Body: ioutil.NopCloser(body), Method: "POST"}, params{}, cs)
if assert.Equal(httpStatusTooManyRequests, w.Code, "Handler error:\n%s", string(w.Body.Bytes())) {
hashes := deserializeHashes(w.Body)
assert.Len(hashes, 1)
assert.Equal(l2.Hash(), hashes[0])
}
}
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 TestRefChunks(t *testing.T) {
assert := assert.New(t)
l := NewList()
r := NewRef(l)
assert.Len(r.Chunks(), 1)
assert.Equal(r, r.Chunks()[0])
}
func TestGenericStructChunks(t *testing.T) {
assert := assert.New(t)
typ := MakeStructType("S1", []string{"r"}, []*Type{MakeRefType(BoolType)})
b := Bool(true)
s1 := NewStructWithType(typ, ValueSlice{NewRef(b)})
assert.Len(s1.Chunks(), 1)
assert.Equal(b.Hash(), s1.Chunks()[0].TargetHash())
}
func TestDropIndices(t *testing.T) {
h := &RefByHeight{}
for i := 0; i < 10; i++ {
h.PushBack(NewRef(Number(i)))
}
sort.Sort(h)
toDrop := []int{2, 4, 7}
expected := RefSlice{h.PeekAt(2), h.PeekAt(4), h.PeekAt(7)}
h.DropIndices(toDrop)
assert.Len(t, *h, 7)
for i, dropped := range expected {
assert.NotContains(t, *h, dropped, "Should not contain %d", toDrop[i])
}
}
func TestGenericStructChunks(t *testing.T) {
assert := assert.New(t)
typ := MakeStructType("S1", TypeMap{
"r": MakeRefType(BoolType),
})
b := Bool(true)
data1 := structData{"r": NewRef(b)}
s1 := newStructFromData(data1, typ)
assert.Len(s1.Chunks(), 1)
assert.Equal(b.Hash(), s1.Chunks()[0].TargetHash())
}
func TestHintRoundTrip(t *testing.T) {
b := &bytes.Buffer{}
input := map[hash.Hash]struct{}{
hash.Parse("00000000000000000000000000000000"): struct{}{},
hash.Parse("00000000000000000000000000000001"): struct{}{},
hash.Parse("00000000000000000000000000000002"): struct{}{},
hash.Parse("00000000000000000000000000000003"): struct{}{},
}
serializeHints(b, input)
output := deserializeHints(b)
assert.Len(t, output, len(input), "Output has different number of elements than input: %v, %v", output, input)
for h := range output {
_, present := input[h]
assert.True(t, present, "%s is in output but not in input", h)
}
}
func TestBuildHashesRequest(t *testing.T) {
assert := assert.New(t)
hashes := map[hash.Hash]struct{}{
hash.Parse("sha1-0000000000000000000000000000000000000002"): struct{}{},
hash.Parse("sha1-0000000000000000000000000000000000000003"): struct{}{},
}
r := buildHashesRequest(hashes)
b, err := ioutil.ReadAll(r)
assert.NoError(err)
urlValues, err := url.ParseQuery(string(b))
assert.NoError(err)
assert.NotEmpty(urlValues)
queryRefs := urlValues["ref"]
assert.Len(queryRefs, len(hashes))
for _, r := range queryRefs {
_, present := hashes[hash.Parse(r)]
assert.True(present, "Query contains %s, which is not in initial refs", r)
}
}
// Len asserts that the specified object has specific length.
// Len also fails if the object has a type that len() not accept.
//
// assert.Len(t, mySlice, 3, "The size of slice is not 3")
//
// Returns whether the assertion was successful (true) or not (false).
func Len(t TestingT, object interface{}, length int, msgAndArgs ...interface{}) {
if !assert.Len(t, object, length, msgAndArgs...) {
t.FailNow()
}
}