github.com/Jeffail/benthos/v3@v3.65.0/internal/transaction/tracked_test.go (about)

     1  package transaction
     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/response"
    10  	"github.com/stretchr/testify/assert"
    11  )
    12  
    13  func TestTaggingErrorsSinglePart(t *testing.T) {
    14  	msg := message.New([][]byte{
    15  		[]byte("foo"),
    16  	})
    17  
    18  	errTest1 := errors.New("test err 1")
    19  	errTest2 := errors.New("test err 2")
    20  	errTest3 := errors.New("test err 3")
    21  
    22  	tran := NewTracked(msg, nil)
    23  
    24  	// No error
    25  	assert.Equal(t, response.NewAck(), tran.resFromError(nil))
    26  
    27  	// Static error
    28  	assert.Equal(t, response.NewError(errTest1), tran.resFromError(errTest1))
    29  
    30  	// Create batch error with single part
    31  	batchErr := batch.NewError(tran.Message(), errTest1)
    32  	batchErr.Failed(0, errTest2)
    33  
    34  	assert.Equal(t, response.NewError(errTest2), tran.resFromError(batchErr))
    35  
    36  	// Create new message, no common part, and create batch error
    37  	newMsg := message.New([][]byte{[]byte("bar")})
    38  	batchErr = batch.NewError(newMsg, errTest1)
    39  	batchErr.Failed(0, errTest2)
    40  
    41  	assert.Equal(t, response.NewError(errTest1), tran.resFromError(batchErr))
    42  
    43  	// Add tran part to new message and create batch error with error on non-tran part
    44  	newMsg.Append(tran.Message().Get(0))
    45  	batchErr = batch.NewError(newMsg, errTest1)
    46  	batchErr.Failed(0, errTest2)
    47  
    48  	assert.Equal(t, response.NewAck(), tran.resFromError(batchErr))
    49  
    50  	// Create batch error for tran part
    51  	batchErr.Failed(1, errTest3)
    52  
    53  	assert.Equal(t, response.NewError(errTest3), tran.resFromError(batchErr))
    54  }
    55  
    56  func TestTaggingErrorsMultiplePart(t *testing.T) {
    57  	msg := message.New([][]byte{
    58  		[]byte("foo"),
    59  		[]byte("bar"),
    60  	})
    61  
    62  	errTest1 := errors.New("test err 1")
    63  	errTest2 := errors.New("test err 2")
    64  	errTest3 := errors.New("test err 3")
    65  
    66  	tran := NewTracked(msg, nil)
    67  
    68  	// No error
    69  	assert.Equal(t, response.NewAck(), tran.resFromError(nil))
    70  
    71  	// Static error
    72  	assert.Equal(t, response.NewError(errTest1), tran.resFromError(errTest1))
    73  
    74  	// Create batch error with single part
    75  	batchErr := batch.NewError(tran.Message(), errTest1)
    76  	batchErr.Failed(0, errTest2)
    77  
    78  	assert.Equal(t, response.NewError(errTest2), tran.resFromError(batchErr))
    79  
    80  	// Create new message, no common part, and create batch error
    81  	newMsg := message.New([][]byte{[]byte("baz")})
    82  	batchErr = batch.NewError(newMsg, errTest1)
    83  	batchErr.Failed(0, errTest2)
    84  
    85  	assert.Equal(t, response.NewError(errTest1), tran.resFromError(batchErr))
    86  
    87  	// Add tran part to new message, still returning general error due to
    88  	// missing part
    89  	newMsg.Append(tran.Message().Get(0))
    90  	batchErr = batch.NewError(newMsg, errTest1)
    91  	batchErr.Failed(0, errTest2)
    92  
    93  	assert.Equal(t, response.NewError(errTest1), tran.resFromError(batchErr))
    94  
    95  	// Add next tran part to new message, and return ack now
    96  	newMsg.Append(tran.Message().Get(1))
    97  	batchErr = batch.NewError(newMsg, errTest1)
    98  	batchErr.Failed(0, errTest2)
    99  
   100  	assert.Equal(t, response.NewAck(), tran.resFromError(batchErr))
   101  
   102  	// Create batch error with error on non-tran part
   103  	batchErr = batch.NewError(newMsg, errTest1)
   104  	batchErr.Failed(0, errTest2)
   105  
   106  	assert.Equal(t, response.NewAck(), tran.resFromError(batchErr))
   107  
   108  	// Create batch error for tran part
   109  	batchErr.Failed(1, errTest3)
   110  	assert.Equal(t, response.NewError(errTest3), tran.resFromError(batchErr))
   111  }
   112  
   113  func TestTaggingErrorsNestedOverlap(t *testing.T) {
   114  	msg := message.New([][]byte{
   115  		[]byte("foo"),
   116  		[]byte("bar"),
   117  	})
   118  
   119  	errTest1 := errors.New("test err 1")
   120  	errTest2 := errors.New("test err 2")
   121  
   122  	tranOne := NewTracked(msg, nil)
   123  
   124  	msgTwo := message.New(nil)
   125  	msgTwo.Append(tranOne.Message().Get(1))
   126  	msgTwo.Append(tranOne.Message().Get(0))
   127  	tranTwo := NewTracked(msgTwo, nil)
   128  
   129  	// No error
   130  	assert.Equal(t, response.NewAck(), tranOne.resFromError(nil))
   131  	assert.Equal(t, response.NewAck(), tranTwo.resFromError(nil))
   132  
   133  	// Static error
   134  	assert.Equal(t, response.NewError(errTest1), tranOne.resFromError(errTest1))
   135  	assert.Equal(t, response.NewError(errTest1), tranTwo.resFromError(errTest1))
   136  
   137  	// Create batch error with single part
   138  	batchErr := batch.NewError(tranTwo.Message(), errTest1)
   139  	batchErr.Failed(0, errTest2)
   140  
   141  	assert.Equal(t, response.NewError(errTest2), tranOne.resFromError(batchErr))
   142  	assert.Equal(t, response.NewError(errTest2), tranTwo.resFromError(batchErr))
   143  
   144  	// And if the batch error only touches the first message, only see error in
   145  	// first transaction
   146  	batchErr = batch.NewError(tranOne.Message(), errTest1)
   147  	batchErr.Failed(0, errTest2)
   148  
   149  	assert.Equal(t, response.NewError(errTest2), tranOne.resFromError(batchErr))
   150  	assert.Equal(t, response.NewError(errTest1), tranTwo.resFromError(batchErr))
   151  }
   152  
   153  func TestTaggingErrorsNestedSerial(t *testing.T) {
   154  	msgOne := message.New([][]byte{
   155  		[]byte("foo"),
   156  	})
   157  	msgTwo := message.New([][]byte{
   158  		[]byte("bar"),
   159  	})
   160  
   161  	errTest1 := errors.New("test err 1")
   162  	errTest2 := errors.New("test err 2")
   163  
   164  	tranOne := NewTracked(msgOne, nil)
   165  	tranTwo := NewTracked(msgTwo, nil)
   166  
   167  	msg := message.New(nil)
   168  	msg.Append(tranOne.Message().Get(0))
   169  	msg.Append(tranTwo.Message().Get(0))
   170  
   171  	// No error
   172  	assert.Equal(t, response.NewAck(), tranOne.resFromError(nil))
   173  	assert.Equal(t, response.NewAck(), tranTwo.resFromError(nil))
   174  
   175  	// Static error
   176  	assert.Equal(t, response.NewError(errTest1), tranOne.resFromError(errTest1))
   177  	assert.Equal(t, response.NewError(errTest1), tranTwo.resFromError(errTest1))
   178  
   179  	// Create batch error with single part
   180  	batchErr := batch.NewError(msg, errTest1)
   181  	batchErr.Failed(0, errTest2)
   182  
   183  	assert.Equal(t, response.NewError(errTest2), tranOne.resFromError(batchErr))
   184  	assert.Equal(t, response.NewAck(), tranTwo.resFromError(batchErr))
   185  }
   186  
   187  func BenchmarkErrorWithTagging(b *testing.B) {
   188  	msg := message.New([][]byte{
   189  		[]byte("foo"),
   190  		[]byte("bar"),
   191  		[]byte("baz"),
   192  		[]byte("buz"),
   193  	})
   194  
   195  	errTest1 := errors.New("test err 1")
   196  	errTest2 := errors.New("test err 2")
   197  
   198  	for i := 0; i < b.N; i++ {
   199  		tran := NewTracked(msg, nil)
   200  
   201  		batchErr := batch.NewError(tran.Message(), errTest1)
   202  		batchErr.Failed(0, errTest2)
   203  
   204  		assert.Equal(b, response.NewError(errTest2), tran.resFromError(batchErr))
   205  	}
   206  }
   207  
   208  func BenchmarkErrorWithTaggingN3(b *testing.B) {
   209  	msg := message.New([][]byte{
   210  		[]byte("foo"),
   211  		[]byte("bar"),
   212  		[]byte("baz"),
   213  		[]byte("buz"),
   214  	})
   215  
   216  	errTest1 := errors.New("test err 1")
   217  	errTest2 := errors.New("test err 2")
   218  
   219  	for i := 0; i < b.N; i++ {
   220  		tran := NewTracked(msg, nil)
   221  		tranTwo := NewTracked(tran.Message(), nil)
   222  		tranThree := NewTracked(tranTwo.Message(), nil)
   223  
   224  		batchErr := batch.NewError(tranThree.Message(), errTest1)
   225  		batchErr.Failed(0, errTest2)
   226  
   227  		assert.Equal(b, response.NewError(errTest2), tran.resFromError(batchErr))
   228  		assert.Equal(b, response.NewError(errTest2), tranTwo.resFromError(batchErr))
   229  		assert.Equal(b, response.NewError(errTest2), tranThree.resFromError(batchErr))
   230  	}
   231  }
   232  
   233  func BenchmarkErrorWithTaggingN2(b *testing.B) {
   234  	msg := message.New([][]byte{
   235  		[]byte("foo"),
   236  		[]byte("bar"),
   237  		[]byte("baz"),
   238  		[]byte("buz"),
   239  	})
   240  
   241  	errTest1 := errors.New("test err 1")
   242  	errTest2 := errors.New("test err 2")
   243  
   244  	for i := 0; i < b.N; i++ {
   245  		tran := NewTracked(msg, nil)
   246  		tranTwo := NewTracked(tran.Message(), nil)
   247  
   248  		batchErr := batch.NewError(tranTwo.Message(), errTest1)
   249  		batchErr.Failed(0, errTest2)
   250  
   251  		assert.Equal(b, response.NewError(errTest2), tran.resFromError(batchErr))
   252  		assert.Equal(b, response.NewError(errTest2), tranTwo.resFromError(batchErr))
   253  	}
   254  }
   255  
   256  func BenchmarkErrorNoTagging(b *testing.B) {
   257  	msg := message.New([][]byte{
   258  		[]byte("foo"),
   259  		[]byte("bar"),
   260  		[]byte("baz"),
   261  		[]byte("buz"),
   262  	})
   263  
   264  	errTest1 := errors.New("test err 1")
   265  
   266  	for i := 0; i < b.N; i++ {
   267  		tran := NewTracked(msg, nil)
   268  		assert.Equal(b, response.NewError(errTest1), tran.resFromError(errTest1))
   269  	}
   270  }