mirror of
https://github.com/featurebasedb/featurebase.git
synced 2026-08-28 10:54:59 +00:00
remove the last usages of test.NewExecutor and cleanup unused in test package
This commit is contained in:
Matt Jaffee
parent
96eae99d38
commit
95547a9a27
6 changed files with 31 additions and 254 deletions
|
|
@ -1307,9 +1307,9 @@ func TestExecutor_SetColumnAttrs_ExcludeField(t *testing.T) {
|
|||
}
|
||||
|
||||
func TestExecutor_Time_Clear_Quantums(t *testing.T) {
|
||||
hldr := test.MustOpenHolder()
|
||||
defer hldr.Close()
|
||||
e := test.NewExecutor(hldr.Holder, pilosa.NewTestCluster(1))
|
||||
c := test.MustRunCluster(t, 1)
|
||||
defer c.Close()
|
||||
hldr := test.Holder{Holder: c[0].Server.Holder()}
|
||||
|
||||
var rangeTests = []struct {
|
||||
quantum pilosa.TimeQuantum
|
||||
|
|
@ -1326,7 +1326,7 @@ func TestExecutor_Time_Clear_Quantums(t *testing.T) {
|
|||
{quantum: "MDH", expected: []uint64{3, 4, 5, 6, 7}},
|
||||
{quantum: "DH", expected: []uint64{3, 4, 5, 6, 7}},
|
||||
}
|
||||
populateBatch := test.MustParse(`
|
||||
populateBatch := `
|
||||
Set(2, f=1, 1999-12-31T00:00)
|
||||
Set(3, f=1, 2000-01-01T00:00)
|
||||
Set(4, f=1, 2000-01-02T00:00)
|
||||
|
|
@ -1336,9 +1336,9 @@ func TestExecutor_Time_Clear_Quantums(t *testing.T) {
|
|||
Set(2, f=1, 1999-12-30T00:00)
|
||||
Set(2, f=1, 2002-02-01T00:00)
|
||||
Set(2, f=10, 2001-01-01T00:00)
|
||||
`)
|
||||
clearColumn := test.MustParse(`Clear( 2, f=1)`)
|
||||
rangeCheckQuery := test.MustParse(`Range(f=1, 1999-12-31T00:00, 2002-01-01T03:00)`)
|
||||
`
|
||||
clearColumn := `Clear( 2, f=1)`
|
||||
rangeCheckQuery := `Range(f=1, 1999-12-31T00:00, 2002-01-01T03:00)`
|
||||
|
||||
for i, tt := range rangeTests {
|
||||
t.Run(fmt.Sprintf("#%d Quantum %s", i+1, tt.quantum), func(t *testing.T) {
|
||||
|
|
@ -1353,15 +1353,15 @@ func TestExecutor_Time_Clear_Quantums(t *testing.T) {
|
|||
t.Fatal(err)
|
||||
}
|
||||
// Populate
|
||||
if _, err := e.Execute(context.Background(), indexName, populateBatch, nil, nil); err != nil {
|
||||
if _, err := c[0].API.Query(context.Background(), &pilosa.QueryRequest{Index: indexName, Query: populateBatch}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, err := e.Execute(context.Background(), indexName, clearColumn, nil, nil); err != nil {
|
||||
if _, err := c[0].API.Query(context.Background(), &pilosa.QueryRequest{Index: indexName, Query: clearColumn}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if res, err := e.Execute(context.Background(), indexName, rangeCheckQuery, nil, nil); err != nil {
|
||||
if res, err := c[0].API.Query(context.Background(), &pilosa.QueryRequest{Index: indexName, Query: rangeCheckQuery}); err != nil {
|
||||
t.Fatal(err)
|
||||
} else if columns := res[0].(*pilosa.Row).Columns(); !reflect.DeepEqual(columns, tt.expected) {
|
||||
} else if columns := res.Results[0].(*pilosa.Row).Columns(); !reflect.DeepEqual(columns, tt.expected) {
|
||||
t.Fatalf("unexpected columns: %+v", columns)
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -86,8 +86,9 @@ func TestMultiStatClient_Expvar(t *testing.T) {
|
|||
}
|
||||
|
||||
func TestStatsCount_TopN(t *testing.T) {
|
||||
hldr := test.MustOpenHolder()
|
||||
defer hldr.Close()
|
||||
c := test.MustRunCluster(t, 1)
|
||||
defer c.Close()
|
||||
hldr := test.Holder{Holder: c[0].Server.Holder()}
|
||||
|
||||
hldr.SetBit("d", "f", 0, 0)
|
||||
hldr.SetBit("d", "f", 0, 1)
|
||||
|
|
@ -96,8 +97,7 @@ func TestStatsCount_TopN(t *testing.T) {
|
|||
|
||||
// Execute query.
|
||||
called := false
|
||||
e := test.NewExecutor(hldr.Holder, pilosa.NewTestCluster(1))
|
||||
e.Holder.Stats = &MockStats{
|
||||
hldr.Holder.Stats = &MockStats{
|
||||
mockCountWithTags: func(name string, value int64, rate float64, tags []string) {
|
||||
if name != "TopN" {
|
||||
t.Errorf("Expected TopN, Results %s", name)
|
||||
|
|
@ -110,7 +110,7 @@ func TestStatsCount_TopN(t *testing.T) {
|
|||
called = true
|
||||
},
|
||||
}
|
||||
if _, err := e.Execute(context.Background(), "d", test.MustParse(`TopN(field=f, n=2)`), nil, nil); err != nil {
|
||||
if _, err := c[0].API.Query(context.Background(), &pilosa.QueryRequest{Index: "d", Query: `TopN(field=f, n=2)`}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if !called {
|
||||
|
|
@ -119,14 +119,14 @@ func TestStatsCount_TopN(t *testing.T) {
|
|||
}
|
||||
|
||||
func TestStatsCount_Bitmap(t *testing.T) {
|
||||
hldr := test.MustOpenHolder()
|
||||
defer hldr.Close()
|
||||
c := test.MustRunCluster(t, 1)
|
||||
defer c.Close()
|
||||
hldr := test.Holder{Holder: c[0].Server.Holder()}
|
||||
|
||||
hldr.SetBit("d", "f", 0, 0)
|
||||
hldr.SetBit("d", "f", 0, 1)
|
||||
called := false
|
||||
e := test.NewExecutor(hldr.Holder, pilosa.NewTestCluster(1))
|
||||
e.Holder.Stats = &MockStats{
|
||||
hldr.Holder.Stats = &MockStats{
|
||||
mockCountWithTags: func(name string, value int64, rate float64, tags []string) {
|
||||
if name != "Row" {
|
||||
t.Errorf("Expected Row, Results %s", name)
|
||||
|
|
@ -139,7 +139,7 @@ func TestStatsCount_Bitmap(t *testing.T) {
|
|||
called = true
|
||||
},
|
||||
}
|
||||
if _, err := e.Execute(context.Background(), "d", test.MustParse(`Row(f=0)`), nil, nil); err != nil {
|
||||
if _, err := c[0].API.Query(context.Background(), &pilosa.QueryRequest{Index: "d", Query: `Row(f=0)`}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if !called {
|
||||
|
|
@ -148,15 +148,15 @@ func TestStatsCount_Bitmap(t *testing.T) {
|
|||
}
|
||||
|
||||
func TestStatsCount_SetColumnAttrs(t *testing.T) {
|
||||
hldr := test.MustOpenHolder()
|
||||
defer hldr.Close()
|
||||
c := test.MustRunCluster(t, 1)
|
||||
defer c.Close()
|
||||
hldr := test.Holder{Holder: c[0].Server.Holder()}
|
||||
|
||||
hldr.SetBit("d", "f", 10, 0)
|
||||
hldr.SetBit("d", "f", 10, 1)
|
||||
|
||||
called := false
|
||||
e := test.NewExecutor(hldr.Holder, pilosa.NewTestCluster(1))
|
||||
field := e.Holder.Field("d", "f")
|
||||
field := hldr.Field("d", "f")
|
||||
if field == nil {
|
||||
t.Fatal("field not found")
|
||||
}
|
||||
|
|
@ -169,7 +169,7 @@ func TestStatsCount_SetColumnAttrs(t *testing.T) {
|
|||
called = true
|
||||
},
|
||||
}
|
||||
if _, err := e.Execute(context.Background(), "d", test.MustParse(`SetRowAttrs(f, 10, foo="bar")`), nil, nil); err != nil {
|
||||
if _, err := c[0].API.Query(context.Background(), &pilosa.QueryRequest{Index: "d", Query: `SetRowAttrs(f, 10, foo="bar")`}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if !called {
|
||||
|
|
@ -178,15 +178,15 @@ func TestStatsCount_SetColumnAttrs(t *testing.T) {
|
|||
}
|
||||
|
||||
func TestStatsCount_SetProfileAttrs(t *testing.T) {
|
||||
hldr := test.MustOpenHolder()
|
||||
defer hldr.Close()
|
||||
c := test.MustRunCluster(t, 1)
|
||||
defer c.Close()
|
||||
hldr := test.Holder{Holder: c[0].Server.Holder()}
|
||||
|
||||
hldr.SetBit("d", "f", 10, 0)
|
||||
hldr.SetBit("d", "f", 10, 1)
|
||||
|
||||
called := false
|
||||
e := test.NewExecutor(hldr.Holder, pilosa.NewTestCluster(1))
|
||||
idx := e.Holder.Index("d")
|
||||
idx := hldr.Holder.Index("d")
|
||||
if idx == nil {
|
||||
t.Fatal("idex not found")
|
||||
}
|
||||
|
|
@ -200,7 +200,7 @@ func TestStatsCount_SetProfileAttrs(t *testing.T) {
|
|||
called = true
|
||||
},
|
||||
}
|
||||
if _, err := e.Execute(context.Background(), "d", test.MustParse(`SetColumnAttrs(10, foo="bar")`), nil, nil); err != nil {
|
||||
if _, err := c[0].API.Query(context.Background(), &pilosa.QueryRequest{Index: "d", Query: `SetColumnAttrs(10, foo="bar")`}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if !called {
|
||||
|
|
|
|||
|
|
@ -14,50 +14,7 @@
|
|||
|
||||
package test
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"io/ioutil"
|
||||
|
||||
"github.com/pilosa/pilosa"
|
||||
)
|
||||
|
||||
// modHasher represents a simple, mod-based hashing.
|
||||
type ModHasher struct{}
|
||||
|
||||
func (*ModHasher) Hash(key uint64, n int) int { return int(key) % n }
|
||||
|
||||
// NewCluster returns a cluster with n nodes and uses a mod-based hasher.
|
||||
func NewCluster(n int) *pilosa.Cluster {
|
||||
path, err := ioutil.TempDir("", "pilosa-cluster-")
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
|
||||
c := pilosa.NewCluster()
|
||||
c.ReplicaN = 1
|
||||
c.Hasher = &ModHasher{}
|
||||
c.Path = path
|
||||
c.Topology = pilosa.NewTopology()
|
||||
|
||||
for i := 0; i < n; i++ {
|
||||
c.Nodes = append(c.Nodes, &pilosa.Node{
|
||||
ID: fmt.Sprintf("node%d", i),
|
||||
URI: newURI("http", fmt.Sprintf("host%d", i), uint16(0)),
|
||||
})
|
||||
}
|
||||
|
||||
c.Node = c.Nodes[0]
|
||||
c.Coordinator = c.Nodes[0].ID
|
||||
c.SetState(pilosa.ClusterStateNormal)
|
||||
|
||||
return c
|
||||
}
|
||||
|
||||
// newURI is a test URI creator that intentionally swallows errors.
|
||||
func newURI(scheme, host string, port uint16) pilosa.URI {
|
||||
uri := pilosa.DefaultURI()
|
||||
uri.SetScheme(scheme)
|
||||
uri.SetHost(host)
|
||||
uri.SetPort(port)
|
||||
return *uri
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,58 +0,0 @@
|
|||
// Copyright 2017 Pilosa Corp.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
package test
|
||||
|
||||
import (
|
||||
gohttp "net/http"
|
||||
"strings"
|
||||
|
||||
"github.com/pilosa/pilosa"
|
||||
"github.com/pilosa/pilosa/http"
|
||||
"github.com/pilosa/pilosa/inmem"
|
||||
"github.com/pilosa/pilosa/pql"
|
||||
)
|
||||
|
||||
// Executor represents a test wrapper for pilosa.Executor.
|
||||
type Executor struct {
|
||||
*pilosa.Executor
|
||||
}
|
||||
|
||||
var remoteClient *gohttp.Client
|
||||
|
||||
func init() {
|
||||
remoteClient = http.GetHTTPClient(nil)
|
||||
}
|
||||
|
||||
// NewExecutor returns a new instance of Executor.
|
||||
// The executor always matches the uri of the first cluster node.
|
||||
func NewExecutor(holder *pilosa.Holder, cluster *pilosa.Cluster) *Executor {
|
||||
client := http.NewInternalClientFromURI(nil, remoteClient)
|
||||
executor := pilosa.NewExecutor(pilosa.OptExecutorInternalQueryClient(client))
|
||||
e := &Executor{Executor: executor}
|
||||
e.Holder = holder
|
||||
e.Cluster = cluster
|
||||
e.TranslateStore = inmem.NewTranslateStore()
|
||||
e.Node = cluster.Nodes[0]
|
||||
return e
|
||||
}
|
||||
|
||||
// MustParse parses s into a PQL query. Panic on error.
|
||||
func MustParse(s string) *pql.Query {
|
||||
q, err := pql.NewParser(strings.NewReader(s)).Parse()
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
return q
|
||||
}
|
||||
107
test/handler.go
107
test/handler.go
|
|
@ -15,109 +15,11 @@
|
|||
package test
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"io"
|
||||
"io/ioutil"
|
||||
gohttp "net/http"
|
||||
"net/http/httptest"
|
||||
"net/url"
|
||||
|
||||
"github.com/gogo/protobuf/proto"
|
||||
"github.com/pilosa/pilosa"
|
||||
"github.com/pilosa/pilosa/http"
|
||||
"github.com/pilosa/pilosa/internal"
|
||||
"github.com/pilosa/pilosa/pql"
|
||||
)
|
||||
|
||||
// Handler represents a test wrapper for pilosa.Handler.
|
||||
type Handler struct {
|
||||
*http.Handler
|
||||
Executor HandlerExecutor
|
||||
}
|
||||
|
||||
// HandlerExecutor is a mock implementing pilosa.Handler.Executor.
|
||||
type HandlerExecutor struct {
|
||||
cluster *pilosa.Cluster
|
||||
ExecuteFn func(ctx context.Context, index string, query *pql.Query, shards []uint64, opt *pilosa.ExecOptions) ([]interface{}, error)
|
||||
}
|
||||
|
||||
func (c *HandlerExecutor) Cluster() *pilosa.Cluster { return c.cluster }
|
||||
|
||||
func (c *HandlerExecutor) Execute(ctx context.Context, index string, query *pql.Query, shards []uint64, opt *pilosa.ExecOptions) ([]interface{}, error) {
|
||||
return c.ExecuteFn(ctx, index, query, shards, opt)
|
||||
}
|
||||
|
||||
// Server represents a test wrapper for httptest.Server.
|
||||
type Server struct {
|
||||
*httptest.Server
|
||||
Handler *Handler
|
||||
}
|
||||
|
||||
// NewServer returns a test server running on a random port.
|
||||
func NewServer() *Server {
|
||||
return &Server{}
|
||||
//handler, err := pilosa.NewHandler()
|
||||
//if err != nil {
|
||||
// panic(err)
|
||||
//}
|
||||
//s := &Server{
|
||||
// Handler: handler,
|
||||
//}
|
||||
//s.Server = httptest.NewServer(s.Handler.Handler)
|
||||
|
||||
//// Handler test messages can no-op.
|
||||
//s.Handler.API.Broadcaster = pilosa.NopBroadcaster
|
||||
//// Create a default cluster on the handler
|
||||
//s.Handler.API.Cluster = NewCluster(1)
|
||||
//s.Handler.API.Cluster.Nodes[0].URI = s.HostURI()
|
||||
|
||||
//return s
|
||||
}
|
||||
|
||||
// LocalStatus exists so that test.Server implements StatusHandler.
|
||||
func (s *Server) LocalStatus() (proto.Message, error) {
|
||||
return nil, nil
|
||||
}
|
||||
|
||||
// ClusterStatus exists so that test.Server implements StatusHandler.
|
||||
func (s *Server) ClusterStatus() (proto.Message, error) {
|
||||
id := "test-node"
|
||||
uri := pilosa.DefaultURI()
|
||||
node := &pilosa.Node{
|
||||
ID: id,
|
||||
URI: *uri,
|
||||
}
|
||||
return &internal.ClusterStatus{
|
||||
ClusterID: "",
|
||||
State: pilosa.ClusterStateNormal,
|
||||
Nodes: pilosa.EncodeNodes([]*pilosa.Node{node}),
|
||||
}, nil
|
||||
}
|
||||
|
||||
// HandleRemoteStatus just need to implement a nop to complete the Interface
|
||||
func (s *Server) HandleRemoteStatus(pb proto.Message) error { return nil }
|
||||
|
||||
// Host returns the hostname of the running server.
|
||||
func (s *Server) Host() string { return MustParseURLHost(s.URL) }
|
||||
|
||||
func (s *Server) HostURI() pilosa.URI {
|
||||
uri, err := pilosa.NewURIFromAddress(s.URL)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
return *uri
|
||||
}
|
||||
|
||||
// MustParseURLHost parses rawurl and returns the hostname. Panic on error.
|
||||
func MustParseURLHost(rawurl string) string {
|
||||
u, err := url.Parse(rawurl)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
return u.Host
|
||||
}
|
||||
|
||||
// MustNewHTTPRequest creates a new HTTP request. Panic on error.
|
||||
func MustNewHTTPRequest(method, urlStr string, body io.Reader) *gohttp.Request {
|
||||
req, err := gohttp.NewRequest(method, urlStr, body)
|
||||
|
|
@ -136,12 +38,3 @@ func MustMarshalJSON(v interface{}) []byte {
|
|||
}
|
||||
return buf
|
||||
}
|
||||
|
||||
// MustReadAll reads a reader into a buffer and returns it. Panic on error.
|
||||
func MustReadAll(r io.Reader) []byte {
|
||||
buf, err := ioutil.ReadAll(r)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
return buf
|
||||
}
|
||||
|
|
|
|||
15
test/test.go
15
test/test.go
|
|
@ -1,15 +0,0 @@
|
|||
// Copyright 2017 Pilosa Corp.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
package test
|
||||
Loading…
Add table
Reference in a new issue