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 }