func TestClient_Timeout(t *testing.T) { ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { time.Sleep(1 * time.Second) var data client.Response w.WriteHeader(http.StatusOK) _ = json.NewEncoder(w).Encode(data) })) defer ts.Close() u, _ := url.Parse(ts.URL) config := client.Config{URL: *u, Timeout: 500 * time.Millisecond} c, err := client.NewClient(config) if err != nil { t.Fatalf("unexpected error. expected %v, actual %v", nil, err) } query := client.Query{} _, err = c.Query(query) if err == nil { t.Fatalf("unexpected success. expected timeout error") } else if !strings.Contains(err.Error(), "use of closed network connection") { t.Fatalf("unexpected error. expected 'use of closed network connection' error, got %v", err) } confignotimeout := client.Config{URL: *u} cnotimeout, err := client.NewClient(confignotimeout) _, err = cnotimeout.Query(query) if err != nil { t.Fatalf("unexpected error. expected %v, actual %v", nil, err) } }
func TestNewClient(t *testing.T) { config := client.Config{} _, err := client.NewClient(config) if err != nil { t.Fatalf("unexpected error. expected %v, actual %v", nil, err) } }
func TestClient_BasicAuth(t *testing.T) { ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { u, p, ok := r.BasicAuth() if !ok { t.Errorf("basic auth error") } if u != "username" { t.Errorf("unexpected username, expected %q, actual %q", "username", u) } if p != "password" { t.Errorf("unexpected password, expected %q, actual %q", "password", p) } w.WriteHeader(http.StatusNoContent) })) defer ts.Close() u, _ := url.Parse(ts.URL) u.User = url.UserPassword("username", "password") config := client.Config{URL: *u, Username: "******", Password: "******"} c, err := client.NewClient(config) if err != nil { t.Fatalf("unexpected error. expected %v, actual %v", nil, err) } _, _, err = c.Ping() if err != nil { t.Fatalf("unexpected error. expected %v, actual %v", nil, err) } }
func ExampleClient_Ping() { host, err := url.Parse(fmt.Sprintf("http://%s:%d", "localhost", 8086)) if err != nil { log.Fatal(err) } con, err := client.NewClient(client.Config{URL: *host}) if err != nil { log.Fatal(err) } dur, ver, err := con.Ping() if err != nil { log.Fatal(err) } log.Printf("Happy as a hippo! %v, %s", dur, ver) }
func ExampleClient_Query() { host, err := url.Parse(fmt.Sprintf("http://%s:%d", "localhost", 8086)) if err != nil { log.Fatal(err) } con, err := client.NewClient(client.Config{URL: *host}) if err != nil { log.Fatal(err) } q := client.Query{ Command: "select count(value) from shapes", Database: "square_holes", } if response, err := con.Query(q); err == nil && response.Error() == nil { log.Println(response.Results) } }
func ExampleClient_Write() { host, err := url.Parse(fmt.Sprintf("http://%s:%d", "localhost", 8086)) if err != nil { log.Fatal(err) } con, err := client.NewClient(client.Config{URL: *host}) if err != nil { log.Fatal(err) } var ( shapes = []string{"circle", "rectangle", "square", "triangle"} colors = []string{"red", "blue", "green"} sampleSize = 1000 pts = make([]client.Point, sampleSize) ) rand.Seed(42) for i := 0; i < sampleSize; i++ { pts[i] = client.Point{ Measurement: "shapes", Tags: map[string]string{ "color": strconv.Itoa(rand.Intn(len(colors))), "shape": strconv.Itoa(rand.Intn(len(shapes))), }, Fields: map[string]interface{}{ "value": rand.Intn(sampleSize), }, Time: time.Now(), Precision: "s", } } bps := client.BatchPoints{ Points: pts, Database: "BumbeBeeTuna", RetentionPolicy: "default", } _, err = con.Write(bps) if err != nil { log.Fatal(err) } }
func ExampleNewClient() { host, err := url.Parse(fmt.Sprintf("http://%s:%d", "localhost", 8086)) if err != nil { log.Fatal(err) } // NOTE: this assumes you've setup a user and have setup shell env variables, // namely INFLUX_USER/INFLUX_PWD. If not just ommit Username/Password below. conf := client.Config{ URL: *host, Username: os.Getenv("INFLUX_USER"), Password: os.Getenv("INFLUX_PWD"), } con, err := client.NewClient(conf) if err != nil { log.Fatal(err) } log.Println("Connection", con) }
func TestClient_Ping(t *testing.T) { ts := emptyTestServer() defer ts.Close() u, _ := url.Parse(ts.URL) config := client.Config{URL: *u} c, err := client.NewClient(config) if err != nil { t.Fatalf("unexpected error. expected %v, actual %v", nil, err) } d, version, err := c.Ping() if err != nil { t.Fatalf("unexpected error. expected %v, actual %v", nil, err) } if d == 0 { t.Fatalf("expected a duration greater than zero. actual %v", d) } if version != "x.x" { t.Fatalf("unexpected version. expected %s, actual %v", "x.x", version) } }
func TestClient_Query(t *testing.T) { ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { var data client.Response w.WriteHeader(http.StatusOK) _ = json.NewEncoder(w).Encode(data) })) defer ts.Close() u, _ := url.Parse(ts.URL) config := client.Config{URL: *u} c, err := client.NewClient(config) if err != nil { t.Fatalf("unexpected error. expected %v, actual %v", nil, err) } query := client.Query{} _, err = c.Query(query) if err != nil { t.Fatalf("unexpected error. expected %v, actual %v", nil, err) } }
func TestClient_Write(t *testing.T) { ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { var data client.Response w.WriteHeader(http.StatusNoContent) _ = json.NewEncoder(w).Encode(data) })) defer ts.Close() u, _ := url.Parse(ts.URL) config := client.Config{URL: *u} c, err := client.NewClient(config) if err != nil { t.Fatalf("unexpected error. expected %v, actual %v", nil, err) } bp := client.BatchPoints{} r, err := c.Write(bp) if err != nil { t.Fatalf("unexpected error. expected %v, actual %v", nil, err) } if r != nil { t.Fatalf("unexpected response. expected %v, actual %v", nil, r) } }
func TestParseCommand_Insert(t *testing.T) { t.Parallel() ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { var data client.Response w.WriteHeader(http.StatusNoContent) _ = json.NewEncoder(w).Encode(data) })) defer ts.Close() u, _ := url.Parse(ts.URL) config := client.Config{URL: *u} c, err := client.NewClient(config) if err != nil { t.Fatalf("unexpected error. expected %v, actual %v", nil, err) } m := main.CommandLine{Client: c} tests := []struct { cmd string }{ {cmd: "INSERT cpu,host=serverA,region=us-west value=1.0"}, {cmd: " INSERT cpu,host=serverA,region=us-west value=1.0"}, {cmd: "INSERT cpu,host=serverA,region=us-west value=1.0"}, {cmd: "insert cpu,host=serverA,region=us-west value=1.0 "}, {cmd: "insert"}, {cmd: "Insert "}, {cmd: "insert c"}, {cmd: "insert int"}, } for _, test := range tests { if !m.ParseCommand(test.cmd) { t.Fatalf(`Command "insert" failed for %q.`, test.cmd) } } }
func (c *CommandLine) connect(cmd string) { var cl *client.Client if cmd != "" { // Remove the "connect" keyword if it exists cmd = strings.TrimSpace(strings.Replace(cmd, "connect", "", -1)) if cmd == "" { return } if strings.Contains(cmd, ":") { h := strings.Split(cmd, ":") if i, e := strconv.Atoi(h[1]); e != nil { fmt.Printf("Connect error: Invalid port number %q: %s\n", cmd, e) return } else { c.Port = i } if h[0] == "" { c.Host = default_host } else { c.Host = h[0] } } else { c.Host = cmd // If they didn't specify a port, always use the default port c.Port = default_port } } u := url.URL{ Scheme: "http", } if c.Ssl { u.Scheme = "https" } if c.Port > 0 { u.Host = fmt.Sprintf("%s:%d", c.Host, c.Port) } else { u.Host = c.Host } cl, err := client.NewClient( client.Config{ URL: u, Username: c.Username, Password: c.Password, UserAgent: "InfluxDBShell/" + version, }) if err != nil { fmt.Printf("Could not create client %s", err) return } c.Client = cl if _, v, e := c.Client.Ping(); e != nil { fmt.Printf("Failed to connect to %s\n", c.Client.Addr()) } else { c.Version = v if c.Execute == "" { fmt.Printf("Connected to %s version %s\n", c.Client.Addr(), c.Version) } } }
func TestClient_UserAgent(t *testing.T) { receivedUserAgent := "" ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { receivedUserAgent = r.UserAgent() var data client.Response w.WriteHeader(http.StatusOK) _ = json.NewEncoder(w).Encode(data) })) defer ts.Close() _, err := http.Get(ts.URL) if err != nil { t.Fatalf("unexpected error. expected %v, actual %v", nil, err) } tests := []struct { name string userAgent string expected string }{ { name: "Empty user agent", userAgent: "", expected: "InfluxDBClient", }, { name: "Custom user agent", userAgent: "Test Influx Client", expected: "Test Influx Client", }, } for _, test := range tests { u, _ := url.Parse(ts.URL) config := client.Config{URL: *u, UserAgent: test.userAgent} c, err := client.NewClient(config) if err != nil { t.Fatalf("unexpected error. expected %v, actual %v", nil, err) } receivedUserAgent = "" query := client.Query{} _, err = c.Query(query) if err != nil { t.Fatalf("unexpected error. expected %v, actual %v", nil, err) } if !strings.HasPrefix(receivedUserAgent, test.expected) { t.Fatalf("Unexpected user agent. expected %v, actual %v", test.expected, receivedUserAgent) } receivedUserAgent = "" bp := client.BatchPoints{} _, err = c.Write(bp) if err != nil { t.Fatalf("unexpected error. expected %v, actual %v", nil, err) } if !strings.HasPrefix(receivedUserAgent, test.expected) { t.Fatalf("Unexpected user agent. expected %v, actual %v", test.expected, receivedUserAgent) } receivedUserAgent = "" _, _, err = c.Ping() if err != nil { t.Fatalf("unexpected error. expected %v, actual %v", nil, err) } if receivedUserAgent != test.expected { t.Fatalf("Unexpected user agent. expected %v, actual %v", test.expected, receivedUserAgent) } } }
func TestParseCommand_InsertInto(t *testing.T) { t.Parallel() ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { var data client.Response w.WriteHeader(http.StatusNoContent) _ = json.NewEncoder(w).Encode(data) })) defer ts.Close() u, _ := url.Parse(ts.URL) config := client.Config{URL: *u} c, err := client.NewClient(config) if err != nil { t.Fatalf("unexpected error. expected %v, actual %v", nil, err) } m := main.CommandLine{Client: c} tests := []struct { cmd, db, rp string }{ { cmd: `INSERT INTO test cpu,host=serverA,region=us-west value=1.0`, db: "", rp: "test", }, { cmd: ` INSERT INTO .test cpu,host=serverA,region=us-west value=1.0`, db: "", rp: "test", }, { cmd: `INSERT INTO "test test" cpu,host=serverA,region=us-west value=1.0`, db: "", rp: "test test", }, { cmd: `Insert iNTO test.test cpu,host=serverA,region=us-west value=1.0`, db: "test", rp: "test", }, { cmd: `insert into "test test" cpu,host=serverA,region=us-west value=1.0`, db: "test", rp: "test test", }, { cmd: `insert into "d b"."test test" cpu,host=serverA,region=us-west value=1.0`, db: "d b", rp: "test test", }, } for _, test := range tests { if !m.ParseCommand(test.cmd) { t.Fatalf(`Command "insert into" failed for %q.`, test.cmd) } if m.Database != test.db { t.Fatalf(`Command "insert into" db parsing failed, expected: %q, actual: %q`, test.db, m.Database) } if m.RetentionPolicy != test.rp { t.Fatalf(`Command "insert into" rp parsing failed, expected: %q, actual: %q`, test.rp, m.RetentionPolicy) } } }