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")
}
