func testSimpleEvent(t *testing.T, factory clientFactory) {
enableLogging([]string{"*"})
mock := transptest.NewMockServerTCP(t, 1*time.Second, "", nil)
server, _ := v2.NewWithListener(mock.Listener)
defer server.Close()
transp, err := mock.Connect()
if err != nil {
t.Fatalf("Failed to connect: %v", err)
}
client := factory(transp)
defer transp.Close()
defer client.Stop()
event := common.MapStr{"type": "test", "name": "me", "line": 10}
go client.Publish([]common.MapStr{event})
// try to receive event from server
batch := server.Receive()
batch.ACK()
// validate
events := batch.Events
assert.Equal(t, 1, len(events))
msg := events[0].(map[string]interface{})
assert.Equal(t, "me", msg["name"])
assert.Equal(t, 10.0, msg["line"])
}
func testCloseAfterWindowSize(t *testing.T, factory clientFactory) {
enableLogging([]string{"*"})
server := transptest.NewMockServerTCP(t, 100*time.Millisecond, "", nil)
sock, transp, err := server.ConnectPair()
if err != nil {
t.Fatalf("Failed to connect server and client: %v", err)
}
client := factory(transp)
conn := &mockConn{sock, streambuf.New(nil)}
defer transp.Close()
defer sock.Close()
defer client.Stop()
client.Publish([]common.MapStr{common.MapStr{
"type": "test",
"message": "hello world",
}})
_, err = conn.recvMessage()
if err != nil {
t.Fatalf("failed to read window size message: %v", err)
}
}
func testSendZero(t *testing.T, factory clientFactory) {
enableLogging([]string{"*"})
server := transptest.NewMockServerTCP(t, 1*time.Second, "", nil)
defer server.Close()
sock, transp, err := server.ConnectPair()
if err != nil {
t.Fatalf("Failed to connect server and client: %v", err)
}
client := factory(transp)
defer sock.Close()
defer transp.Close()
client.Publish(make([]common.MapStr, 0))
client.Stop()
returns := client.Returns()
assert.Equal(t, 1, len(returns))
if len(returns) == 1 {
assert.Equal(t, 0, returns[0].n)
assert.Nil(t, returns[0].err)
}
}
func TestLogstashTCP(t *testing.T) {
timeout := 2 * time.Second
server := transptest.NewMockServerTCP(t, timeout, "", nil)
// create lumberjack output client
config := map[string]interface{}{
"hosts": []string{server.Addr()},
"index": testLogstashIndex("logstash-conn-tcp"),
"timeout": 2,
}
testConnectionType(t, server, testOutputerFactory(t, "", config))
}
func testStructuredEvent(t *testing.T, factory clientFactory) {
enableLogging([]string{"*"})
server := transptest.NewMockServerTCP(t, 1*time.Second, "", nil)
sock, transp, err := server.ConnectPair()
if err != nil {
t.Fatalf("Failed to connect server and client: %v", err)
}
client := factory(transp)
conn := &mockConn{sock, streambuf.New(nil)}
defer transp.Close()
defer sock.Close()
event := common.MapStr{
"type": "test",
"name": "test",
"struct": common.MapStr{
"field1": 1,
"field2": true,
"field3": []int{1, 2, 3},
"field4": []interface{}{
1,
"test",
common.MapStr{
"sub": "field",
},
},
"field5": common.MapStr{
"sub1": 2,
},
},
}
client.Publish([]common.MapStr{event})
win, err := conn.recvMessage()
assert.Nil(t, err)
msg, err := conn.recvMessage()
assert.Nil(t, err)
conn.sendACK(1)
defer client.Stop()
// validate
assert.NotNil(t, win)
assert.NotNil(t, msg)
assert.Equal(t, 1, len(msg.events))
msg = msg.events[0]
assert.Equal(t, "test", msg.doc["name"])
assert.Equal(t, 1.0, msg.doc.get("struct.field1"))
assert.Equal(t, true, msg.doc.get("struct.field2"))
assert.Equal(t, 2.0, msg.doc.get("struct.field5.sub1"))
}
func testStructuredEvent(t *testing.T, factory clientFactory) {
enableLogging([]string{"*"})
mock := transptest.NewMockServerTCP(t, 1*time.Second, "", nil)
server, _ := v2.NewWithListener(mock.Listener)
defer server.Close()
transp, err := mock.Connect()
if err != nil {
t.Fatalf("Failed to connect: %v", err)
}
client := factory(transp)
defer transp.Close()
defer client.Stop()
event := common.MapStr{
"type": "test",
"name": "test",
"struct": common.MapStr{
"field1": 1,
"field2": true,
"field3": []int{1, 2, 3},
"field4": []interface{}{
1,
"test",
common.MapStr{
"sub": "field",
},
},
"field5": common.MapStr{
"sub1": 2,
},
},
}
go client.Publish([]common.MapStr{event})
defer client.Stop()
// try to receive event from server
batch := server.Receive()
batch.ACK()
events := batch.Events
assert.Equal(t, 1, len(events))
msg := events[0]
assert.Equal(t, "test", eventGet(msg, "name"))
assert.Equal(t, 1.0, eventGet(msg, "struct.field1"))
assert.Equal(t, true, eventGet(msg, "struct.field2"))
assert.Equal(t, 2.0, eventGet(msg, "struct.field5.sub1"))
}
func testMultiFailMaxTimeouts(t *testing.T, factory clientFactory) {
enableLogging([]string{"*"})
mock := transptest.NewMockServerTCP(t, 100*time.Millisecond, "", nil)
server, _ := v2.NewWithListener(mock.Listener)
defer server.Close()
transp, err := mock.Transp()
if err != nil {
t.Fatalf("Failed to connect: %v", err)
}
client := factory(transp)
defer transp.Close()
defer client.Stop()
N := 8
event := outputs.Data{Event: common.MapStr{"type": "test", "name": "me", "line": 10}}
for i := 0; i < N; i++ {
// reconnect client
client.Close()
client.Connect()
// publish event. With client returning on timeout, we have to send
// messages again
go client.Publish([]outputs.Data{event})
// read batch + never ACK in order to enforce timeout
server.Receive()
// wait for max connection timeout ensuring ACK receive fails
time.Sleep(100 * time.Millisecond)
}
client.Stop()
returns := client.Returns()
if len(returns) != N {
t.Fatalf("PublishEvents did not return")
}
for _, ret := range returns {
assert.Equal(t, 0, ret.n)
assert.NotNil(t, ret.err)
}
}
func testSimpleEvent(t *testing.T, factory clientFactory) {
enableLogging([]string{"*"})
server := transptest.NewMockServerTCP(t, 1*time.Second, "", nil)
sock, transp, err := server.ConnectPair()
if err != nil {
t.Fatalf("Failed to connect server and client: %v", err)
}
client := factory(transp)
conn := &mockConn{sock, streambuf.New(nil)}
defer transp.Close()
defer sock.Close()
event := common.MapStr{"type": "test", "name": "me", "line": 10}
client.Publish([]common.MapStr{event})
// receive window message
err = sock.SetReadDeadline(time.Now().Add(1 * time.Second))
win, err := conn.recvMessage()
assert.Nil(t, err)
// receive data message
msg, err := conn.recvMessage()
assert.Nil(t, err)
// send ack
conn.sendACK(1)
client.Stop()
// validate
assert.NotNil(t, win)
assert.NotNil(t, msg)
assert.Equal(t, 1, len(msg.events))
msg = msg.events[0]
assert.Equal(t, "me", msg.doc["name"])
assert.Equal(t, 10.0, msg.doc["line"])
}
func newClientServerTCP(t *testing.T, to time.Duration) *clientServer {
return &clientServer{transptest.NewMockServerTCP(t, to, "", nil)}
}
func newMockTCPServer(t *testing.T, to time.Duration) *mockLSServer {
return &mockLSServer{transptest.NewMockServerTCP(t, to, "", nil)}
}
func newProtoServerTCP(t *testing.T, to time.Duration) *protocolServer {
return &protocolServer{transptest.NewMockServerTCP(t, to, "", nil)}
}
func testMultiFailMaxTimeouts(t *testing.T, factory clientFactory) {
enableLogging([]string{"*"})
server := transptest.NewMockServerTCP(t, 100*time.Millisecond, "", nil)
transp, err := server.Transp()
if err != nil {
t.Fatalf("Failed to connect server and client: %v", err)
}
N := 8
client := factory(transp)
defer transp.Close()
defer client.Stop()
event := common.MapStr{"type": "test", "name": "me", "line": 10}
for i := 0; i < N; i++ {
await := server.Await()
err = transp.Connect()
if err != nil {
t.Fatalf("Transport client Failed to connect: %v", err)
}
sock := <-await
conn := &mockConn{sock, streambuf.New(nil)}
// close socket only once test has finished
// so no EOF error can be generated
defer sock.Close()
// publish event. With client returning on timeout, we have to send
// messages again
client.Publish([]common.MapStr{event})
// read window
msg, err := conn.recvMessage()
if err != nil {
t.Errorf("Failed receiving window size: %v", err)
break
}
if msg.code != 'W' {
t.Errorf("expected window size message")
break
}
// read message
msg, err = conn.recvMessage()
if err != nil {
t.Errorf("Failed receiving data message: %v", err)
break
}
if msg.code != 'C' {
t.Errorf("expected data message")
break
}
// do not respond -> enforce timeout
// check connection being closed,
// timeout required in case of sender not closing the connection
// correctly
sock.SetDeadline(time.Now().Add(30 * time.Second))
msg, err = conn.recvMessage()
if msg != nil {
t.Errorf("Received message on connection expected to be closed")
break
}
if nerr, ok := err.(net.Error); ok && nerr.Timeout() {
t.Errorf("Unexpected timeout error (client did not close connection in time?): %v", err)
break
}
}
client.Stop()
returns := client.Returns()
if len(returns) != N {
t.Fatalf("PublishEvents did not return")
}
for _, ret := range returns {
assert.Equal(t, 0, ret.n)
assert.NotNil(t, ret.err)
}
}