Switch to using the dep tool and update all the dependencies

vendor/github.com/stacktic/dropbox/datastores_parser_test.go

@@ -0,0 +1,202 @@
+/*
+** Copyright (c) 2014 Arnaud Ysmal.  All Rights Reserved.
+**
+** Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions
+** are met:
+** 1. Redistributions of source code must retain the above copyright
+**    notice, this list of conditions and the following disclaimer.
+** 2. Redistributions in binary form must reproduce the above copyright
+**    notice, this list of conditions and the following disclaimer in the
+**    documentation and/or other materials provided with the distribution.
+**
+** THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
+** OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+** WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+** DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+** FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+** DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+** SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+** HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+** LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+** OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+** SUCH DAMAGE.
+ */
+
+package dropbox
+
+import (
+	"encoding/json"
+	"fmt"
+	"math"
+	"reflect"
+	"testing"
+	"time"
+)
+
+type equaller interface {
+	equals(equaller) bool
+}
+
+func (s *atom) equals(o *atom) bool {
+	switch v1 := s.Value.(type) {
+	case float64:
+		if v2, ok := o.Value.(float64); ok {
+			if math.IsNaN(v1) && math.IsNaN(v2) {
+				return true
+			}
+			return v1 == v2
+		}
+	default:
+		return reflect.DeepEqual(s, o)
+	}
+	return false
+}
+
+func (s *value) equals(o *value) bool {
+	return reflect.DeepEqual(s, o)
+}
+
+func (s Fields) equals(o Fields) bool {
+	return reflect.DeepEqual(s, o)
+}
+
+func (s opDict) equals(o opDict) bool {
+	return reflect.DeepEqual(s, o)
+}
+
+func (s *change) equals(o *change) bool {
+	return reflect.DeepEqual(s, o)
+}
+
+func (s *fieldOp) equals(o *fieldOp) bool {
+	return reflect.DeepEqual(s, o)
+}
+
+func testDSAtom(t *testing.T, c *atom, e string) {
+	var c2 atom
+	var err error
+	var js []byte
+
+	if js, err = json.Marshal(c); err != nil {
+		t.Errorf("%s", err)
+	}
+	if err = c2.UnmarshalJSON(js); err != nil {
+		t.Errorf("%s", err)
+	}
+	if !c.equals(&c2) {
+		t.Errorf("expected %#v type %s got %#v of type %s", c.Value, reflect.TypeOf(c.Value).Name(), c2.Value, reflect.TypeOf(c2.Value).Name())
+	}
+	c2 = atom{}
+	if err = c2.UnmarshalJSON([]byte(e)); err != nil {
+		t.Errorf("%s", err)
+	}
+	if !c.equals(&c2) {
+		t.Errorf("expected %#v type %s got %#v of type %s", c.Value, reflect.TypeOf(c.Value).Name(), c2.Value, reflect.TypeOf(c2.Value).Name())
+	}
+}
+
+func TestDSAtomUnmarshalJSON(t *testing.T) {
+	testDSAtom(t, &atom{Value: 32.5}, `32.5`)
+	testDSAtom(t, &atom{Value: true}, `true`)
+	testDSAtom(t, &atom{Value: int64(42)}, `{"I":"42"}`)
+	testDSAtom(t, &atom{Value: math.NaN()}, `{"N":"nan"}`)
+	testDSAtom(t, &atom{Value: math.Inf(1)}, `{"N":"+inf"}`)
+	testDSAtom(t, &atom{Value: math.Inf(-1)}, `{"N":"-inf"}`)
+	testDSAtom(t, &atom{Value: []byte(`random string converted to bytes`)}, `{"B":"cmFuZG9tIHN0cmluZyBjb252ZXJ0ZWQgdG8gYnl0ZXM="}`)
+
+	now := time.Now().Round(time.Millisecond)
+	js := fmt.Sprintf(`{"T": "%d"}`, now.UnixNano()/int64(time.Millisecond))
+	testDSAtom(t, &atom{Value: now}, js)
+}
+
+func testDSChange(t *testing.T, c *change, e string) {
+	var c2 change
+	var err error
+	var js []byte
+
+	if js, err = json.Marshal(c); err != nil {
+		t.Errorf("%s", err)
+	}
+	if err = c2.UnmarshalJSON(js); err != nil {
+		t.Errorf("%s", err)
+	}
+	if !c.equals(&c2) {
+		t.Errorf("mismatch: got:\n\t%#v\nexpected:\n\t%#v", c2, *c)
+	}
+	c2 = change{}
+	if err = c2.UnmarshalJSON([]byte(e)); err != nil {
+		t.Errorf("%s", err)
+	}
+	if !c.equals(&c2) {
+		t.Errorf("mismatch")
+	}
+}
+
+func TestDSChangeUnmarshalJSON(t *testing.T) {
+	testDSChange(t,
+		&change{
+			Op:       recordInsert,
+			TID:      "dropbox",
+			RecordID: "test",
+			Data:     Fields{"float": value{values: []interface{}{float64(42)}, isList: false}},
+		}, `["I","dropbox","test",{"float":42}]`)
+	testDSChange(t,
+		&change{
+			Op:       recordUpdate,
+			TID:      "dropbox",
+			RecordID: "test",
+			Ops:      opDict{"field": fieldOp{Op: fieldPut, Data: value{values: []interface{}{float64(42)}, isList: false}}},
+		}, `["U","dropbox","test",{"field":["P", 42]}]`)
+	testDSChange(t,
+		&change{
+			Op:       recordUpdate,
+			TID:      "dropbox",
+			RecordID: "test",
+			Ops:      opDict{"field": fieldOp{Op: listCreate}},
+		}, `["U","dropbox","test",{"field":["LC"]}]`)
+
+	testDSChange(t,
+		&change{
+			Op:       recordDelete,
+			TID:      "dropbox",
+			RecordID: "test",
+		}, `["D","dropbox","test"]`)
+}
+
+func testCheckfieldOp(t *testing.T, fo *fieldOp, e string) {
+	var fo2 fieldOp
+	var js []byte
+	var err error
+
+	if js, err = json.Marshal(fo); err != nil {
+		t.Errorf("%s", err)
+	}
+	if string(js) != e {
+		t.Errorf("marshalling error got %s expected %s", string(js), e)
+	}
+	if err = json.Unmarshal(js, &fo2); err != nil {
+		t.Errorf("%s %s", err, string(js))
+	}
+	if !fo.equals(&fo2) {
+		t.Errorf("%#v != %#v\n", fo, fo2)
+	}
+	fo2 = fieldOp{}
+	if err = json.Unmarshal([]byte(e), &fo2); err != nil {
+		t.Errorf("%s %s", err, string(js))
+	}
+	if !fo.equals(&fo2) {
+		t.Errorf("%#v != %#v\n", fo, fo2)
+	}
+}
+
+func TestDSfieldOpMarshalling(t *testing.T) {
+	testCheckfieldOp(t, &fieldOp{Op: "P", Data: value{values: []interface{}{"bar"}, isList: false}}, `["P","bar"]`)
+	testCheckfieldOp(t, &fieldOp{Op: "P", Data: value{values: []interface{}{"ga", "bu", "zo", "meuh", int64(42), 4.5, true}, isList: true}}, `["P",["ga","bu","zo","meuh",{"I":"42"},4.5,true]]`)
+	testCheckfieldOp(t, &fieldOp{Op: "D"}, `["D"]`)
+	testCheckfieldOp(t, &fieldOp{Op: "LC"}, `["LC"]`)
+	testCheckfieldOp(t, &fieldOp{Op: "LP", Index: 1, Data: value{values: []interface{}{"baz"}}}, `["LP",1,"baz"]`)
+	testCheckfieldOp(t, &fieldOp{Op: "LI", Index: 1, Data: value{values: []interface{}{"baz"}}}, `["LI",1,"baz"]`)
+	testCheckfieldOp(t, &fieldOp{Op: "LD", Index: 1}, `["LD",1]`)
+	testCheckfieldOp(t, &fieldOp{Op: "LM", Index: 1, Index2: 2}, `["LM",1,2]`)
+}

vendor/github.com/stacktic/dropbox/datastores_test.go

@@ -0,0 +1,263 @@
+/*
+** Copyright (c) 2014 Arnaud Ysmal.  All Rights Reserved.
+**
+** Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions
+** are met:
+** 1. Redistributions of source code must retain the above copyright
+**    notice, this list of conditions and the following disclaimer.
+** 2. Redistributions in binary form must reproduce the above copyright
+**    notice, this list of conditions and the following disclaimer in the
+**    documentation and/or other materials provided with the distribution.
+**
+** THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
+** OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+** WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+** DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+** FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+** DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+** SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+** HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+** LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+** OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+** SUCH DAMAGE.
+ */
+
+package dropbox
+
+import (
+	"encoding/json"
+	"testing"
+)
+
+func checkList(t *testing.T, l *List, e []interface{}) {
+	var elt1 interface{}
+	var err error
+
+	if l.Size() != len(e) {
+		t.Errorf("wrong size")
+	}
+	for i := range e {
+		if elt1, err = l.Get(i); err != nil {
+			t.Errorf("%s", err)
+		}
+		if elt1 != e[i] {
+			t.Errorf("position %d mismatch got %#v, expected %#v", i, elt1, e[i])
+		}
+	}
+}
+
+func newDatastore(t *testing.T) *Datastore {
+	var ds *Datastore
+
+	ds = &Datastore{
+		manager: newDropbox(t).NewDatastoreManager(),
+		info: DatastoreInfo{
+			ID:       "dummyID",
+			handle:   "dummyHandle",
+			title:    "dummyTitle",
+			revision: 0,
+		},
+		tables:       make(map[string]*Table),
+		changesQueue: make(chan changeWork),
+	}
+	go ds.doHandleChange()
+	return ds
+}
+
+func TestList(t *testing.T) {
+	var tbl *Table
+	var r *Record
+	var ds *Datastore
+	var l *List
+	var err error
+
+	ds = newDatastore(t)
+
+	if tbl, err = ds.GetTable("dummyTable"); err != nil {
+		t.Errorf("%s", err)
+	}
+	if r, err = tbl.GetOrInsert("dummyRecord"); err != nil {
+		t.Errorf("%s", err)
+	}
+	if l, err = r.GetOrCreateList("dummyList"); err != nil {
+		t.Errorf("%s", err)
+	}
+	for i := 0; i < 10; i++ {
+		if err = l.Add(i); err != nil {
+			t.Errorf("%s", err)
+		}
+	}
+	if ftype, err := r.GetFieldType("dummyList"); err != nil || ftype != TypeList {
+		t.Errorf("wrong type")
+	}
+
+	ftype, err := l.GetType(0)
+	if err != nil {
+		t.Errorf("%s", err)
+	}
+	if ftype != TypeInteger {
+		t.Errorf("wrong type")
+	}
+
+	checkList(t, l, []interface{}{0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
+
+	if err = l.Remove(5); err != nil {
+		t.Errorf("could not remove element 5")
+	}
+	checkList(t, l, []interface{}{0, 1, 2, 3, 4, 6, 7, 8, 9})
+
+	if err = l.Remove(0); err != nil {
+		t.Errorf("could not remove element 0")
+	}
+	checkList(t, l, []interface{}{1, 2, 3, 4, 6, 7, 8, 9})
+
+	if err = l.Remove(7); err != nil {
+		t.Errorf("could not remove element 7")
+	}
+	checkList(t, l, []interface{}{1, 2, 3, 4, 6, 7, 8})
+
+	if err = l.Remove(7); err == nil {
+		t.Errorf("out of bound index must return an error")
+	}
+	checkList(t, l, []interface{}{1, 2, 3, 4, 6, 7, 8})
+
+	if err = l.Move(3, 6); err != nil {
+		t.Errorf("could not move element 3 to position 6")
+	}
+	checkList(t, l, []interface{}{1, 2, 3, 6, 7, 8, 4})
+
+	if err = l.Move(3, 9); err == nil {
+		t.Errorf("out of bound index must return an error")
+	}
+	checkList(t, l, []interface{}{1, 2, 3, 6, 7, 8, 4})
+
+	if err = l.Move(6, 3); err != nil {
+		t.Errorf("could not move element 6 to position 3")
+	}
+	checkList(t, l, []interface{}{1, 2, 3, 4, 6, 7, 8})
+
+	if err = l.AddAtPos(0, 0); err != nil {
+		t.Errorf("could not insert element at position 0")
+	}
+	checkList(t, l, []interface{}{0, 1, 2, 3, 4, 6, 7, 8})
+
+	if err = l.Add(9); err != nil {
+		t.Errorf("could not append element")
+	}
+	checkList(t, l, []interface{}{0, 1, 2, 3, 4, 6, 7, 8, 9})
+
+	if err = l.AddAtPos(5, 5); err != nil {
+		t.Errorf("could not insert element at position 5")
+	}
+	checkList(t, l, []interface{}{0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
+
+	if err = l.Set(0, 3); err != nil {
+		t.Errorf("could not update element at position 0")
+	}
+	checkList(t, l, []interface{}{3, 1, 2, 3, 4, 5, 6, 7, 8, 9})
+
+	if err = l.Set(9, 2); err != nil {
+		t.Errorf("could not update element at position 9")
+	}
+	checkList(t, l, []interface{}{3, 1, 2, 3, 4, 5, 6, 7, 8, 2})
+
+	if err = l.Set(10, 11); err == nil {
+		t.Errorf("out of bound index must return an error")
+	}
+	checkList(t, l, []interface{}{3, 1, 2, 3, 4, 5, 6, 7, 8, 2})
+}
+
+func TestGenerateID(t *testing.T) {
+	f, err := generateDatastoreID()
+	if err != nil {
+		t.Errorf("%s", err)
+	}
+	if !isValidDatastoreID(f) {
+		t.Errorf("generated ID is not correct")
+	}
+}
+
+func TestUnmarshalAwait(t *testing.T) {
+	type awaitResult struct {
+		Deltas struct {
+			Results map[string]struct {
+				Deltas []datastoreDelta `json:"deltas"`
+			} `json:"deltas"`
+		} `json:"get_deltas"`
+		Datastores struct {
+			Info  []datastoreInfo `json:"datastores"`
+			Token string          `json:"token"`
+		} `json:"list_datastores"`
+	}
+	var r awaitResult
+	var datastoreID string
+	var res []datastoreDelta
+
+	js := `{"get_deltas":{"deltas":{"12345678901234567890":{"deltas":[{"changes":[["I","dummyTable","dummyRecord",{}]],"nonce":"","rev":0},{"changes":[["U","dummyTable","dummyRecord",{"name":["P","dummy"]}],["U","dummyTable","dummyRecord",{"dummyList":["LC"]}]],"nonce":"","rev":1},{"changes":[["U","dummyTable","dummyRecord",{"dummyList":["LI",0,{"I":"0"}]}],["U","dummyTable","dummyRecord",{"dummyList":["LI",1,{"I":"1"}]}],["U","dummyTable","dummyRecord",{"dummyList":["LI",2,{"I":"2"}]}],["U","dummyTable","dummyRecord",{"dummyList":["LI",3,{"I":"3"}]}],["U","dummyTable","dummyRecord",{"dummyList":["LI",4,{"I":"4"}]}],["U","dummyTable","dummyRecord",{"dummyList":["LI",5,{"I":"5"}]}],["U","dummyTable","dummyRecord",{"dummyList":["LI",6,{"I":"6"}]}],["U","dummyTable","dummyRecord",{"dummyList":["LI",7,{"I":"7"}]}],["U","dummyTable","dummyRecord",{"dummyList":["LI",8,{"I":"8"}]}],["U","dummyTable","dummyRecord",{"dummyList":["LI",9,{"I":"9"}]}]],"nonce":"","rev":2},{"changes":[["D","dummyTable","dummyRecord"]],"nonce":"","rev":3}]}}}}`
+	datastoreID = "12345678901234567890"
+
+	expected := []datastoreDelta{
+		datastoreDelta{
+			Revision: 0,
+			Changes: listOfChanges{
+				&change{Op: recordInsert, TID: "dummyTable", RecordID: "dummyRecord", Data: Fields{}},
+			},
+		},
+		datastoreDelta{
+			Revision: 1,
+			Changes: listOfChanges{
+				&change{Op: "U", TID: "dummyTable", RecordID: "dummyRecord", Ops: opDict{"name": fieldOp{Op: "P", Index: 0, Data: value{values: []interface{}{"dummy"}}}}},
+				&change{Op: "U", TID: "dummyTable", RecordID: "dummyRecord", Ops: opDict{"dummyList": fieldOp{Op: "LC"}}},
+			},
+		},
+		datastoreDelta{
+			Revision: 2,
+			Changes: listOfChanges{
+				&change{Op: recordUpdate, TID: "dummyTable", RecordID: "dummyRecord", Ops: opDict{"dummyList": fieldOp{Op: listInsert, Index: 0, Data: value{values: []interface{}{int64(0)}}}}},
+				&change{Op: recordUpdate, TID: "dummyTable", RecordID: "dummyRecord", Ops: opDict{"dummyList": fieldOp{Op: listInsert, Index: 1, Data: value{values: []interface{}{int64(1)}}}}},
+				&change{Op: recordUpdate, TID: "dummyTable", RecordID: "dummyRecord", Ops: opDict{"dummyList": fieldOp{Op: listInsert, Index: 2, Data: value{values: []interface{}{int64(2)}}}}},
+				&change{Op: recordUpdate, TID: "dummyTable", RecordID: "dummyRecord", Ops: opDict{"dummyList": fieldOp{Op: listInsert, Index: 3, Data: value{values: []interface{}{int64(3)}}}}},
+				&change{Op: recordUpdate, TID: "dummyTable", RecordID: "dummyRecord", Ops: opDict{"dummyList": fieldOp{Op: listInsert, Index: 4, Data: value{values: []interface{}{int64(4)}}}}},
+				&change{Op: recordUpdate, TID: "dummyTable", RecordID: "dummyRecord", Ops: opDict{"dummyList": fieldOp{Op: listInsert, Index: 5, Data: value{values: []interface{}{int64(5)}}}}},
+				&change{Op: recordUpdate, TID: "dummyTable", RecordID: "dummyRecord", Ops: opDict{"dummyList": fieldOp{Op: listInsert, Index: 6, Data: value{values: []interface{}{int64(6)}}}}},
+				&change{Op: recordUpdate, TID: "dummyTable", RecordID: "dummyRecord", Ops: opDict{"dummyList": fieldOp{Op: listInsert, Index: 7, Data: value{values: []interface{}{int64(7)}}}}},
+				&change{Op: recordUpdate, TID: "dummyTable", RecordID: "dummyRecord", Ops: opDict{"dummyList": fieldOp{Op: listInsert, Index: 8, Data: value{values: []interface{}{int64(8)}}}}},
+				&change{Op: recordUpdate, TID: "dummyTable", RecordID: "dummyRecord", Ops: opDict{"dummyList": fieldOp{Op: listInsert, Index: 9, Data: value{values: []interface{}{int64(9)}}}}},
+			},
+		},
+		datastoreDelta{
+			Revision: 3,
+			Changes: listOfChanges{
+				&change{Op: "D", TID: "dummyTable", RecordID: "dummyRecord"},
+			},
+		},
+	}
+	err := json.Unmarshal([]byte(js), &r)
+	if err != nil {
+		t.Errorf("%s", err)
+	}
+	if len(r.Deltas.Results) != 1 {
+		t.Errorf("wrong number of datastoreDelta")
+	}
+
+	if tmp, ok := r.Deltas.Results[datastoreID]; !ok {
+		t.Fatalf("wrong datastore ID")
+	} else {
+		res = tmp.Deltas
+	}
+	if len(res) != len(expected) {
+		t.Fatalf("got %d results expected %d", len(res), len(expected))
+	}
+	for i, d := range res {
+		ed := expected[i]
+		if d.Revision != ed.Revision {
+			t.Errorf("wrong revision got %d expected %d", d.Revision, expected[i].Revision)
+		}
+		for j, c := range d.Changes {
+			if !c.equals(ed.Changes[j]) {
+				t.Errorf("wrong change: got: %+v expected: %+v", *c, *ed.Changes[j])
+			}
+		}
+	}
+}

vendor/github.com/stacktic/dropbox/dropbox_test.go

@@ -0,0 +1,786 @@
+/*
+** Copyright (c) 2014 Arnaud Ysmal.  All Rights Reserved.
+**
+** Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions
+** are met:
+** 1. Redistributions of source code must retain the above copyright
+**    notice, this list of conditions and the following disclaimer.
+** 2. Redistributions in binary form must reproduce the above copyright
+**    notice, this list of conditions and the following disclaimer in the
+**    documentation and/or other materials provided with the distribution.
+**
+** THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
+** OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+** WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+** DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+** FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+** DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+** SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+** HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+** LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+** OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+** SUCH DAMAGE.
+ */
+
+package dropbox
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"reflect"
+	"strconv"
+	"testing"
+	"time"
+)
+
+var dirEntry = Entry{Size: "0 bytes", Revision: "1f477dd351f", ThumbExists: false, Bytes: 0,
+	Modified: DBTime(time.Date(2011, time.August, 10, 18, 21, 30, 0, time.UTC)),
+	Path:     "/testdir", IsDir: true, Icon: "folder", Root: "auto"}
+
+var fileEntry = Entry{Size: "0 bytes", Revision: "1f33043551f", ThumbExists: false, Bytes: 0,
+	Modified: DBTime(time.Date(2011, time.August, 10, 18, 21, 30, 0, time.UTC)),
+	Path:     "/testfile", IsDir: false, Icon: "page_white_text",
+	Root: "auto", MimeType: "text/plain"}
+
+type FakeHTTP struct {
+	t            *testing.T
+	Method       string
+	Host         string
+	Path         string
+	Params       map[string]string
+	RequestData  []byte
+	ResponseData []byte
+}
+
+func (f FakeHTTP) RoundTrip(req *http.Request) (resp *http.Response, err error) {
+	if resp, err = f.checkRequest(req); err != nil {
+		f.t.Errorf("%s", err)
+	}
+	return resp, err
+}
+
+func (f FakeHTTP) checkRequest(r *http.Request) (*http.Response, error) {
+	var va []string
+	var ok bool
+
+	if r.Method != f.Method {
+		return nil, fmt.Errorf("wrong method")
+	}
+	if r.URL.Scheme != "https" || r.URL.Host != f.Host || r.URL.Path != f.Path {
+		return nil, fmt.Errorf("wrong URL %s://%s%s", r.URL.Scheme, r.URL.Host, r.URL.Path)
+	}
+	vals := r.URL.Query()
+	if len(vals) != len(f.Params) {
+		return nil, fmt.Errorf("wrong number of parameters got %d expected %d", len(vals), len(f.Params))
+	}
+	for k, v := range f.Params {
+		if va, ok = vals[k]; !ok || len(va) != 1 {
+			return nil, fmt.Errorf("wrong parameters %s", k)
+		} else if va[0] != v {
+			return nil, fmt.Errorf("wrong parameters %s expected %s received %s", k, v, va[0])
+		}
+	}
+	if len(f.RequestData) != 0 {
+		var buf []byte
+		var err error
+
+		if buf, err = ioutil.ReadAll(r.Body); err != nil {
+			return nil, err
+		}
+		if !bytes.Equal(buf, f.RequestData) {
+			return nil, fmt.Errorf("wrong request body")
+		}
+	}
+
+	return &http.Response{Status: "200 OK", StatusCode: 200,
+		Proto: "HTTP/1.1", ProtoMajor: 1, ProtoMinor: 1,
+		ContentLength: int64(len(f.ResponseData)), Body: ioutil.NopCloser(bytes.NewReader(f.ResponseData))}, nil
+}
+
+// Downloading a file
+func Example() {
+	db := NewDropbox()
+	db.SetAppInfo("application id", "application secret")
+	db.SetAccessToken("your secret token for this application")
+	db.DownloadToFile("file on Dropbox", "local destination", "revision of the file on Dropbox")
+}
+
+func newDropbox(t *testing.T) *Dropbox {
+	db := NewDropbox()
+	db.SetAppInfo("dummyappkey", "dummyappsecret")
+	db.SetAccessToken("dummyoauthtoken")
+	return db
+}
+
+func TestAccountInfo(t *testing.T) {
+	var err error
+	var db *Dropbox
+	var received *Account
+
+	db = newDropbox(t)
+
+	expected := Account{ReferralLink: "https://www.dropbox.com/referrals/r1a2n3d4m5s6t7", DisplayName: "John P. User", Country: "US", UID: 12345678}
+	expected.QuotaInfo.Shared = 253738410565
+	expected.QuotaInfo.Quota = 107374182400000
+	expected.QuotaInfo.Normal = 680031877871
+	js, err := json.Marshal(expected)
+	if err != nil {
+		t.Fatalf("could not run test marshalling issue")
+	}
+
+	http.DefaultClient = &http.Client{
+		Transport: FakeHTTP{
+			t:            t,
+			Method:       "GET",
+			Host:         "api.dropbox.com",
+			Path:         "/1/account/info",
+			Params:       map[string]string{"locale": "en"},
+			ResponseData: js,
+		},
+	}
+
+	if received, err = db.GetAccountInfo(); err != nil {
+		t.Errorf("API error: %s", err)
+	} else if !reflect.DeepEqual(expected, *received) {
+		t.Errorf("got %#v expected %#v", *received, expected)
+	}
+}
+
+func TestCopy(t *testing.T) {
+	var err error
+	var db *Dropbox
+	var received *Entry
+	var from, to string
+	var fake FakeHTTP
+
+	expected := fileEntry
+	from = expected.Path[1:]
+	to = from + ".1"
+	expected.Path = to
+
+	js, err := json.Marshal(expected)
+	if err != nil {
+		t.Fatalf("could not run test marshalling issue")
+	}
+
+	fake = FakeHTTP{
+		t:      t,
+		Method: "POST",
+		Host:   "api.dropbox.com",
+		Path:   "/1/fileops/copy",
+		Params: map[string]string{
+			"root":      "auto",
+			"from_path": from,
+			"to_path":   to,
+			"locale":    "en",
+		},
+		ResponseData: js,
+	}
+	db = newDropbox(t)
+	http.DefaultClient = &http.Client{
+		Transport: fake,
+	}
+
+	if received, err = db.Copy(from, to, false); err != nil {
+		t.Errorf("API error: %s", err)
+	} else if !reflect.DeepEqual(expected, *received) {
+		t.Errorf("got %#v expected %#v", *received, expected)
+	}
+
+	delete(fake.Params, "from_path")
+	fake.Params["from_copy_ref"] = from
+	if received, err = db.Copy(from, to, true); err != nil {
+		t.Errorf("API error: %s", err)
+	} else if !reflect.DeepEqual(expected, *received) {
+		t.Errorf("got %#v expected %#v", *received, expected)
+	}
+}
+
+func TestCopyRef(t *testing.T) {
+	var err error
+	var db *Dropbox
+	var received *CopyRef
+	var filename string
+
+	filename = "dummyfile"
+	db = newDropbox(t)
+
+	expected := CopyRef{CopyRef: "z1X6ATl6aWtzOGq0c3g5Ng", Expires: "Fri, 31 Jan 2042 21:01:05 +0000"}
+	js, err := json.Marshal(expected)
+	if err != nil {
+		t.Fatalf("could not run test due to marshalling issue")
+	}
+
+	http.DefaultClient = &http.Client{
+		Transport: FakeHTTP{
+			Method:       "GET",
+			Host:         "api.dropbox.com",
+			Path:         "/1/copy_ref/auto/" + filename,
+			t:            t,
+			Params:       map[string]string{"locale": "en"},
+			ResponseData: js,
+		},
+	}
+	if received, err = db.CopyRef(filename); err != nil {
+		t.Errorf("API error: %s", err)
+	} else if !reflect.DeepEqual(expected, *received) {
+		t.Errorf("got %#v expected %#v", *received, expected)
+	}
+}
+
+func TestCreateFolder(t *testing.T) {
+	var err error
+	var db *Dropbox
+	var received *Entry
+	var foldername string
+
+	expected := dirEntry
+	foldername = expected.Path[1:]
+
+	js, err := json.Marshal(expected)
+	if err != nil {
+		t.Fatalf("could not run test due to marshalling issue")
+	}
+
+	db = newDropbox(t)
+	http.DefaultClient = &http.Client{
+		Transport: FakeHTTP{
+			Method: "POST",
+			Host:   "api.dropbox.com",
+			Path:   "/1/fileops/create_folder",
+			Params: map[string]string{
+				"root":   "auto",
+				"path":   foldername,
+				"locale": "en",
+			},
+			t:            t,
+			ResponseData: js,
+		},
+	}
+	if received, err = db.CreateFolder(foldername); err != nil {
+		t.Errorf("API error: %s", err)
+	} else if !reflect.DeepEqual(expected, *received) {
+		t.Errorf("got %#v expected %#v", *received, expected)
+	}
+}
+
+func TestDelete(t *testing.T) {
+	var err error
+	var db *Dropbox
+	var received *Entry
+	var path string
+
+	expected := dirEntry
+	expected.IsDeleted = true
+	path = expected.Path[1:]
+
+	js, err := json.Marshal(expected)
+	if err != nil {
+		t.Fatalf("could not run test marshalling issue")
+	}
+
+	db = newDropbox(t)
+	http.DefaultClient = &http.Client{
+		Transport: FakeHTTP{
+			t:      t,
+			Method: "POST",
+			Host:   "api.dropbox.com",
+			Path:   "/1/fileops/delete",
+			Params: map[string]string{
+				"root":   "auto",
+				"path":   path,
+				"locale": "en",
+			},
+			ResponseData: js,
+		},
+	}
+	if received, err = db.Delete(path); err != nil {
+		t.Errorf("API error: %s", err)
+	} else if !reflect.DeepEqual(expected, *received) {
+		t.Errorf("got %#v expected %#v", *received, expected)
+	}
+}
+
+func TestFilesPut(t *testing.T) {
+	var err error
+	var db *Dropbox
+	var received *Entry
+	var filename string
+	var content, js []byte
+	var fake FakeHTTP
+
+	filename = "test.txt"
+	content = []byte("file content")
+
+	expected := Entry{Size: strconv.FormatInt(int64(len(content)), 10), Revision: "35e97029684fe", ThumbExists: false, Bytes: int64(len(content)),
+		Modified: DBTime(time.Date(2011, time.July, 19, 21, 55, 38, 0, time.UTC)), Path: "/" + filename, IsDir: false, Icon: "page_white_text",
+		Root: "auto", MimeType: "text/plain"}
+
+	js, err = json.Marshal(expected)
+	if err != nil {
+		t.Fatalf("could not run test marshalling issue")
+	}
+
+	fake = FakeHTTP{
+		t:      t,
+		Method: "PUT",
+		Host:   "api-content.dropbox.com",
+		Path:   "/1/files_put/auto/" + filename,
+		Params: map[string]string{
+			"locale":    "en",
+			"overwrite": "false",
+		},
+		ResponseData: js,
+		RequestData:  content,
+	}
+
+	db = newDropbox(t)
+	http.DefaultClient = &http.Client{
+		Transport: fake,
+	}
+
+	received, err = db.FilesPut(ioutil.NopCloser(bytes.NewBuffer(content)), int64(len(content)), filename, false, "")
+	if err != nil {
+		t.Errorf("API error: %s", err)
+	} else if !reflect.DeepEqual(expected, *received) {
+		t.Errorf("got %#v expected %#v", *received, expected)
+	}
+
+	fake.Params["parent_rev"] = "12345"
+	received, err = db.FilesPut(ioutil.NopCloser(bytes.NewBuffer(content)), int64(len(content)), filename, false, "12345")
+	if err != nil {
+		t.Errorf("API error: %s", err)
+	} else if !reflect.DeepEqual(expected, *received) {
+		t.Errorf("got %#v expected %#v", *received, expected)
+	}
+
+	fake.Params["overwrite"] = "true"
+	received, err = db.FilesPut(ioutil.NopCloser(bytes.NewBuffer(content)), int64(len(content)), filename, true, "12345")
+	if err != nil {
+		t.Errorf("API error: %s", err)
+	} else if !reflect.DeepEqual(expected, *received) {
+		t.Errorf("got %#v expected %#v", *received, expected)
+	}
+
+	_, err = db.FilesPut(ioutil.NopCloser(bytes.NewBuffer(content)), int64(MaxPutFileSize+1), filename, true, "12345")
+	if err == nil {
+		t.Errorf("size > %d bytes must returns an error", MaxPutFileSize)
+	}
+}
+
+func TestMedia(t *testing.T) {
+	var err error
+	var db *Dropbox
+	var received *Link
+	var filename string
+
+	filename = "dummyfile"
+	db = newDropbox(t)
+
+	expected := Link{Expires: DBTime(time.Date(2011, time.August, 10, 18, 21, 30, 0, time.UTC)), URL: "https://dl.dropboxusercontent.com/1/view/abcdefghijk/example"}
+	js, err := json.Marshal(expected)
+	if err != nil {
+		t.Fatalf("could not run test due to marshalling issue: %s", err)
+	}
+
+	http.DefaultClient = &http.Client{
+		Transport: FakeHTTP{
+			Method:       "POST",
+			Host:         "api.dropbox.com",
+			Path:         "/1/media/auto/" + filename,
+			Params:       map[string]string{"locale": "en"},
+			t:            t,
+			ResponseData: js,
+		},
+	}
+	if received, err = db.Media(filename); err != nil {
+		t.Errorf("API error: %s", err)
+	} else if !reflect.DeepEqual(expected, *received) {
+		t.Errorf("got %#v expected %#v", *received, expected)
+	}
+}
+
+func TestMetadata(t *testing.T) {
+	var err error
+	var db *Dropbox
+	var received *Entry
+	var path string
+	var fake FakeHTTP
+
+	expected := fileEntry
+	path = expected.Path[1:]
+
+	js, err := json.Marshal(expected)
+	if err != nil {
+		t.Fatalf("could not run test marshalling issue")
+	}
+
+	fake = FakeHTTP{
+		t:      t,
+		Method: "GET",
+		Host:   "api.dropbox.com",
+		Path:   "/1/metadata/auto/" + path,
+		Params: map[string]string{
+			"list":            "false",
+			"include_deleted": "false",
+			"file_limit":      "10",
+			"locale":          "en",
+		},
+		ResponseData: js,
+	}
+	db = newDropbox(t)
+	http.DefaultClient = &http.Client{
+		Transport: fake,
+	}
+
+	if received, err = db.Metadata(path, false, false, "", "", 10); err != nil {
+		t.Errorf("API error: %s", err)
+	} else if !reflect.DeepEqual(expected, *received) {
+		t.Errorf("got %#v expected %#v", *received, expected)
+	}
+
+	fake.Params["list"] = "true"
+	if received, err = db.Metadata(path, true, false, "", "", 10); err != nil {
+		t.Errorf("API error: %s", err)
+	} else if !reflect.DeepEqual(expected, *received) {
+		t.Errorf("got %#v expected %#v", *received, expected)
+	}
+
+	fake.Params["include_deleted"] = "true"
+	if received, err = db.Metadata(path, true, true, "", "", 10); err != nil {
+		t.Errorf("API error: %s", err)
+	} else if !reflect.DeepEqual(expected, *received) {
+		t.Errorf("got %#v expected %#v", *received, expected)
+	}
+
+	fake.Params["file_limit"] = "20"
+	if received, err = db.Metadata(path, true, true, "", "", 20); err != nil {
+		t.Errorf("API error: %s", err)
+	} else if !reflect.DeepEqual(expected, *received) {
+		t.Errorf("got %#v expected %#v", *received, expected)
+	}
+
+	fake.Params["rev"] = "12345"
+	if received, err = db.Metadata(path, true, true, "", "12345", 20); err != nil {
+		t.Errorf("API error: %s", err)
+	} else if !reflect.DeepEqual(expected, *received) {
+		t.Errorf("got %#v expected %#v", *received, expected)
+	}
+
+	fake.Params["hash"] = "6789"
+	if received, err = db.Metadata(path, true, true, "6789", "12345", 20); err != nil {
+		t.Errorf("API error: %s", err)
+	} else if !reflect.DeepEqual(expected, *received) {
+		t.Errorf("got %#v expected %#v", *received, expected)
+	}
+
+	fake.Params["file_limit"] = "10000"
+	if received, err = db.Metadata(path, true, true, "6789", "12345", 0); err != nil {
+		t.Errorf("API error: %s", err)
+	} else if !reflect.DeepEqual(expected, *received) {
+		t.Errorf("got %#v expected %#v", *received, expected)
+	}
+
+	fake.Params["file_limit"] = strconv.FormatInt(int64(MetadataLimitMax), 10)
+	if received, err = db.Metadata(path, true, true, "6789", "12345", MetadataLimitMax+1); err != nil {
+		t.Errorf("API error: %s", err)
+	} else if !reflect.DeepEqual(expected, *received) {
+		t.Errorf("got %#v expected %#v", *received, expected)
+	}
+}
+
+func TestMove(t *testing.T) {
+	var err error
+	var db *Dropbox
+	var received *Entry
+	var from, to string
+
+	expected := fileEntry
+	from = expected.Path[1:]
+	to = from + ".1"
+	expected.Path = to
+
+	js, err := json.Marshal(expected)
+	if err != nil {
+		t.Fatalf("could not run test marshalling issue")
+	}
+
+	db = newDropbox(t)
+	http.DefaultClient = &http.Client{
+		Transport: FakeHTTP{
+			t:      t,
+			Method: "POST",
+			Host:   "api.dropbox.com",
+			Path:   "/1/fileops/move",
+			Params: map[string]string{
+				"root":      "auto",
+				"from_path": from,
+				"to_path":   to,
+				"locale":    "en",
+			},
+			ResponseData: js,
+		},
+	}
+	if received, err = db.Move(from, to); err != nil {
+		t.Errorf("API error: %s", err)
+	} else if !reflect.DeepEqual(expected, *received) {
+		t.Errorf("got %#v expected %#v", *received, expected)
+	}
+}
+
+func TestRestore(t *testing.T) {
+	var err error
+	var db *Dropbox
+	var received *Entry
+	var path string
+
+	expected := fileEntry
+	path = expected.Path[1:]
+
+	js, err := json.Marshal(expected)
+	if err != nil {
+		t.Fatalf("could not run test marshalling issue")
+	}
+
+	db = newDropbox(t)
+	http.DefaultClient = &http.Client{
+		Transport: FakeHTTP{
+			t:      t,
+			Method: "POST",
+			Host:   "api.dropbox.com",
+			Path:   "/1/restore/auto/" + path,
+			Params: map[string]string{
+				"rev":    expected.Revision,
+				"locale": "en",
+			},
+			ResponseData: js,
+		},
+	}
+	if received, err = db.Restore(path, expected.Revision); err != nil {
+		t.Errorf("API error: %s", err)
+	} else if !reflect.DeepEqual(expected, *received) {
+		t.Errorf("got %#v expected %#v", *received, expected)
+	}
+}
+
+func TestRevisions(t *testing.T) {
+	var err error
+	var db *Dropbox
+	var received []Entry
+	var path string
+	var fake FakeHTTP
+
+	expected := []Entry{fileEntry}
+	path = expected[0].Path[1:]
+
+	js, err := json.Marshal(expected)
+	if err != nil {
+		t.Fatalf("could not run test marshalling issue")
+	}
+
+	fake = FakeHTTP{
+		t:      t,
+		Method: "GET",
+		Host:   "api.dropbox.com",
+		Path:   "/1/revisions/auto/" + path,
+		Params: map[string]string{
+			"rev_limit": "10",
+			"locale":    "en",
+		},
+		ResponseData: js,
+	}
+	db = newDropbox(t)
+	http.DefaultClient = &http.Client{
+		Transport: fake,
+	}
+
+	if received, err = db.Revisions(path, 10); err != nil {
+		t.Errorf("API error: %s", err)
+	} else if !reflect.DeepEqual(expected, received) {
+		t.Errorf("got %#v expected %#v", received, expected)
+	}
+
+	fake.Params["rev_limit"] = strconv.FormatInt(int64(RevisionsLimitDefault), 10)
+	if received, err = db.Revisions(path, 0); err != nil {
+		t.Errorf("API error: %s", err)
+	} else if !reflect.DeepEqual(expected, received) {
+		t.Errorf("got %#v expected %#v", received, expected)
+	}
+
+	fake.Params["rev_limit"] = strconv.FormatInt(int64(RevisionsLimitMax), 10)
+	if received, err = db.Revisions(path, RevisionsLimitMax+1); err != nil {
+		t.Errorf("API error: %s", err)
+	} else if !reflect.DeepEqual(expected, received) {
+		t.Errorf("got %#v expected %#v", received, expected)
+	}
+}
+
+func TestSearch(t *testing.T) {
+	var err error
+	var db *Dropbox
+	var received []Entry
+	var dirname string
+
+	dirname = "dummy"
+	db = newDropbox(t)
+
+	expected := []Entry{Entry{Size: "0 bytes", Revision: "35c1f029684fe", ThumbExists: false, Bytes: 0,
+		Modified: DBTime(time.Date(2011, time.August, 10, 18, 21, 30, 0, time.UTC)), Path: "/" + dirname + "/dummyfile", IsDir: false, Icon: "page_white_text",
+		Root: "auto", MimeType: "text/plain"}}
+	js, err := json.Marshal(expected)
+	if err != nil {
+		t.Fatalf("could not run test due to marshalling issue")
+	}
+
+	fake := FakeHTTP{
+		Method: "GET",
+		Host:   "api.dropbox.com",
+		Path:   "/1/search/auto/" + dirname,
+		t:      t,
+		Params: map[string]string{
+			"locale":          "en",
+			"query":           "foo bar",
+			"file_limit":      "10",
+			"include_deleted": "false",
+		},
+		ResponseData: js,
+	}
+	http.DefaultClient = &http.Client{
+		Transport: fake,
+	}
+
+	if received, err = db.Search(dirname, "foo bar", 10, false); err != nil {
+		t.Errorf("API error: %s", err)
+	} else if !reflect.DeepEqual(expected, received) {
+		t.Errorf("got %#v expected %#v", received, expected)
+	}
+
+	fake.Params["include_deleted"] = "true"
+	if received, err = db.Search(dirname, "foo bar", 10, true); err != nil {
+		t.Errorf("API error: %s", err)
+	} else if !reflect.DeepEqual(expected, received) {
+		t.Errorf("got %#v expected %#v", received, expected)
+	}
+
+	fake.Params["file_limit"] = strconv.FormatInt(int64(SearchLimitDefault), 10)
+	if received, err = db.Search(dirname, "foo bar", 0, true); err != nil {
+		t.Errorf("API error: %s", err)
+	} else if !reflect.DeepEqual(expected, received) {
+		t.Errorf("got %#v expected %#v", received, expected)
+	}
+
+	if received, err = db.Search(dirname, "foo bar", SearchLimitMax+1, true); err != nil {
+		t.Errorf("API error: %s", err)
+	} else if !reflect.DeepEqual(expected, received) {
+		t.Errorf("got %#v expected %#v", received, expected)
+	}
+}
+
+func TestShares(t *testing.T) {
+	var err error
+	var db *Dropbox
+	var received *Link
+	var filename string
+
+	filename = "dummyfile"
+	db = newDropbox(t)
+
+	expected := Link{Expires: DBTime(time.Date(2011, time.August, 10, 18, 21, 30, 0, time.UTC)), URL: "https://db.tt/c0mFuu1Y"}
+	js, err := json.Marshal(expected)
+	if err != nil {
+		t.Fatalf("could not run test due to marshalling issue")
+	}
+	fake := FakeHTTP{
+		Method: "POST",
+		Host:   "api.dropbox.com",
+		Path:   "/1/shares/auto/" + filename,
+		Params: map[string]string{
+			"locale":    "en",
+			"short_url": "false",
+		},
+		t:            t,
+		ResponseData: js,
+	}
+	http.DefaultClient = &http.Client{
+		Transport: fake,
+	}
+
+	if received, err = db.Shares(filename, false); err != nil {
+		t.Errorf("API error: %s", err)
+	} else if !reflect.DeepEqual(expected, *received) {
+		t.Errorf("got %#v expected %#v", *received, expected)
+	}
+
+	fake.Params["short_url"] = "true"
+	if received, err = db.Shares(filename, true); err != nil {
+		t.Errorf("API error: %s", err)
+	} else if !reflect.DeepEqual(expected, *received) {
+		t.Errorf("got %#v expected %#v", *received, expected)
+	}
+}
+
+func TestLatestCursor(t *testing.T) {
+	tab := []struct {
+		prefix    string
+		mediaInfo bool
+	}{
+		{
+			prefix:    "",
+			mediaInfo: false,
+		},
+		{
+			prefix:    "/some",
+			mediaInfo: false,
+		},
+		{
+			prefix:    "",
+			mediaInfo: true,
+		},
+		{
+			prefix:    "/some",
+			mediaInfo: true,
+		},
+	}
+
+	expected := Cursor{Cursor: "some"}
+	cur, err := json.Marshal(expected)
+	if err != nil {
+		t.Fatal("Failed to JSON encode Cursor")
+	}
+
+	for _, testCase := range tab {
+		db := newDropbox(t)
+		fake := FakeHTTP{
+			Method: "POST",
+			Host:   "api.dropbox.com",
+			Path:   "/1/delta/latest_cursor",
+			t:      t,
+			Params: map[string]string{
+				"locale": "en",
+			},
+			ResponseData: cur,
+		}
+
+		if testCase.prefix != "" {
+			fake.Params["path_prefix"] = testCase.prefix
+		}
+
+		if testCase.mediaInfo {
+			fake.Params["include_media_info"] = "true"
+		}
+
+		http.DefaultClient = &http.Client{
+			Transport: fake,
+		}
+
+		if received, err := db.LatestCursor(testCase.prefix, testCase.mediaInfo); err != nil {
+			t.Errorf("API error: %s", err)
+		} else if !reflect.DeepEqual(expected, *received) {
+			t.Errorf("got %#v expected %#v", *received, expected)
+		}
+	}
+}