github.com/Jeffail/benthos/v3@v3.65.0/lib/output/line_writer_test.go (about)

     1  package output
     2  
     3  import (
     4  	"bytes"
     5  	"testing"
     6  	"time"
     7  
     8  	"github.com/Jeffail/benthos/v3/lib/log"
     9  	"github.com/Jeffail/benthos/v3/lib/message"
    10  	"github.com/Jeffail/benthos/v3/lib/metrics"
    11  	"github.com/Jeffail/benthos/v3/lib/types"
    12  )
    13  
    14  type testBuffer struct {
    15  	bytes.Buffer
    16  
    17  	closed bool
    18  }
    19  
    20  func (t *testBuffer) Close() error {
    21  	t.closed = true
    22  	return nil
    23  }
    24  
    25  func TestLineWriterBasic(t *testing.T) {
    26  	var buf testBuffer
    27  
    28  	msgChan := make(chan types.Transaction)
    29  	resChan := make(chan types.Response)
    30  
    31  	writer, err := NewLineWriter(&buf, true, []byte{}, "foo", log.Noop(), metrics.Noop())
    32  	if err != nil {
    33  		t.Error(err)
    34  		return
    35  	}
    36  
    37  	if err = writer.Consume(msgChan); err != nil {
    38  		t.Error(err)
    39  	}
    40  	if err = writer.Consume(msgChan); err == nil {
    41  		t.Error("Expected error from duplicate receiver call")
    42  	}
    43  
    44  	testCases := []struct {
    45  		message        []string
    46  		expectedOutput string
    47  	}{
    48  		{
    49  			[]string{`hello world`},
    50  			"hello world\n",
    51  		},
    52  		{
    53  			[]string{`hello world`, `part 2`},
    54  			"hello world\npart 2\n\n",
    55  		},
    56  	}
    57  
    58  	for _, c := range testCases {
    59  		msg := message.New(nil)
    60  		for _, part := range c.message {
    61  			msg.Append(message.NewPart([]byte(part)))
    62  		}
    63  
    64  		select {
    65  		case msgChan <- types.NewTransaction(msg, resChan):
    66  		case <-time.After(time.Second):
    67  			t.Error("Timed out sending message")
    68  		}
    69  
    70  		select {
    71  		case res, open := <-resChan:
    72  			if !open {
    73  				t.Error("writer closed early")
    74  				return
    75  			}
    76  			if res.Error() != nil {
    77  				t.Error(res.Error())
    78  			}
    79  		case <-time.After(time.Second):
    80  			t.Error("Timed out waiting for response")
    81  		}
    82  
    83  		if exp, act := c.expectedOutput, buf.String(); exp != act {
    84  			t.Errorf("Unexpected output from writer: %v != %v", exp, act)
    85  		}
    86  		buf.Reset()
    87  	}
    88  
    89  	writer.CloseAsync()
    90  	if err = writer.WaitForClose(time.Second); err != nil {
    91  		t.Error(err)
    92  	}
    93  
    94  	if !buf.closed {
    95  		t.Error("Buffer was not closed by writer")
    96  	}
    97  }
    98  
    99  func TestLineWriterCustomDelim(t *testing.T) {
   100  	var buf testBuffer
   101  
   102  	msgChan := make(chan types.Transaction)
   103  	resChan := make(chan types.Response)
   104  
   105  	writer, err := NewLineWriter(&buf, true, []byte("<FOO>"), "foo", log.Noop(), metrics.Noop())
   106  	if err != nil {
   107  		t.Error(err)
   108  		return
   109  	}
   110  
   111  	if err = writer.Consume(msgChan); err != nil {
   112  		t.Error(err)
   113  	}
   114  	if err = writer.Consume(msgChan); err == nil {
   115  		t.Error("Expected error from duplicate receiver call")
   116  	}
   117  
   118  	testCases := []struct {
   119  		message        []string
   120  		expectedOutput string
   121  	}{
   122  		{
   123  			[]string{`hello world`},
   124  			"hello world<FOO>",
   125  		},
   126  		{
   127  			[]string{`hello world`, `part 2`},
   128  			"hello world<FOO>part 2<FOO><FOO>",
   129  		},
   130  	}
   131  
   132  	for _, c := range testCases {
   133  		msg := message.New(nil)
   134  		for _, part := range c.message {
   135  			msg.Append(message.NewPart([]byte(part)))
   136  		}
   137  
   138  		select {
   139  		case msgChan <- types.NewTransaction(msg, resChan):
   140  		case <-time.After(time.Second):
   141  			t.Error("Timed out sending message")
   142  		}
   143  
   144  		select {
   145  		case res, open := <-resChan:
   146  			if !open {
   147  				t.Error("writer closed early")
   148  				return
   149  			}
   150  			if res.Error() != nil {
   151  				t.Error(res.Error())
   152  			}
   153  		case <-time.After(time.Second):
   154  			t.Error("Timed out waiting for response")
   155  		}
   156  
   157  		if exp, act := c.expectedOutput, buf.String(); exp != act {
   158  			t.Errorf("Unexpected output from writer: %v != %v", exp, act)
   159  		}
   160  		buf.Reset()
   161  	}
   162  
   163  	writer.CloseAsync()
   164  	if err = writer.WaitForClose(time.Second); err != nil {
   165  		t.Error(err)
   166  	}
   167  
   168  	if !buf.closed {
   169  		t.Error("Buffer was not closed by writer")
   170  	}
   171  }