From 39337fa41b594691576256e265954aba3b86aa4d Mon Sep 17 00:00:00 2001 From: Nia Weiss Date: Mon, 7 Jun 2021 11:47:56 -0400 Subject: [PATCH] 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. --- client/client_it_test.go | 396 +++++++++++++++++++-------------------- 1 file changed, 197 insertions(+), 199 deletions(-) diff --git a/client/client_it_test.go b/client/client_it_test.go index fb3008cda..d0c2b9fac 100644 --- a/client/client_it_test.go +++ b/client/client_it_test.go @@ -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) } }