func TestQuerySimple(t *testing.T) { mapds := datastore.NewMapDatastore() m := mount.New([]mount.Mount{ {Prefix: datastore.NewKey("/quux"), Datastore: mapds}, }) const myKey = "/quux/thud" if err := m.Put(datastore.NewKey(myKey), []byte("foobar")); err != nil { t.Fatalf("Put error: %v", err) } res, err := m.Query(query.Query{Prefix: "/quux"}) if err != nil { t.Fatalf("Query fail: %v\n", err) } entries, err := res.Rest() if err != nil { t.Fatalf("Query Results.Rest fail: %v\n", err) } seen := false for _, e := range entries { switch e.Key { case datastore.NewKey(myKey).String(): seen = true default: t.Errorf("saw unexpected key: %q", e.Key) } } if !seen { t.Errorf("did not see wanted key %q in %+v", myKey, entries) } }
func TestGetBadNothing(t *testing.T) { m := mount.New([]mount.Mount{}) _, err := m.Get(datastore.NewKey("/quux/thud")) if g, e := err, datastore.ErrNotFound; g != e { t.Fatalf("expected ErrNotFound, got: %v\n", g) } }
func TestPutBadNothing(t *testing.T) { m := mount.New(nil) err := m.Put(datastore.NewKey("quux"), []byte("foobar")) if g, e := err, mount.ErrNoMount; g != e { t.Fatalf("Put got wrong error: %v != %v", g, e) } }
// openDatastore returns an error if the config file is not present. func (r *FSRepo) openDatastore() error { leveldbPath := path.Join(r.path, leveldbDirectory) var err error // save leveldb reference so it can be neatly closed afterward leveldbDS, err := levelds.NewDatastore(leveldbPath, &levelds.Options{ Compression: ldbopts.NoCompression, }) if err != nil { return errors.New("unable to open leveldb datastore") } // 4TB of 256kB objects ~=17M objects, splitting that 256-way // leads to ~66k objects per dir, splitting 256*256-way leads to // only 256. // // The keys seen by the block store have predictable prefixes, // including "/" from datastore.Key and 2 bytes from multihash. To // reach a uniform 256-way split, we need approximately 4 bytes of // prefix. blocksDS, err := flatfs.New(path.Join(r.path, flatfsDirectory), 4) if err != nil { return errors.New("unable to open flatfs datastore") } // Add our PeerID to metrics paths to keep them unique // // As some tests just pass a zero-value Config to fsrepo.Init, // cope with missing PeerID. id := r.config.Identity.PeerID if id == "" { // the tests pass in a zero Config; cope with it id = fmt.Sprintf("uninitialized_%p", r) } prefix := "fsrepo." + id + ".datastore." metricsBlocks := measure.New(prefix+"blocks", blocksDS) metricsLevelDB := measure.New(prefix+"leveldb", leveldbDS) mountDS := mount.New([]mount.Mount{ { Prefix: ds.NewKey("/blocks"), Datastore: metricsBlocks, }, { Prefix: ds.NewKey("/"), Datastore: metricsLevelDB, }, }) // Make sure it's ok to claim the virtual datastore from mount as // threadsafe. There's no clean way to make mount itself provide // this information without copy-pasting the code into two // variants. This is the same dilemma as the `[].byte` attempt at // introducing const types to Go. var _ ds.ThreadSafeDatastore = blocksDS var _ ds.ThreadSafeDatastore = leveldbDS r.ds = ds2.ClaimThreadSafe{mountDS} return nil }
func TestGetNotFound(t *testing.T) { mapds := datastore.NewMapDatastore() m := mount.New([]mount.Mount{ {Prefix: datastore.NewKey("/quux"), Datastore: mapds}, }) _, err := m.Get(datastore.NewKey("/quux/thud")) if g, e := err, datastore.ErrNotFound; g != e { t.Fatalf("expected ErrNotFound, got: %v\n", g) } }
func TestPutBadNoMount(t *testing.T) { mapds := datastore.NewMapDatastore() m := mount.New([]mount.Mount{ {Prefix: datastore.NewKey("/redherring"), Datastore: mapds}, }) err := m.Put(datastore.NewKey("/quux/thud"), []byte("foobar")) if g, e := err, mount.ErrNoMount; g != e { t.Fatalf("expected ErrNoMount, got: %v\n", g) } }
func TestHasBadNothing(t *testing.T) { m := mount.New([]mount.Mount{}) found, err := m.Has(datastore.NewKey("/quux/thud")) if err != nil { t.Fatalf("Has error: %v", err) } if g, e := found, false; g != e { t.Fatalf("wrong value: %v != %v", g, e) } }
func TestHasNotFound(t *testing.T) { mapds := datastore.NewMapDatastore() m := mount.New([]mount.Mount{ {Prefix: datastore.NewKey("/quux"), Datastore: mapds}, }) found, err := m.Has(datastore.NewKey("/quux/thud")) if err != nil { t.Fatalf("Has error: %v", err) } if g, e := found, false; g != e { t.Fatalf("wrong value: %v != %v", g, e) } }
func TestHas(t *testing.T) { mapds := datastore.NewMapDatastore() m := mount.New([]mount.Mount{ {Prefix: datastore.NewKey("/quux"), Datastore: mapds}, }) if err := mapds.Put(datastore.NewKey("/thud"), []byte("foobar")); err != nil { t.Fatalf("Put error: %v", err) } found, err := m.Has(datastore.NewKey("/quux/thud")) if err != nil { t.Fatalf("Has error: %v", err) } if g, e := found, true; g != e { t.Fatalf("wrong value: %v != %v", g, e) } }
func TestPut(t *testing.T) { mapds := datastore.NewMapDatastore() m := mount.New([]mount.Mount{ {Prefix: datastore.NewKey("/quux"), Datastore: mapds}, }) if err := m.Put(datastore.NewKey("/quux/thud"), []byte("foobar")); err != nil { t.Fatalf("Put error: %v", err) } val, err := mapds.Get(datastore.NewKey("/thud")) if err != nil { t.Fatalf("Get error: %v", err) } buf, ok := val.([]byte) if !ok { t.Fatalf("Get value is not []byte: %T %v", val, val) } if g, e := string(buf), "foobar"; g != e { t.Errorf("wrong value: %q != %q", g, e) } }
func TestDelete(t *testing.T) { mapds := datastore.NewMapDatastore() m := mount.New([]mount.Mount{ {Prefix: datastore.NewKey("/quux"), Datastore: mapds}, }) if err := mapds.Put(datastore.NewKey("/thud"), []byte("foobar")); err != nil { t.Fatalf("Put error: %v", err) } err := m.Delete(datastore.NewKey("/quux/thud")) if err != nil { t.Fatalf("Delete error: %v", err) } // make sure it disappeared found, err := mapds.Has(datastore.NewKey("/thud")) if err != nil { t.Fatalf("Has error: %v", err) } if g, e := found, false; g != e { t.Fatalf("wrong value: %v != %v", g, e) } }