mirror of
https://github.com/featurebasedb/featurebase.git
synced 2026-09-07 00:55:55 +00:00
fix shadowing of require in client internal tests
The `require` tool was being shadowed with the outer test's T, causing the testing package to explode sometimes.
This commit is contained in:
Nia Weiss
parent
c0ef297b11
commit
39337fa41b
1 changed files with 197 additions and 199 deletions
|
|
@ -41,7 +41,7 @@ var (
|
|||
testFieldInt1 *Field
|
||||
)
|
||||
|
||||
func setup(t *testing.T, r *require.Assertions, cli *Client) {
|
||||
func setup(t *testing.T, cli *Client) {
|
||||
t.Helper()
|
||||
|
||||
testSchema := NewSchema()
|
||||
|
|
@ -59,20 +59,18 @@ func setup(t *testing.T, r *require.Assertions, cli *Client) {
|
|||
testFieldInt0 = testIndexAtomicRecord.Field("test-field-int0", OptFieldTypeInt(-1000, 1000))
|
||||
testFieldInt1 = testIndexAtomicRecord.Field("test-field-int1", OptFieldTypeInt(-1000, 1000))
|
||||
|
||||
r.NoErrorf(cli.SyncSchema(testSchema), "SyncSchema")
|
||||
require.NoErrorf(t, cli.SyncSchema(testSchema), "SyncSchema")
|
||||
}
|
||||
|
||||
func tearDown(t *testing.T, r *require.Assertions, cli *Client) {
|
||||
func tearDown(t *testing.T, cli *Client) {
|
||||
t.Helper()
|
||||
|
||||
for _, i := range []*Index{testIndex, testIndexWithKeys, testIndexWithKeysNoTrack, testIndexAtomicRecord} {
|
||||
r.NoErrorf(cli.DeleteIndex(i), "DeleteIndex(%s)", i.name)
|
||||
for _, i := range []*Index{testIndex, testIndexWithKeys, testIndexWithKeysNoTrack, testIndexAtomicRecord, testIndexKeyTranslation} {
|
||||
require.NoErrorf(t, cli.DeleteIndex(i), "DeleteIndex(%s)", i.name)
|
||||
}
|
||||
}
|
||||
|
||||
func TestClientAgainstCluster(t *testing.T) {
|
||||
require := require.New(t)
|
||||
|
||||
for size, replicaN := 3, 1; replicaN <= 2; replicaN++ {
|
||||
testName := fmt.Sprintf("%d.%d", size, replicaN)
|
||||
t.Run(testName, func(t *testing.T) {
|
||||
|
|
@ -83,7 +81,7 @@ func TestClientAgainstCluster(t *testing.T) {
|
|||
n.Config.Cluster.ReplicaN = replicaN
|
||||
}
|
||||
err := c.Start()
|
||||
require.NoError(err, "Start cluster "+testName)
|
||||
require.NoError(t, err, "Start cluster "+testName)
|
||||
|
||||
urls := make([]string, len(c.Nodes))
|
||||
for i, n := range c.Nodes {
|
||||
|
|
@ -93,54 +91,54 @@ func TestClientAgainstCluster(t *testing.T) {
|
|||
|
||||
// Create a new client for the cluster
|
||||
cli, err := newClientFromAddresses(urls, &ClientOptions{})
|
||||
require.NoErrorf(err, "newClientFromAddresses(%v): %v", urls, err)
|
||||
require.NoErrorf(t, err, "newClientFromAddresses(%v): %v", urls, err)
|
||||
defer cli.Close()
|
||||
|
||||
t.Run("GetStatus", func(t *testing.T) {
|
||||
status, err := cli.Status()
|
||||
require.NoErrorf(err, "GET /status")
|
||||
require.NoErrorf(t, err, "GET /status")
|
||||
|
||||
require.Equalf(disco.ClusterStateNormal, disco.ClusterState(status.State), "GET /status")
|
||||
require.Equalf(t, disco.ClusterStateNormal, disco.ClusterState(status.State), "GET /status")
|
||||
})
|
||||
|
||||
t.Run("QueryRow", func(t *testing.T) {
|
||||
setup(t, require, cli)
|
||||
defer tearDown(t, require, cli)
|
||||
setup(t, cli)
|
||||
defer tearDown(t, cli)
|
||||
|
||||
resp, err := cli.Query(testField.Row(1))
|
||||
require.NoErrorf(err, "Query Row")
|
||||
require.NotNil(resp, "Response should not be nil")
|
||||
require.NoErrorf(t, err, "Query Row")
|
||||
require.NotNil(t, resp, "Response should not be nil")
|
||||
})
|
||||
|
||||
t.Run("QueryWithShards", func(t *testing.T) {
|
||||
setup(t, require, cli)
|
||||
defer tearDown(t, require, cli)
|
||||
setup(t, cli)
|
||||
defer tearDown(t, cli)
|
||||
|
||||
shardWidth := uint64(1 << shardwidth.Exponent)
|
||||
|
||||
_, err := cli.Query(testField.Set(1, 1))
|
||||
require.NoErrorf(err, "Set(1, %d)", 1)
|
||||
require.NoErrorf(t, err, "Set(1, %d)", 1)
|
||||
|
||||
_, err = cli.Query(testField.Set(1, shardWidth))
|
||||
require.NoErrorf(err, "Set(1, %d)", shardWidth)
|
||||
require.NoErrorf(t, err, "Set(1, %d)", shardWidth)
|
||||
|
||||
_, err = cli.Query(testField.Set(1, shardWidth*3))
|
||||
require.NoErrorf(err, "Set(1, %d)", shardWidth*3)
|
||||
require.NoErrorf(t, err, "Set(1, %d)", shardWidth*3)
|
||||
|
||||
resp, err := cli.Query(testField.Row(1), OptQueryShards(0, 3))
|
||||
require.NoErrorf(err, "Row(1) OptQueryShards(0, 3)")
|
||||
require.NoErrorf(t, err, "Row(1) OptQueryShards(0, 3)")
|
||||
|
||||
cols := resp.Result().Row().Columns
|
||||
require.Equalf([]uint64{1, shardWidth * 3}, cols, "Unexpected results: %#v", cols)
|
||||
require.Equalf(t, []uint64{1, shardWidth * 3}, cols, "Unexpected results: %#v", cols)
|
||||
})
|
||||
|
||||
t.Run("OrmCount", func(t *testing.T) {
|
||||
setup(t, require, cli)
|
||||
defer tearDown(t, require, cli)
|
||||
setup(t, cli)
|
||||
defer tearDown(t, cli)
|
||||
|
||||
testFieldCount := testIndex.Field("test-field-count")
|
||||
err := cli.EnsureField(testFieldCount)
|
||||
require.NoError(err)
|
||||
require.NoError(t, err)
|
||||
|
||||
qry := testIndex.BatchQuery(
|
||||
testFieldCount.Set(10, 20),
|
||||
|
|
@ -148,36 +146,36 @@ func TestClientAgainstCluster(t *testing.T) {
|
|||
testFieldCount.Set(15, 25),
|
||||
)
|
||||
_, err = cli.Query(qry)
|
||||
require.NoErrorf(err, "BatchQuery")
|
||||
require.NoErrorf(t, err, "BatchQuery")
|
||||
|
||||
resp, err := cli.Query(testIndex.Count(testFieldCount.Row(10)))
|
||||
require.NoErrorf(err, "Count")
|
||||
require.Equalf(int64(2), resp.Result().Count(), "Count")
|
||||
require.NoErrorf(t, err, "Count")
|
||||
require.Equalf(t, int64(2), resp.Result().Count(), "Count")
|
||||
})
|
||||
|
||||
t.Run("DecimalField", func(t *testing.T) {
|
||||
setup(t, require, cli)
|
||||
defer tearDown(t, require, cli)
|
||||
setup(t, cli)
|
||||
defer tearDown(t, cli)
|
||||
|
||||
testFieldDec := testIndex.Field("test-field-dec", OptFieldTypeDecimal(3))
|
||||
err := cli.EnsureField(testFieldDec)
|
||||
require.NoError(err)
|
||||
require.NoError(t, err)
|
||||
|
||||
sch, err := cli.Schema()
|
||||
require.NoErrorf(err, "Schema")
|
||||
require.NoErrorf(t, err, "Schema")
|
||||
|
||||
idx := sch.indexes[testIndex.name]
|
||||
opts := idx.Field(testFieldDec.name).Options()
|
||||
require.Equalf(int64(3), opts.scale, "%s scale", testFieldDec.name)
|
||||
require.Equalf(t, int64(3), opts.scale, "%s scale", testFieldDec.name)
|
||||
})
|
||||
|
||||
t.Run("IntersectReturns", func(t *testing.T) {
|
||||
setup(t, require, cli)
|
||||
defer tearDown(t, require, cli)
|
||||
setup(t, cli)
|
||||
defer tearDown(t, cli)
|
||||
|
||||
testFieldSegments := testIndex.Field("test-field-segments")
|
||||
err := cli.EnsureField(testFieldSegments)
|
||||
require.NoError(err)
|
||||
require.NoError(t, err)
|
||||
|
||||
qry1 := testIndex.BatchQuery(
|
||||
testFieldSegments.Set(2, 10),
|
||||
|
|
@ -186,23 +184,23 @@ func TestClientAgainstCluster(t *testing.T) {
|
|||
testFieldSegments.Set(3, 20),
|
||||
)
|
||||
_, err = cli.Query(qry1)
|
||||
require.NoErrorf(err, "BatchQuery")
|
||||
require.NoErrorf(t, err, "BatchQuery")
|
||||
|
||||
qry2 := testIndex.Intersect(testFieldSegments.Row(2), testFieldSegments.Row(3))
|
||||
resp, err := cli.Query(qry2)
|
||||
require.NoErrorf(err, "Intersect")
|
||||
require.NoErrorf(t, err, "Intersect")
|
||||
|
||||
require.Equalf(1, len(resp.Results()), "Intersect number of results")
|
||||
require.Equalf([]uint64{10}, resp.Result().Row().Columns, "Intersect columns results")
|
||||
require.Equalf(t, 1, len(resp.Results()), "Intersect number of results")
|
||||
require.Equalf(t, []uint64{10}, resp.Result().Row().Columns, "Intersect columns results")
|
||||
})
|
||||
|
||||
t.Run("TopNReturns", func(t *testing.T) {
|
||||
setup(t, require, cli)
|
||||
defer tearDown(t, require, cli)
|
||||
setup(t, cli)
|
||||
defer tearDown(t, cli)
|
||||
|
||||
testFieldTopN := testIndex.Field("test-field-topn")
|
||||
err := cli.EnsureField(testFieldTopN)
|
||||
require.NoError(err)
|
||||
require.NoError(t, err)
|
||||
|
||||
qry := testIndex.BatchQuery(
|
||||
testFieldTopN.Set(10, 5),
|
||||
|
|
@ -212,30 +210,30 @@ func TestClientAgainstCluster(t *testing.T) {
|
|||
testFieldTopN.Set(30, 5),
|
||||
)
|
||||
_, err = cli.Query(qry)
|
||||
require.NoErrorf(err, "BatchQuery")
|
||||
require.NoErrorf(t, err, "BatchQuery")
|
||||
|
||||
// XXX: The following is required to make this test pass. See: https://github.com/pilosa/pilosa/issues/625
|
||||
_, _, err = cli.HTTPRequest("POST", "/recalculate-caches", nil, nil)
|
||||
require.NoErrorf(err, "POST /recalculate-caches")
|
||||
require.NoErrorf(t, err, "POST /recalculate-caches")
|
||||
|
||||
resp, err := cli.Query(testFieldTopN.TopN(2))
|
||||
require.NoErrorf(err, "TopN(2)")
|
||||
require.NoErrorf(t, err, "TopN(2)")
|
||||
|
||||
items := resp.Result().CountItems()
|
||||
require.Equalf(2, len(items), "TopN result CountItems")
|
||||
require.Equalf(t, 2, len(items), "TopN result CountItems")
|
||||
|
||||
item := items[0]
|
||||
require.Equalf(uint64(10), item.ID, "TopN result item[0].ID")
|
||||
require.Equalf(uint64(3), item.Count, "TopN result item[0].Count")
|
||||
require.Equalf(t, uint64(10), item.ID, "TopN result item[0].ID")
|
||||
require.Equalf(t, uint64(3), item.Count, "TopN result item[0].Count")
|
||||
})
|
||||
|
||||
t.Run("MinMaxRow", func(t *testing.T) {
|
||||
setup(t, require, cli)
|
||||
defer tearDown(t, require, cli)
|
||||
setup(t, cli)
|
||||
defer tearDown(t, cli)
|
||||
|
||||
testFieldMinMax := testIndex.Field("test-field-minmax")
|
||||
err := cli.EnsureField(testFieldMinMax)
|
||||
require.NoError(err)
|
||||
require.NoError(t, err)
|
||||
|
||||
qry := testIndex.BatchQuery(
|
||||
testFieldMinMax.Set(10, 5),
|
||||
|
|
@ -245,207 +243,207 @@ func TestClientAgainstCluster(t *testing.T) {
|
|||
testFieldMinMax.Set(30, 5),
|
||||
)
|
||||
_, err = cli.Query(qry)
|
||||
require.NoErrorf(err, "Setting bits")
|
||||
require.NoErrorf(t, err, "Setting bits")
|
||||
|
||||
resp, err := cli.Query(testFieldMinMax.MinRow())
|
||||
require.NoErrorf(err, "MinRow")
|
||||
require.NoErrorf(t, err, "MinRow")
|
||||
|
||||
min := resp.Result().CountItem().ID
|
||||
require.Equalf(uint64(10), min, "Min")
|
||||
require.Equalf(t, uint64(10), min, "Min")
|
||||
|
||||
resp, err = cli.Query(testFieldMinMax.MaxRow())
|
||||
require.NoErrorf(err, "MaxRow")
|
||||
require.NoErrorf(t, err, "MaxRow")
|
||||
|
||||
max := resp.Result().CountItem().ID
|
||||
require.Equalf(uint64(30), max, "Max")
|
||||
require.Equalf(t, uint64(30), max, "Max")
|
||||
})
|
||||
|
||||
t.Run("SetMutexField", func(t *testing.T) {
|
||||
setup(t, require, cli)
|
||||
defer tearDown(t, require, cli)
|
||||
setup(t, cli)
|
||||
defer tearDown(t, cli)
|
||||
|
||||
testFieldMutex := testIndex.Field("test-field-mutex", OptFieldTypeMutex(CacheTypeDefault, 0))
|
||||
err := cli.EnsureField(testFieldMutex)
|
||||
require.NoError(err)
|
||||
require.NoError(t, err)
|
||||
|
||||
// can set mutex
|
||||
_, err = cli.Query(testFieldMutex.Set(1, 100))
|
||||
require.NoErrorf(err, "Set(1, 100)")
|
||||
require.NoErrorf(t, err, "Set(1, 100)")
|
||||
|
||||
resp, err := cli.Query(testFieldMutex.Row(1))
|
||||
require.NoErrorf(err, "Row(1)")
|
||||
require.NoErrorf(t, err, "Row(1)")
|
||||
|
||||
target := []uint64{100}
|
||||
require.Equalf(target, resp.Result().Row().Columns, "Row Result Columns")
|
||||
require.Equalf(t, target, resp.Result().Row().Columns, "Row Result Columns")
|
||||
|
||||
// setting another row removes the previous
|
||||
_, err = cli.Query(testFieldMutex.Set(42, 100))
|
||||
require.NoErrorf(err, "Set(42, 100)")
|
||||
require.NoErrorf(t, err, "Set(42, 100)")
|
||||
|
||||
resp, err = cli.Query(testIndex.BatchQuery(
|
||||
testFieldMutex.Row(1),
|
||||
testFieldMutex.Row(42),
|
||||
))
|
||||
require.NoErrorf(err, "BatchQuery")
|
||||
require.NoErrorf(t, err, "BatchQuery")
|
||||
|
||||
target1 := []uint64(nil)
|
||||
target42 := []uint64{100}
|
||||
require.Equalf(target1, resp.Results()[0].Row().Columns, "Row Results[0] Columns")
|
||||
require.Equalf(target42, resp.Results()[1].Row().Columns, "Row Results[1] Columns")
|
||||
require.Equalf(t, target1, resp.Results()[0].Row().Columns, "Row Results[0] Columns")
|
||||
require.Equalf(t, target42, resp.Results()[1].Row().Columns, "Row Results[1] Columns")
|
||||
})
|
||||
|
||||
t.Run("SetBoolField", func(t *testing.T) {
|
||||
setup(t, require, cli)
|
||||
defer tearDown(t, require, cli)
|
||||
setup(t, cli)
|
||||
defer tearDown(t, cli)
|
||||
|
||||
testFieldBool := testIndex.Field("test-field-bool", OptFieldTypeBool())
|
||||
err := cli.EnsureField(testFieldBool)
|
||||
require.NoError(err)
|
||||
require.NoError(t, err)
|
||||
|
||||
// can set bool
|
||||
_, err = cli.Query(testFieldBool.Set(true, 100))
|
||||
require.NoErrorf(err, "Set(true, 100)")
|
||||
require.NoErrorf(t, err, "Set(true, 100)")
|
||||
|
||||
resp, err := cli.Query(testFieldBool.Row(true))
|
||||
require.NoErrorf(err, "Row(true)")
|
||||
require.NoErrorf(t, err, "Row(true)")
|
||||
|
||||
target := []uint64{100}
|
||||
require.Equalf(target, resp.Result().Row().Columns, "Row Result Columns")
|
||||
require.Equalf(t, target, resp.Result().Row().Columns, "Row Result Columns")
|
||||
})
|
||||
|
||||
t.Run("ClearRowQuery", func(t *testing.T) {
|
||||
setup(t, require, cli)
|
||||
defer tearDown(t, require, cli)
|
||||
setup(t, cli)
|
||||
defer tearDown(t, cli)
|
||||
|
||||
testFieldClear := testIndex.Field("test-field-clear")
|
||||
err := cli.EnsureField(testFieldClear)
|
||||
require.NoError(err)
|
||||
require.NoError(t, err)
|
||||
|
||||
_, err = cli.Query(testIndex.BatchQuery(
|
||||
testFieldClear.Set(1, 100),
|
||||
testFieldClear.Set(1, 200),
|
||||
))
|
||||
require.NoErrorf(err, "Set(1, 100) Set(1, 200)")
|
||||
require.NoErrorf(t, err, "Set(1, 100) Set(1, 200)")
|
||||
|
||||
resp, err := cli.Query(testFieldClear.Row(1))
|
||||
require.NoErrorf(err, "Row(1)")
|
||||
require.NoErrorf(t, err, "Row(1)")
|
||||
|
||||
target := []uint64{100, 200}
|
||||
require.Equalf(target, resp.Result().Row().Columns, "Row Result Columns")
|
||||
require.Equalf(t, target, resp.Result().Row().Columns, "Row Result Columns")
|
||||
|
||||
_, err = cli.Query(testFieldClear.ClearRow(1))
|
||||
require.NoErrorf(err, "ClearRow(1)")
|
||||
require.NoErrorf(t, err, "ClearRow(1)")
|
||||
|
||||
resp, err = cli.Query(testFieldClear.Row(1))
|
||||
require.NoErrorf(err, "Row(1)")
|
||||
require.NoErrorf(t, err, "Row(1)")
|
||||
|
||||
target = []uint64(nil)
|
||||
require.Equalf(target, resp.Result().Row().Columns, "Row Result Columns")
|
||||
require.Equalf(t, target, resp.Result().Row().Columns, "Row Result Columns")
|
||||
})
|
||||
|
||||
t.Run("RowsQuery", func(t *testing.T) {
|
||||
setup(t, require, cli)
|
||||
defer tearDown(t, require, cli)
|
||||
setup(t, cli)
|
||||
defer tearDown(t, cli)
|
||||
|
||||
testFieldRows := testIndex.Field("test-field-rows")
|
||||
err := cli.EnsureField(testFieldRows)
|
||||
require.NoError(err)
|
||||
require.NoError(t, err)
|
||||
|
||||
_, err = cli.Query(testIndex.BatchQuery(
|
||||
testFieldRows.Set(1, 100),
|
||||
testFieldRows.Set(1, 200),
|
||||
testFieldRows.Set(2, 200),
|
||||
))
|
||||
require.NoErrorf(err, "Set(1, 100) Set(1, 200) Set(2, 200)")
|
||||
require.NoErrorf(t, err, "Set(1, 100) Set(1, 200) Set(2, 200)")
|
||||
|
||||
resp, err := cli.Query(testFieldRows.Rows())
|
||||
require.NoErrorf(err, "Rows")
|
||||
require.NoErrorf(t, err, "Rows")
|
||||
|
||||
target := RowIdentifiersResult{
|
||||
IDs: []uint64{1, 2},
|
||||
}
|
||||
require.Equalf(target, resp.Result().RowIdentifiers(), "RowIdentifiers Result")
|
||||
require.Equalf(t, target, resp.Result().RowIdentifiers(), "RowIdentifiers Result")
|
||||
})
|
||||
|
||||
t.Run("UnionRowsQuery", func(t *testing.T) {
|
||||
setup(t, require, cli)
|
||||
defer tearDown(t, require, cli)
|
||||
setup(t, cli)
|
||||
defer tearDown(t, cli)
|
||||
|
||||
testFieldRows := testIndex.Field("test-field-rows")
|
||||
err := cli.EnsureField(testFieldRows)
|
||||
require.NoError(err)
|
||||
require.NoError(t, err)
|
||||
|
||||
_, err = cli.Query(testIndex.BatchQuery(
|
||||
testFieldRows.Set(1, 100),
|
||||
testFieldRows.Set(1, 200),
|
||||
testFieldRows.Set(2, 200),
|
||||
))
|
||||
require.NoErrorf(err, "Set(1, 100) Set(1, 200) Set(2, 200)")
|
||||
require.NoErrorf(t, err, "Set(1, 100) Set(1, 200) Set(2, 200)")
|
||||
|
||||
resp, err := cli.Query(testFieldRows.Rows().Union())
|
||||
require.NoErrorf(err, "Rows Union")
|
||||
require.NoErrorf(t, err, "Rows Union")
|
||||
|
||||
target := []uint64{100, 200}
|
||||
require.Equalf(target, resp.Result().Row().Columns, "Row Result Columns")
|
||||
require.Equalf(t, target, resp.Result().Row().Columns, "Row Result Columns")
|
||||
})
|
||||
|
||||
t.Run("LikeQuery", func(t *testing.T) {
|
||||
setup(t, require, cli)
|
||||
defer tearDown(t, require, cli)
|
||||
setup(t, cli)
|
||||
defer tearDown(t, cli)
|
||||
|
||||
testFieldLike := testIndex.Field("test-field-like", OptFieldKeys(true))
|
||||
err := cli.EnsureField(testFieldLike)
|
||||
require.NoError(err)
|
||||
require.NoError(t, err)
|
||||
|
||||
_, err = cli.Query(testIndex.BatchQuery(
|
||||
testFieldLike.Set("a", 100),
|
||||
testFieldLike.Set("b", 200),
|
||||
testFieldLike.Set("bc", 200),
|
||||
))
|
||||
require.NoErrorf(err, "Set(a, 100) Set(b, 200) Set(bc, 200)")
|
||||
require.NoErrorf(t, err, "Set(a, 100) Set(b, 200) Set(bc, 200)")
|
||||
|
||||
resp, err := cli.Query(testFieldLike.Like("b%"))
|
||||
require.NoErrorf(err, `Like(b%)`)
|
||||
require.NoErrorf(t, err, `Like(b%)`)
|
||||
|
||||
target := RowIdentifiersResult{
|
||||
Keys: []string{"b", "bc"},
|
||||
}
|
||||
require.Equalf(target, resp.Result().RowIdentifiers(), "RowIdentifiers Result")
|
||||
require.Equalf(t, target, resp.Result().RowIdentifiers(), "RowIdentifiers Result")
|
||||
})
|
||||
|
||||
t.Run("GroupByQuery", func(t *testing.T) {
|
||||
setup(t, require, cli)
|
||||
defer tearDown(t, require, cli)
|
||||
setup(t, cli)
|
||||
defer tearDown(t, cli)
|
||||
|
||||
testFieldGroupBy := testIndex.Field("test-field-group-by")
|
||||
err := cli.EnsureField(testFieldGroupBy)
|
||||
require.NoError(err)
|
||||
require.NoError(t, err)
|
||||
|
||||
_, err = cli.Query(testIndex.BatchQuery(
|
||||
testFieldGroupBy.Set(1, 100),
|
||||
testFieldGroupBy.Set(1, 200),
|
||||
testFieldGroupBy.Set(2, 200),
|
||||
))
|
||||
require.NoErrorf(err, "Set(1, 100) Set(1, 200) Set(2, 200)")
|
||||
require.NoErrorf(t, err, "Set(1, 100) Set(1, 200) Set(2, 200)")
|
||||
|
||||
resp, err := cli.Query(testIndex.GroupBy(testFieldGroupBy.Rows()))
|
||||
require.NoErrorf(err, `Like(b%)`)
|
||||
require.NoErrorf(t, err, `Like(b%)`)
|
||||
|
||||
target := []GroupCount{
|
||||
{Groups: []FieldRow{{FieldName: "test-field-group-by", RowID: 1}}, Count: 2},
|
||||
{Groups: []FieldRow{{FieldName: "test-field-group-by", RowID: 2}}, Count: 1},
|
||||
}
|
||||
|
||||
assertGroupBy(t, require, target, resp.Result().GroupCounts())
|
||||
assertGroupBy(t, target, resp.Result().GroupCounts())
|
||||
})
|
||||
|
||||
t.Run("GroupByQuery", func(t *testing.T) {
|
||||
setup(t, require, cli)
|
||||
defer tearDown(t, require, cli)
|
||||
setup(t, cli)
|
||||
defer tearDown(t, cli)
|
||||
|
||||
testFieldGroupBy := testIndex.Field("test-field-group-by-int", OptFieldTypeInt(-10, 10))
|
||||
err := cli.EnsureField(testFieldGroupBy)
|
||||
require.NoError(err)
|
||||
require.NoError(t, err)
|
||||
|
||||
_, err = cli.Query(testIndex.RawQuery(`
|
||||
Set(0, test-field-group-by-int=1)
|
||||
|
|
@ -462,10 +460,10 @@ func TestClientAgainstCluster(t *testing.T) {
|
|||
Set(10000, test-field-group-by-int=0)
|
||||
Set(100000, test-field-group-by-int=0)
|
||||
`))
|
||||
require.NoError(err, "Set(0..100000)")
|
||||
require.NoError(t, err, "Set(0..100000)")
|
||||
|
||||
resp, err := cli.Query(testIndex.GroupBy(testFieldGroupBy.Rows()))
|
||||
require.NoErrorf(err, `GroupBy(Rows)`)
|
||||
require.NoErrorf(t, err, `GroupBy(Rows)`)
|
||||
|
||||
var a, b, c, d, e, f int64 = -2, -1, 0, 1, 2, 4
|
||||
target := []GroupCount{
|
||||
|
|
@ -476,7 +474,7 @@ func TestClientAgainstCluster(t *testing.T) {
|
|||
{Groups: []FieldRow{{FieldName: "test-field-group-by-int", Value: &e}}, Count: 1},
|
||||
{Groups: []FieldRow{{FieldName: "test-field-group-by-int", Value: &f}}, Count: 1},
|
||||
}
|
||||
assertGroupBy(t, require, target, resp.Result().GroupCounts())
|
||||
assertGroupBy(t, target, resp.Result().GroupCounts())
|
||||
})
|
||||
|
||||
t.Run("CreateDeleteIndexField", func(t *testing.T) {
|
||||
|
|
@ -484,56 +482,56 @@ func TestClientAgainstCluster(t *testing.T) {
|
|||
tmpField := tmpIndex.Field("tmp-field")
|
||||
|
||||
err := cli.CreateIndex(tmpIndex)
|
||||
require.NoError(err)
|
||||
require.NoError(t, err)
|
||||
|
||||
err = cli.CreateField(tmpField)
|
||||
require.NoError(err)
|
||||
require.NoError(t, err)
|
||||
|
||||
err = cli.DeleteField(tmpField)
|
||||
require.NoError(err)
|
||||
require.NoError(t, err)
|
||||
|
||||
err = cli.DeleteIndex(tmpIndex)
|
||||
require.NoError(err)
|
||||
require.NoError(t, err)
|
||||
})
|
||||
|
||||
t.Run("ErrorCreatingIndexField", func(t *testing.T) {
|
||||
setup(t, require, cli)
|
||||
defer tearDown(t, require, cli)
|
||||
setup(t, cli)
|
||||
defer tearDown(t, cli)
|
||||
|
||||
require.ErrorIs(cli.CreateIndex(testIndex), ErrIndexExists)
|
||||
require.ErrorIs(cli.CreateField(testField), ErrFieldExists)
|
||||
require.ErrorIs(t, cli.CreateIndex(testIndex), ErrIndexExists)
|
||||
require.ErrorIs(t, cli.CreateField(testField), ErrFieldExists)
|
||||
})
|
||||
|
||||
t.Run("Failover", func(t *testing.T) {
|
||||
setup(t, require, cli)
|
||||
defer tearDown(t, require, cli)
|
||||
setup(t, cli)
|
||||
defer tearDown(t, cli)
|
||||
|
||||
uri, _ := pnet.NewURIFromAddress("does-not-resolve.foo.bar")
|
||||
tmpcli, _ := NewClient(NewClusterWithHost(uri, uri, uri, uri), OptClientRetries(0))
|
||||
|
||||
_, err := tmpcli.Query(testIndex.All())
|
||||
require.Error(err, ErrTriedMaxHosts)
|
||||
require.Error(t, err, ErrTriedMaxHosts)
|
||||
})
|
||||
|
||||
t.Run("InvalidQuery", func(t *testing.T) {
|
||||
setup(t, require, cli)
|
||||
defer tearDown(t, require, cli)
|
||||
setup(t, cli)
|
||||
defer tearDown(t, cli)
|
||||
|
||||
_, _, err := cli.HTTPRequest("INVALID METHOD", "/foo", nil, nil)
|
||||
require.Error(err)
|
||||
require.Error(t, err)
|
||||
|
||||
_, err = cli.Query(testIndex.RawQuery("Invalid query"))
|
||||
require.Error(err)
|
||||
require.Error(t, err)
|
||||
})
|
||||
|
||||
t.Run("Sync", func(t *testing.T) {
|
||||
testIndexRemote := NewIndex("test-index-remote")
|
||||
err := cli.EnsureIndex(testIndexRemote)
|
||||
require.NoError(err)
|
||||
require.NoError(t, err)
|
||||
|
||||
testFieldRemote := testIndexRemote.Field("test-field-remote")
|
||||
err = cli.EnsureField(testFieldRemote)
|
||||
require.NoError(err)
|
||||
require.NoError(t, err)
|
||||
|
||||
schema := NewSchema()
|
||||
idx1 := schema.Index("index-1")
|
||||
|
|
@ -545,54 +543,54 @@ func TestClientAgainstCluster(t *testing.T) {
|
|||
schema.Index(testIndexRemote.Name())
|
||||
|
||||
err = cli.SyncSchema(schema)
|
||||
require.NoError(err)
|
||||
require.NoError(t, err)
|
||||
|
||||
err = cli.DeleteIndex(testIndexRemote)
|
||||
require.NoError(err)
|
||||
require.NoError(t, err)
|
||||
|
||||
err = cli.DeleteIndex(idx1)
|
||||
require.NoError(err)
|
||||
require.NoError(t, err)
|
||||
|
||||
err = cli.DeleteIndex(idx2)
|
||||
require.NoError(err)
|
||||
require.NoError(t, err)
|
||||
})
|
||||
|
||||
t.Run("FetchFragmentNodes", func(t *testing.T) {
|
||||
setup(t, require, cli)
|
||||
defer tearDown(t, require, cli)
|
||||
setup(t, cli)
|
||||
defer tearDown(t, cli)
|
||||
|
||||
nodes, err := cli.fetchFragmentNodes(testIndex.Name(), 0)
|
||||
require.NoErrorf(err, "fetchFragmentNodes(%s, 0)", testIndex.name)
|
||||
require.Equalf(replicaN, len(nodes), "len(nodes)")
|
||||
require.NoErrorf(t, err, "fetchFragmentNodes(%s, 0)", testIndex.name)
|
||||
require.Equalf(t, replicaN, len(nodes), "len(nodes)")
|
||||
|
||||
// running the same for coverage
|
||||
nodes, err = cli.fetchFragmentNodes(testIndex.Name(), 0)
|
||||
require.NoErrorf(err, "fetchFragmentNodes(%s, 0)", testIndex.name)
|
||||
require.Equalf(replicaN, len(nodes), "len(nodes)")
|
||||
require.NoErrorf(t, err, "fetchFragmentNodes(%s, 0)", testIndex.name)
|
||||
require.Equalf(t, replicaN, len(nodes), "len(nodes)")
|
||||
})
|
||||
|
||||
t.Run("RowRangeQuery", func(t *testing.T) {
|
||||
setup(t, require, cli)
|
||||
defer tearDown(t, require, cli)
|
||||
setup(t, cli)
|
||||
defer tearDown(t, cli)
|
||||
|
||||
testFieldRange := testIndex.Field("test-field-range", OptFieldTypeTime(TimeQuantumMonthDayHour))
|
||||
err := cli.EnsureField(testFieldRange)
|
||||
require.NoError(err)
|
||||
require.NoError(t, err)
|
||||
|
||||
_, err = cli.Query(testIndex.BatchQuery(
|
||||
testFieldRange.SetTimestamp(10, 100, time.Date(2017, time.January, 1, 0, 0, 0, 0, time.UTC)),
|
||||
testFieldRange.SetTimestamp(10, 100, time.Date(2018, time.January, 1, 0, 0, 0, 0, time.UTC)),
|
||||
testFieldRange.SetTimestamp(10, 100, time.Date(2019, time.January, 1, 0, 0, 0, 0, time.UTC)),
|
||||
))
|
||||
require.NoErrorf(err, "BatchQuery SetTimestamp")
|
||||
require.NoErrorf(t, err, "BatchQuery SetTimestamp")
|
||||
|
||||
start := time.Date(2017, time.January, 5, 0, 0, 0, 0, time.UTC)
|
||||
end := time.Date(2018, time.January, 5, 0, 0, 0, 0, time.UTC)
|
||||
resp, err := cli.Query(testFieldRange.RowRange(10, start, end))
|
||||
require.NoErrorf(err, "RowRange(10, %v, %v)", start, end)
|
||||
require.NoErrorf(t, err, "RowRange(10, %v, %v)", start, end)
|
||||
|
||||
target := []uint64{100}
|
||||
require.Equalf(target, resp.Result().Row().Columns, "Row Result Columns")
|
||||
require.Equalf(t, target, resp.Result().Row().Columns, "Row Result Columns")
|
||||
})
|
||||
|
||||
t.Run("StoreQuery", func(t *testing.T) {
|
||||
|
|
@ -601,11 +599,11 @@ func TestClientAgainstCluster(t *testing.T) {
|
|||
testFieldFrom := testIndexStore.Field("test-field-from")
|
||||
testFieldTo := testIndexStore.Field("test-field-to")
|
||||
err := cli.SyncSchema(schema)
|
||||
require.NoError(err)
|
||||
require.NoError(t, err)
|
||||
|
||||
defer func() {
|
||||
cerr := cli.DeleteIndex(testIndexStore)
|
||||
require.NoErrorf(cerr, "failed to delete index: %v", testIndexStore.name)
|
||||
require.NoErrorf(t, cerr, "failed to delete index: %v", testIndexStore.name)
|
||||
}()
|
||||
|
||||
_, err = cli.Query(testIndexStore.BatchQuery(
|
||||
|
|
@ -613,22 +611,22 @@ func TestClientAgainstCluster(t *testing.T) {
|
|||
testFieldFrom.Set(10, 200),
|
||||
testFieldTo.Store(testFieldFrom.Row(10), 1),
|
||||
))
|
||||
require.NoErrorf(err, "Set(10, 100) Set(10, 200) Store(Row(10), 1)")
|
||||
require.NoErrorf(t, err, "Set(10, 100) Set(10, 200) Store(Row(10), 1)")
|
||||
|
||||
resp, err := cli.Query(testFieldTo.Row(1))
|
||||
require.NoErrorf(err, "Row(1)")
|
||||
require.NoErrorf(t, err, "Row(1)")
|
||||
|
||||
target := []uint64{100, 200}
|
||||
require.Equalf(target, resp.Result().Row().Columns, "Row Result Columns")
|
||||
require.Equalf(t, target, resp.Result().Row().Columns, "Row Result Columns")
|
||||
})
|
||||
|
||||
t.Run("MultipleClientKeyQuery", func(t *testing.T) {
|
||||
setup(t, require, cli)
|
||||
defer tearDown(t, require, cli)
|
||||
setup(t, cli)
|
||||
defer tearDown(t, cli)
|
||||
|
||||
testFieldMultiClient := testIndexWithKeys.Field("test-field-multiclient")
|
||||
err := cli.EnsureField(testFieldMultiClient)
|
||||
require.NoError(err)
|
||||
require.NoError(t, err)
|
||||
|
||||
eg := &errgroup.Group{}
|
||||
for i := 0; i < 10; i++ {
|
||||
|
|
@ -638,129 +636,129 @@ func TestClientAgainstCluster(t *testing.T) {
|
|||
return e
|
||||
})
|
||||
}
|
||||
require.NoError(eg.Wait())
|
||||
require.NoError(t, eg.Wait())
|
||||
})
|
||||
|
||||
t.Run("ExportRowIDColumnID", func(t *testing.T) {
|
||||
setup(t, require, cli)
|
||||
defer tearDown(t, require, cli)
|
||||
setup(t, cli)
|
||||
defer tearDown(t, cli)
|
||||
|
||||
testFieldExport := testIndex.Field("test-field-export")
|
||||
err := cli.EnsureField(testFieldExport)
|
||||
require.NoError(err)
|
||||
require.NoError(t, err)
|
||||
|
||||
_, err = cli.Query(testIndex.BatchQuery(
|
||||
testFieldExport.Set(1, 1),
|
||||
testFieldExport.Set(1, 10),
|
||||
testFieldExport.Set(2, 1048577),
|
||||
), nil)
|
||||
require.NoErrorf(err, "Set(1, 1) Set(1, 10) Set(2, 1048577)")
|
||||
require.NoErrorf(t, err, "Set(1, 1) Set(1, 10) Set(2, 1048577)")
|
||||
|
||||
r, err := cli.ExportField(testFieldExport)
|
||||
require.NoErrorf(err, "ExportField")
|
||||
require.NoErrorf(t, err, "ExportField")
|
||||
|
||||
b, err := ioutil.ReadAll(r)
|
||||
require.NoError(err)
|
||||
require.NoError(t, err)
|
||||
|
||||
target := "1,1\n1,10\n2,1048577\n"
|
||||
require.Equalf(target, string(b), "Export Field Response")
|
||||
require.Equalf(t, target, string(b), "Export Field Response")
|
||||
})
|
||||
|
||||
t.Run("ExportRowIDColumnKey", func(t *testing.T) {
|
||||
setup(t, require, cli)
|
||||
defer tearDown(t, require, cli)
|
||||
setup(t, cli)
|
||||
defer tearDown(t, cli)
|
||||
|
||||
testFieldExport := testIndexWithKeys.Field("test-field-export")
|
||||
err := cli.EnsureField(testFieldExport)
|
||||
require.NoError(err)
|
||||
require.NoError(t, err)
|
||||
|
||||
_, err = cli.Query(testIndexWithKeys.BatchQuery(
|
||||
testFieldExport.Set(1, "one"),
|
||||
testFieldExport.Set(1, "ten"),
|
||||
testFieldExport.Set(2, "big-number"),
|
||||
), nil)
|
||||
require.NoErrorf(err, "Set(1, one) Set(1, ten) Set(2, big-number)")
|
||||
require.NoErrorf(t, err, "Set(1, one) Set(1, ten) Set(2, big-number)")
|
||||
|
||||
r, err := cli.ExportField(testFieldExport)
|
||||
require.NoErrorf(err, "ExportField")
|
||||
require.NoErrorf(t, err, "ExportField")
|
||||
|
||||
b, err := ioutil.ReadAll(r)
|
||||
require.NoError(err)
|
||||
require.NoError(t, err)
|
||||
|
||||
target := "1,one\n1,ten\n2,big-number\n"
|
||||
require.Equalf(target, string(b), "Export Field Response")
|
||||
require.Equalf(t, target, string(b), "Export Field Response")
|
||||
})
|
||||
|
||||
t.Run("TranslateRowKeys", func(t *testing.T) {
|
||||
setup(t, require, cli)
|
||||
defer tearDown(t, require, cli)
|
||||
setup(t, cli)
|
||||
defer tearDown(t, cli)
|
||||
|
||||
testFieldTranslate := testIndexKeyTranslation.Field("test-field-translate", OptFieldKeys(true))
|
||||
err := cli.EnsureField(testFieldTranslate)
|
||||
require.NoError(err)
|
||||
require.NoError(t, err)
|
||||
|
||||
trans, err := cli.CreateFieldKeys(testFieldTranslate, "key1", "key2")
|
||||
require.NoErrorf(err, "CreateFieldKeys")
|
||||
require.NoErrorf(t, err, "CreateFieldKeys")
|
||||
|
||||
target := map[string]uint64{"key1": 1, "key2": 2}
|
||||
require.Equalf(target, trans, "CreateFieldKeys")
|
||||
require.Equalf(t, target, trans, "CreateFieldKeys")
|
||||
|
||||
trans, err = cli.FindFieldKeys(testFieldTranslate, "key1", "key2", "key3")
|
||||
require.NoErrorf(err, "FindFieldKeys")
|
||||
require.NoErrorf(t, err, "FindFieldKeys")
|
||||
|
||||
require.Equalf(target, trans, "FindFieldKeys")
|
||||
require.Equalf(t, target, trans, "FindFieldKeys")
|
||||
})
|
||||
|
||||
t.Run("TranslateColKeys", func(t *testing.T) {
|
||||
setup(t, require, cli)
|
||||
defer tearDown(t, require, cli)
|
||||
setup(t, cli)
|
||||
defer tearDown(t, cli)
|
||||
|
||||
trans, err := cli.CreateIndexKeys(testIndexKeyTranslation, "key1", "key2")
|
||||
require.NoErrorf(err, "CreateIndexKeys")
|
||||
require.NoErrorf(t, err, "CreateIndexKeys")
|
||||
|
||||
target := map[string]uint64{"key1": 65011713, "key2": 63963137}
|
||||
require.Equalf(target, trans, "CreateIndexKeys")
|
||||
require.Equalf(t, target, trans, "CreateIndexKeys")
|
||||
|
||||
trans, err = cli.FindIndexKeys(testIndexKeyTranslation, "key1", "key2", "key3")
|
||||
require.NoErrorf(err, "FindIndexKeys")
|
||||
require.NoErrorf(t, err, "FindIndexKeys")
|
||||
|
||||
require.Equalf(target, trans, "FindIndexKeys")
|
||||
require.Equalf(t, target, trans, "FindIndexKeys")
|
||||
})
|
||||
|
||||
t.Run("Transactions", func(t *testing.T) {
|
||||
trns, err := cli.StartTransaction("blah", time.Minute, false, time.Minute)
|
||||
require.NoErrorf(err, "StartTransaction(blah)")
|
||||
require.Equalf("blah", trns.ID, "TranslateColumnKeys ID")
|
||||
require.Equalf(time.Minute, trns.Timeout, "TranslateColumnKeys Timeout")
|
||||
require.Truef(trns.Active, "TranslateColumnKeys Active")
|
||||
require.NoErrorf(t, err, "StartTransaction(blah)")
|
||||
require.Equalf(t, "blah", trns.ID, "TranslateColumnKeys ID")
|
||||
require.Equalf(t, time.Minute, trns.Timeout, "TranslateColumnKeys Timeout")
|
||||
require.Truef(t, trns.Active, "TranslateColumnKeys Active")
|
||||
|
||||
trnsMap, err := cli.Transactions()
|
||||
require.NoErrorf(err, "Transactions")
|
||||
require.Equalf(1, len(trnsMap), "Transactions len")
|
||||
require.Truef(trnsMap["blah"].Active, "Transactions Active")
|
||||
require.NoErrorf(t, err, "Transactions")
|
||||
require.Equalf(t, 1, len(trnsMap), "Transactions len")
|
||||
require.Truef(t, trnsMap["blah"].Active, "Transactions Active")
|
||||
|
||||
trns, err = cli.GetTransaction("blah")
|
||||
require.NoErrorf(err, "GetTransaction(blah)")
|
||||
require.Equalf("blah", trns.ID, "TranslateColumnKeys ID")
|
||||
require.Equalf(time.Minute, trns.Timeout, "TranslateColumnKeys Timeout")
|
||||
require.Truef(trns.Active, "TranslateColumnKeys Active")
|
||||
require.NoErrorf(t, err, "GetTransaction(blah)")
|
||||
require.Equalf(t, "blah", trns.ID, "TranslateColumnKeys ID")
|
||||
require.Equalf(t, time.Minute, trns.Timeout, "TranslateColumnKeys Timeout")
|
||||
require.Truef(t, trns.Active, "TranslateColumnKeys Active")
|
||||
|
||||
trns, err = cli.FinishTransaction("blah")
|
||||
require.NoErrorf(err, "FinishTransaction(blah)")
|
||||
require.Equalf("blah", trns.ID, "TranslateColumnKeys ID")
|
||||
require.Equalf(time.Minute, trns.Timeout, "TranslateColumnKeys Timeout")
|
||||
require.Truef(trns.Active, "TranslateColumnKeys Active")
|
||||
require.NoErrorf(t, err, "FinishTransaction(blah)")
|
||||
require.Equalf(t, "blah", trns.ID, "TranslateColumnKeys ID")
|
||||
require.Equalf(t, time.Minute, trns.Timeout, "TranslateColumnKeys Timeout")
|
||||
require.Truef(t, trns.Active, "TranslateColumnKeys Active")
|
||||
})
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func assertGroupBy(t *testing.T, r *require.Assertions, expected, results []GroupCount) {
|
||||
func assertGroupBy(t *testing.T, expected, results []GroupCount) {
|
||||
t.Helper()
|
||||
|
||||
r.Equalf(len(expected), len(results), "number of groupings mismatch")
|
||||
require.Equalf(t, len(expected), len(results), "number of groupings mismatch")
|
||||
|
||||
for i, result := range results {
|
||||
r.Equalf(expected[i], result, "unexpected result at %d", i)
|
||||
require.Equalf(t, expected[i], result, "unexpected result at %d", i)
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue