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() } }