func TestNew(t *testing.T) { ctx := context.Background() sendTo1 := dptest.NewBasicSink() sendTo2 := dptest.NewBasicSink() demux := New([]dpsink.Sink{sendTo1, sendTo2}) pts := []*datapoint.Datapoint{dptest.DP(), dptest.DP()} es := []*event.Event{dptest.E(), dptest.E()} ctx2, _ := context.WithTimeout(ctx, time.Millisecond) assert.Error(t, demux.AddDatapoints(ctx2, pts)) assert.Error(t, demux.AddEvents(ctx2, es)) assert.NoError(t, demux.AddDatapoints(context.Background(), []*datapoint.Datapoint{})) assert.NoError(t, demux.AddEvents(context.Background(), []*event.Event{})) }
func TestAllInvalid(t *testing.T) { dp := dptest.DP() dp.Metric = "" f := Forwarder{} assert.NoError(t, f.AddDatapoints(context.Background(), []*datapoint.Datapoint{dp})) assert.NoError(t, f.AddEvents(context.Background(), []*event.Event{})) }
func TestEmptyMetricFilter(t *testing.T) { end := dptest.NewBasicSink() end.Resize(1) ctx := context.Background() filt := EmptyMetricFilter{} p1 := dptest.DP() p2 := dptest.DP() p1.Metric = "" assert.NoError(t, filt.AddDatapoints(ctx, []*datapoint.Datapoint{p1, p2}, end)) out := <-end.PointsChan assert.Equal(t, 1, len(out)) assert.Equal(t, int64(1), filt.EmptyMetricFiltered) assert.NoError(t, filt.AddDatapoints(ctx, []*datapoint.Datapoint{p1}, end)) runtime.Gosched() assert.Equal(t, 0, len(end.PointsChan)) }
func TestClientReqError(t *testing.T) { f := Forwarder{ protoMarshal: proto.Marshal, client: &http.Client{ Transport: roundTripTest(func(r *http.Request) (*http.Response, error) { return nil, fmt.Errorf("unable to execute http request") }), }, } err := f.AddDatapoints(context.Background(), []*datapoint.Datapoint{dptest.DP()}) assert.Contains(t, err.Error(), "unable to execute http request") }
func TestFilenameForwarderBadWrite(t *testing.T) { ctx := context.Background() fileObj, _ := ioutil.TempFile("", "gotest") defer os.Remove(fileObj.Name()) conf := &config.ForwardTo{ Filename: workarounds.GolangDoesnotAllowPointerToStringLiteral(fileObj.Name()), } f, _ := ForwarderLoader(conf) f.writeString = func(f *os.File, s string) (ret int, err error) { return 0, errors.New("nope") } assert.Error(t, f.AddDatapoints(ctx, []*datapoint.Datapoint{dptest.DP()})) assert.Error(t, f.AddEvents(ctx, []*event.Event{dptest.E()})) }
func TestResponseBodyError(t *testing.T) { f := Forwarder{ protoMarshal: proto.Marshal, client: &http.Client{ Transport: roundTripTest(func(r *http.Request) (*http.Response, error) { r2 := http.Response{ Body: ioutil.NopCloser(&readError{}), } return &r2, nil }), }, } err := f.AddDatapoints(context.Background(), []*datapoint.Datapoint{dptest.DP()}) assert.Equal(t, "read error", err.(*forwardError).originalError.Error()) }
func TestConnectorProcessProtoError(t *testing.T) { expectedErr := errors.New("marshal error") f := Forwarder{ protoMarshal: func(pb proto.Message) ([]byte, error) { return nil, expectedErr }, jsonMarshal: func(interface{}) ([]byte, error) { return nil, expectedErr }, } err := f.AddDatapoints(context.Background(), []*datapoint.Datapoint{dptest.DP()}) assert.Equal(t, expectedErr, err.(*forwardError).originalError) err = f.AddEvents(context.Background(), []*event.Event{dptest.E()}) assert.Equal(t, expectedErr, err.(*forwardError).originalError) }
func TestFilenameForwarder(t *testing.T) { ctx := context.Background() fileObj, _ := ioutil.TempFile("", "gotest") filename := fileObj.Name() defer os.Remove(filename) conf := &config.ForwardTo{ Filename: workarounds.GolangDoesnotAllowPointerToStringLiteral(fileObj.Name()), } f, err := ForwarderLoader(conf) defer f.Close() assert.NoError(t, err) assert.NoError(t, f.AddDatapoints(ctx, []*datapoint.Datapoint{dptest.DP()})) assert.NoError(t, f.AddEvents(ctx, []*event.Event{dptest.E()})) assert.Equal(t, 0, len(f.Stats())) }
func TestResponseBadStatus(t *testing.T) { f := Forwarder{ protoMarshal: proto.Marshal, client: &http.Client{ Transport: roundTripTest(func(r *http.Request) (*http.Response, error) { r2 := http.Response{ Body: ioutil.NopCloser(bytes.NewBufferString("")), StatusCode: 404, } return &r2, nil }), }, } err := f.AddDatapoints(context.Background(), []*datapoint.Datapoint{dptest.DP()}) assert.Contains(t, err.(*forwardError).originalError.Error(), "invalid status code") }
func TestCreation(t *testing.T) { listenFrom := config.ListenFrom{} listenFrom.ListenAddr = workarounds.GolangDoesnotAllowPointerToStringLiteral("127.0.0.1:0") forwardTo := dptest.NewBasicSink() ctx := context.Background() l, err := ListenerLoader(ctx, forwardTo, &listenFrom) defer l.Close() assert.Equal(t, nil, err, "Expect no error") assert.Equal(t, numStats, len(l.Stats()), "Expect no stats") forwarder, err := NewForwarder("127.0.0.1", nettest.TCPPort(l.psocket), time.Second, []string{"zzfirst"}, 10) defer forwarder.Close() assert.Equal(t, nil, err, "Expect no error") assert.Equal(t, 1, len(forwarder.pool.conns)) timeToSend := time.Now().Round(time.Second) dpSent := dptest.DP() dpSent.Timestamp = timeToSend log.Info("Sending a dp") forwarder.AddDatapoints(ctx, []*datapoint.Datapoint{dpSent}) log.Info("Looking for DP back") dpSeen := forwardTo.Next() assert.Equal(t, "randtest."+dpSent.Metric, dpSeen.Metric, "Expect metric back") assert.Equal(t, dpSent.Timestamp, dpSeen.Timestamp, "Expect metric back") // Test creating a new connection if pool is empty for forwarder.pool.Get() != nil { } forwarder.AddDatapoints(ctx, []*datapoint.Datapoint{dpSent}) dpSeen = forwardTo.Next() assert.Equal(t, "randtest."+dpSent.Metric, dpSeen.Metric, "Expect metric back") assert.Equal(t, dpSent.Timestamp, dpSeen.Timestamp, "Expect metric back") // // Test creation error if pool is empty for forwarder.pool.Get() != nil { } forwarder.dialer = func(network, address string, timeout time.Duration) (net.Conn, error) { return nil, errors.New("nope") } assert.Error(t, forwarder.AddDatapoints(ctx, []*datapoint.Datapoint{dpSeen})) forwarder.dialer = net.DialTimeout assert.NoError(t, forwarder.AddDatapoints(ctx, []*datapoint.Datapoint{dpSeen}), "Should get the conn back") }
func TestResponseBadBody(t *testing.T) { f := Forwarder{ protoMarshal: proto.Marshal, jsonMarshal: json.Marshal, client: &http.Client{ Transport: roundTripTest(func(r *http.Request) (*http.Response, error) { r2 := http.Response{ Body: ioutil.NopCloser(bytes.NewBufferString(`"BAD"`)), StatusCode: 200, } return &r2, nil }), }, } err := f.AddDatapoints(context.Background(), []*datapoint.Datapoint{dptest.DP()}) assert.Contains(t, err.Error(), "body decode error") err = f.AddEvents(context.Background(), []*event.Event{dptest.E()}) assert.Contains(t, err.Error(), "body decode error") }
func TestResponseBadJSON(t *testing.T) { f := Forwarder{ protoMarshal: proto.Marshal, jsonMarshal: json.Marshal, client: &http.Client{ Transport: roundTripTest(func(r *http.Request) (*http.Response, error) { r2 := http.Response{ Body: ioutil.NopCloser(bytes.NewBufferString("INVALID_JSON")), StatusCode: 200, } return &r2, nil }), }, } err := f.AddDatapoints(context.Background(), []*datapoint.Datapoint{dptest.DP()}) assert.IsType(t, &json.SyntaxError{}, err.(*forwardError).originalError) err = f.AddEvents(context.Background(), []*event.Event{dptest.E()}) assert.IsType(t, &json.SyntaxError{}, err.(*forwardError).originalError) }
func TestBasicSend(t *testing.T) { testServer := httptest.NewServer(http.HandlerFunc(func(rw http.ResponseWriter, req *http.Request) { assert.Equal(t, "abcd", req.Header.Get("User-Agent")) assert.Equal(t, "abcdefg", req.Header.Get(TokenHeaderName)) rw.Write([]byte(`"OK"`)) })) defer testServer.Close() f := NewSignalfxJSONForwarder("", time.Second, "", 10, "", "", "") f.UserAgent("abcd") f.AuthToken("abcdefg") f.Endpoint(testServer.URL) f.EventEndpoint(testServer.URL) ctx := context.Background() dp := dptest.DP() e := dptest.E() assert.NoError(t, f.AddDatapoints(ctx, []*datapoint.Datapoint{dp})) assert.NoError(t, f.AddEvents(ctx, []*event.Event{e})) }
func TestRateLimitErrorLogging(t *testing.T) { expectedErr := errors.New("nope") end := dptest.NewBasicSink() end.RetError(expectedErr) ctx := context.Background() var lastErr error count := 0 l := RateLimitErrorLogging{ Callback: func(err error) { lastErr = err count++ }, LogThrottle: time.Second, } for i := 0; i < 1000; i++ { assert.Equal(t, expectedErr, l.AddDatapoints(ctx, []*datapoint.Datapoint{dptest.DP()}, end)) } assert.Equal(t, expectedErr, lastErr) assert.Equal(t, 1, count) }
func TestLoader(t *testing.T) { listenFrom := config.ListenFrom{} listenFrom.ListenAddr = workarounds.GolangDoesnotAllowPointerToStringLiteral("127.0.0.1:0") ctx := context.Background() forwardTo := dptest.NewBasicSink() l, err := ListenerLoader(ctx, forwardTo, &listenFrom) port := nettest.TCPPort(l.psocket) ft := config.ForwardTo{ Host: workarounds.GolangDoesnotAllowPointerToStringLiteral("127.0.0.1"), Port: workarounds.GolangDoesnotAllowPointerToUint16Literal(port), } f, err := ForwarderLoader(context.Background(), &ft) assert.NoError(t, err) dpSent := dptest.DP() dpSent.Dimensions = map[string]string{} assert.NoError(t, f.AddDatapoints(ctx, []*datapoint.Datapoint{dpSent})) dpSeen := forwardTo.Next() assert.Equal(t, dpSent.Metric, dpSeen.Metric) assert.Equal(t, numStats+1, len(f.Stats())) }
func TestWriteError(t *testing.T) { listenFrom := config.ListenFrom{} listenFrom.ListenAddr = workarounds.GolangDoesnotAllowPointerToStringLiteral("127.0.0.1:0") forwardTo := dptest.NewBasicSink() ctx := context.Background() l, err := ListenerLoader(ctx, forwardTo, &listenFrom) defer l.Close() forwarder, err := NewForwarder("127.0.0.1", nettest.TCPPort(l.psocket), time.Second, []string{}, 10) assert.Equal(t, nil, err, "Expect no error") forwarder.dialer = func(network, address string, timeout time.Duration) (net.Conn, error) { mockConn := mockConn{} mockConn.writeReturn = errors.New("deadline error") return &mockConn, nil } for forwarder.pool.Get() != nil { } dpSent := dptest.DP() assert.Error(t, forwarder.AddDatapoints(ctx, []*datapoint.Datapoint{dpSent})) }
func TestCarbonWrite(t *testing.T) { listenFrom := config.ListenFrom{} listenFrom.ListenAddr = workarounds.GolangDoesnotAllowPointerToStringLiteral("127.0.0.1:0") forwardTo := dptest.NewBasicSink() ctx := context.Background() l, err := ListenerLoader(ctx, forwardTo, &listenFrom) defer l.Close() assert.Equal(t, nil, err, "Expect no error") assert.Equal(t, numStats, len(l.Stats()), "Expect no stats") forwarder, err := NewForwarder("127.0.0.1", nettest.TCPPort(l.psocket), time.Second, []string{"zzfirst"}, 10) assert.Equal(t, nil, err, "Expect no error") assert.Equal(t, 1, len(forwarder.pool.conns)) timeToSend := time.Now().Round(time.Second) dpSent := dptest.DP() dpSent.Timestamp = timeToSend dpSent.Meta[carbonNative] = "abcd 123 123" log.Info("Sending a dp") forwarder.AddDatapoints(ctx, []*datapoint.Datapoint{dpSent}) log.Info("Looking for DP back") dpSeen := forwardTo.Next() assert.Equal(t, "abcd", dpSeen.Metric, "Expect metric back") }