func TestMergeFileSets(t *testing.T) {
mergedSet := mergeFileSets(
[]File{{Name: "a"}, {Name: "b"}},
[]File{{Name: "a"}, {Name: "c"}})
ensure.SameElements(t, []File{{Name: "a"}, {Name: "b"}, {Name: "c"}}, mergedSet)
mergedSet = mergeFileSets(
[]File{{Name: "a"}, {Name: "b"}, {Name: "c"}},
[]File{})
ensure.SameElements(t, []File{{Name: "a"}, {Name: "b"}, {Name: "c"}}, mergedSet)
}
func TestObjectString(t *testing.T) {
var g inject.Graph
a := &TypeNestedStruct{}
if err := g.Provide(&inject.Object{Value: a, Name: "foo"}); err != nil {
t.Fatal(err)
}
var c TypeForObjectString
if err := g.Provide(&inject.Object{Value: &c}); err != nil {
t.Fatal(err)
}
if err := g.Populate(); err != nil {
t.Fatal(err)
}
var actual []string
for _, o := range g.Objects() {
actual = append(actual, fmt.Sprint(o))
}
ensure.SameElements(t, actual, []string{
"*inject_test.TypeForObjectString",
"*inject_test.TypeNestedStruct",
"*inject_test.TypeNestedStruct named foo",
"*inject_test.TypeAnswerStruct",
})
}
func TestPrefixClient(t *testing.T) {
const (
prefix1 = "prefix1"
prefix2 = "prefix2"
avgKey = "avg"
avgVal = float64(1)
sumKey = "sum"
sumVal = float64(2)
histogramKey = "histogram"
histogramVal = float64(3)
timeKey = "time"
)
var keys []string
hc := &stats.HookClient{
BumpAvgHook: func(key string, val float64) {
keys = append(keys, key)
ensure.DeepEqual(t, val, avgVal)
},
BumpSumHook: func(key string, val float64) {
keys = append(keys, key)
ensure.DeepEqual(t, val, sumVal)
},
BumpHistogramHook: func(key string, val float64) {
keys = append(keys, key)
ensure.DeepEqual(t, val, histogramVal)
},
BumpTimeHook: func(key string) interface {
End()
} {
return multiEnderTest{
EndHook: func() {
keys = append(keys, key)
},
}
},
}
pc := stats.PrefixClient([]string{prefix1, prefix2}, hc)
pc.BumpAvg(avgKey, avgVal)
pc.BumpSum(sumKey, sumVal)
pc.BumpHistogram(histogramKey, histogramVal)
pc.BumpTime(timeKey).End()
ensure.SameElements(t, keys, []string{
prefix1 + avgKey,
prefix1 + sumKey,
prefix1 + histogramKey,
prefix1 + timeKey,
prefix2 + avgKey,
prefix2 + sumKey,
prefix2 + histogramKey,
prefix2 + timeKey,
})
}
// HelpTestStorage runs basic tests on the given Storage
func HelpTestStorage(t *testing.T, s Storage) {
data1 := []byte("abcdef")
data2 := strings.NewReader("xyz123")
err := s.Put("a/data1", data1)
ensure.Nil(t, err)
err = s.PutReader("b/data2", data2)
ensure.Nil(t, err)
items, err := s.List("a", 1000)
ensure.Nil(t, err)
ensure.DeepEqual(t, len(items), 1)
ensure.SameElements(t, items, []string{"a/data1"})
items, err = s.List("b/", 1000)
ensure.Nil(t, err)
ensure.DeepEqual(t, len(items), 1)
ensure.SameElements(t, items, []string{"b/data2"})
data1Reader, err := s.Get("a/data1")
ensure.Nil(t, err)
data2Reader, err := s.Get("b/data2")
ensure.Nil(t, err)
content, err := ioutil.ReadAll(data1Reader)
ensure.Nil(t, err)
ensure.DeepEqual(t, content, []byte("abcdef"))
content, err = ioutil.ReadAll(data2Reader)
ensure.Nil(t, err)
ensure.DeepEqual(t, content, []byte("xyz123"))
err = s.Delete("a/data1")
ensure.Nil(t, err)
err = s.Delete("b/data2")
ensure.Nil(t, err)
items, err = s.List("", 1000)
ensure.Nil(t, err)
ensure.DeepEqual(t, len(items), 0)
}
func TestSameElementsLengthDifference(t *testing.T) {
var c capture
ensure.SameElements(&c, []int{1, 2}, []interface{}{1})
c.Equal(t, `ensure_test.go:180: expected same elements but found slices of different lengths:
ACTUAL:
([]int) (len=2 cap=2) {
(int) 1,
(int) 2
}
EXPECTED
([]interface {}) (len=1 cap=1) {
(int) 1
}`)
}
func TestStatsTicker(t *testing.T) {
t.Parallel()
klock := clock.NewMock()
expected := []string{"alive", "idle", "out", "waiting"}
statsDone := make(chan string, 4)
hc := &stats.HookClient{
BumpAvgHook: func(key string, val float64) {
if contains(expected, key) {
statsDone <- key
}
},
}
var cm resourceMaker
p := Pool{
New: cm.New,
Stats: hc,
Max: 4,
MinIdle: 2,
IdleTimeout: time.Second,
ClosePoolSize: 2,
Clock: klock,
}
// acquire and release some resources to make them idle
var resources []io.Closer
for i := p.Max; i > 0; i-- {
r, err := p.Acquire()
ensure.Nil(t, err)
resources = append(resources, r)
}
for _, r := range resources {
p.Release(r)
}
// tick IdleTimeout to make them eligible
klock.Add(p.IdleTimeout)
// tick Minute to trigger stats
klock.Add(time.Minute)
// stats should soon show idle closed
ensure.SameElements(
t,
[]string{<-statsDone, <-statsDone, <-statsDone, <-statsDone},
expected,
)
}
func TestColumnFamilyCreateDrop(t *testing.T) {
dir, err := ioutil.TempDir("", "gorocksdb-TestColumnFamilyCreate")
ensure.Nil(t, err)
opts := NewDefaultOptions()
opts.SetCreateIfMissingColumnFamilies(true)
opts.SetCreateIfMissing(true)
db, err := OpenDb(opts, dir)
ensure.Nil(t, err)
defer db.Close()
cf, err := db.CreateColumnFamily(opts, "guide")
ensure.Nil(t, err)
defer cf.Destroy()
actualNames, err := ListColumnFamilies(opts, dir)
ensure.Nil(t, err)
ensure.SameElements(t, actualNames, []string{"default", "guide"})
ensure.Nil(t, db.DropColumnFamily(cf))
actualNames, err = ListColumnFamilies(opts, dir)
ensure.Nil(t, err)
ensure.SameElements(t, actualNames, []string{"default"})
}
func TestSameElementsRepeated(t *testing.T) {
var c capture
ensure.SameElements(&c, []int{1, 2}, []interface{}{1, 1})
c.Equal(t, `ensure_test.go:195: missing expected element:
ACTUAL:
([]int) (len=2 cap=2) {
(int) 1,
(int) 2
}
EXPECTED:
([]interface {}) (len=2 cap=2) {
(int) 1,
(int) 1
}
MISSING ELEMENT
(int) 1`)
}
func TestMetadata(t *testing.T) {
m := NewMetadataStore()
md0 := SnapshotMetadata{ReplicaID: "replset1_host1", ID: "1", Path: "/path/foo", Files: []File{{Name: "a"}, {Name: "b"}, {Name: "c"}}}
md1 := SnapshotMetadata{ReplicaID: "replset1_host1", ID: "2", Path: "/path/foo", Files: []File{{Name: "a"}, {Name: "b"}, {Name: "c"}}}
md2 := SnapshotMetadata{ReplicaID: "replset2_host2", ID: "1", Path: "/path/foo", Files: []File{{Name: "a"}, {Name: "b"}, {Name: "c"}}}
err := m.Add(NewLazySMFromM(&md0))
ensure.Nil(t, err)
err = m.Add(NewLazySMFromM(&md1))
ensure.Nil(t, err)
err = m.Add(NewLazySMFromM(&md2))
ensure.Nil(t, err)
ensure.SameElements(t, m.GetReplicaIDs(), []string{"replset1_host1", "replset2_host2"})
lazyMD, err := m.getForReplica("replset1_host1")
ensure.Nil(t, err)
ensure.DeepEqual(t, len(lazyMD), 2)
mdRetrieved, err := lazyMD[0].Get()
ensure.Nil(t, err)
ensure.Subset(t, *mdRetrieved, SnapshotMetadata{ID: "1", Path: "/path/foo", Files: []File{{Name: "a"}, {Name: "b"}, {Name: "c"}}})
mdRetrieved, err = lazyMD[1].Get()
ensure.Nil(t, err)
ensure.Subset(t, *mdRetrieved, SnapshotMetadata{ID: "2", Path: "/path/foo", Files: []File{{Name: "a"}, {Name: "b"}, {Name: "c"}}})
lazyMD, err = m.getForReplica("replset2_host2")
ensure.Nil(t, err)
ensure.DeepEqual(t, len(lazyMD), 1)
mdRetrieved, err = lazyMD[0].Get()
ensure.Nil(t, err)
ensure.Subset(t, *mdRetrieved, SnapshotMetadata{ID: "1", Path: "/path/foo", Files: []File{{Name: "a"}, {Name: "b"}, {Name: "c"}}})
m.DeleteForReplicaByID("replset1_host1", "1")
lazyMD, err = m.getForReplica("replset1_host1")
ensure.Nil(t, err)
// Both LazySnapshotMetadatas should still be in MetadataStore, but the first one should be marked for delete.
ensure.DeepEqual(t, len(lazyMD), 2)
ensure.True(t, lazyMD[0].DeleteMark)
ensure.False(t, lazyMD[1].DeleteMark)
mdRetrieved, err = lazyMD[1].Get()
ensure.Nil(t, err)
ensure.Subset(t, *mdRetrieved, SnapshotMetadata{ID: "2", Path: "/path/foo", Files: []File{{Name: "a"}, {Name: "b"}, {Name: "c"}}})
}
func TestColumnFamilyOpen(t *testing.T) {
dir, err := ioutil.TempDir("", "gorocksdb-TestColumnFamilyOpen")
ensure.Nil(t, err)
givenNames := []string{"default", "guide"}
opts := NewDefaultOptions()
opts.SetCreateIfMissingColumnFamilies(true)
opts.SetCreateIfMissing(true)
db, cfh, err := OpenDbColumnFamilies(opts, dir, givenNames, []*Options{opts, opts})
ensure.Nil(t, err)
defer db.Close()
ensure.DeepEqual(t, len(cfh), 2)
cfh[0].Destroy()
cfh[1].Destroy()
actualNames, err := ListColumnFamilies(opts, dir)
ensure.Nil(t, err)
ensure.SameElements(t, actualNames, givenNames)
}
func TestHiddenInputs(t *testing.T) {
const (
k1 = "k1"
v1a = "v1a"
v1b = "v1b"
k2 = "k2"
v2 = "v2"
)
v := url.Values{
k1: []string{v1a, v1b},
k2: []string{v2},
}
d := HiddenInputs(v).(*Div)
ensure.DeepEqual(t, d.Style, "display:none")
f := d.Inner.(Frag)
ensure.SameElements(t, f, Frag{
&Input{Name: k1, Value: v1a},
&Input{Name: k1, Value: v1b},
&Input{Name: k2, Value: v2},
})
}
func TestGraphObjects(t *testing.T) {
var g inject.Graph
err := g.Provide(
&inject.Object{Value: &TypeNestedStruct{}, Name: "foo"},
&inject.Object{Value: &TypeForGraphObjects{}},
)
ensure.Nil(t, err)
ensure.Nil(t, g.Populate())
var actual []string
for _, o := range g.Objects() {
actual = append(actual, fmt.Sprint(o))
}
ensure.SameElements(t, actual, []string{
"*inject_test.TypeAnswerStruct",
"*inject_test.TypeForGraphObjects",
"*inject_test.TypeNestedStruct named foo",
"*inject_test.TypeNestedStruct",
`*struct { B *inject_test.TypeNestedStruct "inject:\"\"" }`,
})
}
func TestPatternWalker(t *testing.T) {
t.Parallel()
root := makeEmptyRoot(t)
defer os.RemoveAll(root)
files, dirs := initProject(t, root)
dirs = append(dirs, root)
var visitedFiles, visitedDirs []string
walkFn := func(path string, info os.FileInfo, err error) error {
if err != nil {
return err
}
if info.IsDir() {
visitedDirs = append(visitedDirs, path)
return nil
}
visitedFiles = append(visitedFiles, path)
return nil
}
testCases := []struct {
ignores string
expectedFiles, expectedDirs []string
}{
{
`
test/
!tester/test
`,
[]string{},
[]string{
filepath.Join(root, "tester", "inside", "test"),
},
},
{
`
test
!tester/test
`,
[]string{
filepath.Join(root, "tester", "inside", "tester", "test"),
},
[]string{
filepath.Join(root, "tester", "inside", "test"),
},
},
{
`
test*
`,
files,
[]string{
filepath.Join(root, "tester"),
filepath.Join(root, "tester", "inside"),
filepath.Join(root, "tester", "inside", "test"),
filepath.Join(root, "tester", "inside", "tester"),
},
},
}
for _, testCase := range testCases {
matcher, errors := parseIgnoreMatcher([]byte(testCase.ignores))
ensure.DeepEqual(t, len(errors), 0)
visitedFiles, visitedDirs = nil, nil
errors, err := parseIgnoreWalk(matcher, root, walkFn)
ensure.Nil(t, err)
ensure.DeepEqual(t, len(errors), 0)
var aggFiles, aggDirs []string
aggFiles = append(aggFiles, testCase.expectedFiles...)
aggFiles = append(aggFiles, visitedFiles...)
aggDirs = append(aggDirs, testCase.expectedDirs...)
aggDirs = append(aggDirs, visitedDirs...)
ensure.SameElements(t, aggFiles, files)
ensure.SameElements(t, aggDirs, dirs)
}
}
func TestSameElementsIntAndInterface(t *testing.T) {
ensure.SameElements(t, []int{1, 2}, []interface{}{2, 1})
}
func TestSubtractFileSets(t *testing.T) {
newSet := subtractFileSets(
[]File{{Name: "a"}, {Name: "b"}, {Name: "c"}},
[]File{{Name: "a"}, {Name: "c"}})
ensure.SameElements(t, []File{{Name: "b"}}, newSet)
}