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

     1  package writer
     2  
     3  import (
     4  	"errors"
     5  	"testing"
     6  
     7  	"github.com/Jeffail/benthos/v3/internal/batch"
     8  	"github.com/Jeffail/benthos/v3/lib/message"
     9  	"github.com/Jeffail/benthos/v3/lib/types"
    10  	"github.com/stretchr/testify/assert"
    11  )
    12  
    13  func TestBatchedSendHappy(t *testing.T) {
    14  	parts := []string{
    15  		"foo", "bar", "baz", "buz",
    16  	}
    17  
    18  	msg := message.New(nil)
    19  	for _, p := range parts {
    20  		msg.Append(message.NewPart([]byte(p)))
    21  	}
    22  
    23  	seen := []string{}
    24  	assert.NoError(t, IterateBatchedSend(msg, func(i int, p types.Part) error {
    25  		assert.Equal(t, i, len(seen))
    26  		seen = append(seen, string(p.Get()))
    27  		return nil
    28  	}))
    29  
    30  	assert.Equal(t, parts, seen)
    31  }
    32  
    33  func TestBatchedSendALittleSad(t *testing.T) {
    34  	parts := []string{
    35  		"foo", "bar", "baz", "buz",
    36  	}
    37  
    38  	msg := message.New(nil)
    39  	for _, p := range parts {
    40  		msg.Append(message.NewPart([]byte(p)))
    41  	}
    42  
    43  	errFirst, errSecond := errors.New("first"), errors.New("second")
    44  
    45  	seen := []string{}
    46  	err := IterateBatchedSend(msg, func(i int, p types.Part) error {
    47  		assert.Equal(t, i, len(seen))
    48  		seen = append(seen, string(p.Get()))
    49  		if i == 1 {
    50  			return errFirst
    51  		}
    52  		if i == 3 {
    53  			return errSecond
    54  		}
    55  		return nil
    56  	})
    57  	assert.Error(t, err)
    58  
    59  	expErr := batch.NewError(msg, errFirst).Failed(1, errFirst).Failed(3, errSecond)
    60  
    61  	assert.Equal(t, parts, seen)
    62  	assert.Equal(t, expErr, err)
    63  }
    64  
    65  func TestBatchedSendFatal(t *testing.T) {
    66  	msg := message.New(nil)
    67  	for _, p := range []string{
    68  		"foo", "bar", "baz", "buz",
    69  	} {
    70  		msg.Append(message.NewPart([]byte(p)))
    71  	}
    72  
    73  	seen := []string{}
    74  	err := IterateBatchedSend(msg, func(i int, p types.Part) error {
    75  		assert.Equal(t, i, len(seen))
    76  		seen = append(seen, string(p.Get()))
    77  		if i == 1 {
    78  			return types.ErrTypeClosed
    79  		}
    80  		return nil
    81  	})
    82  	assert.Error(t, err)
    83  	assert.EqualError(t, err, "type was closed")
    84  	assert.Equal(t, []string{"foo", "bar"}, seen)
    85  
    86  	seen = []string{}
    87  	err = IterateBatchedSend(msg, func(i int, p types.Part) error {
    88  		assert.Equal(t, i, len(seen))
    89  		seen = append(seen, string(p.Get()))
    90  		if i == 1 {
    91  			return types.ErrNotConnected
    92  		}
    93  		return nil
    94  	})
    95  	assert.Error(t, err)
    96  	assert.EqualError(t, err, "not connected to target source or sink")
    97  	assert.Equal(t, []string{"foo", "bar"}, seen)
    98  
    99  	seen = []string{}
   100  	err = IterateBatchedSend(msg, func(i int, p types.Part) error {
   101  		assert.Equal(t, i, len(seen))
   102  		seen = append(seen, string(p.Get()))
   103  		if i == 1 {
   104  			return types.ErrTimeout
   105  		}
   106  		return nil
   107  	})
   108  	assert.Error(t, err)
   109  	assert.EqualError(t, err, "action timed out")
   110  	assert.Equal(t, []string{"foo", "bar"}, seen)
   111  }