github.com/observiq/carbon@v0.9.11-0.20200820160507-1b872e368a5e/operator/helper/transformer_test.go (about)

     1  package helper
     2  
     3  import (
     4  	"context"
     5  	"fmt"
     6  	"testing"
     7  
     8  	"github.com/observiq/carbon/entry"
     9  	"github.com/observiq/carbon/operator"
    10  	"github.com/observiq/carbon/testutil"
    11  	"github.com/stretchr/testify/mock"
    12  	"github.com/stretchr/testify/require"
    13  )
    14  
    15  func TestTransformerConfigMissingBase(t *testing.T) {
    16  	cfg := NewTransformerConfig("test", "")
    17  	cfg.OutputIDs = []string{"test-output"}
    18  	_, err := cfg.Build(testutil.NewBuildContext(t))
    19  	require.Error(t, err)
    20  	require.Contains(t, err.Error(), "missing required `type` field.")
    21  }
    22  
    23  func TestTransformerConfigMissingOutput(t *testing.T) {
    24  	cfg := NewTransformerConfig("test", "test")
    25  	_, err := cfg.Build(testutil.NewBuildContext(t))
    26  	require.NoError(t, err)
    27  }
    28  
    29  func TestTransformerConfigValid(t *testing.T) {
    30  	cfg := NewTransformerConfig("test", "test")
    31  	cfg.OutputIDs = []string{"test-output"}
    32  	_, err := cfg.Build(testutil.NewBuildContext(t))
    33  	require.NoError(t, err)
    34  }
    35  
    36  func TestTransformerOnErrorDefault(t *testing.T) {
    37  	cfg := NewTransformerConfig("test-id", "test-type")
    38  	transformer, err := cfg.Build(testutil.NewBuildContext(t))
    39  	require.NoError(t, err)
    40  	require.Equal(t, SendOnError, transformer.OnError)
    41  }
    42  
    43  func TestTransformerOnErrorInvalid(t *testing.T) {
    44  	cfg := NewTransformerConfig("test", "test")
    45  	cfg.OnError = "invalid"
    46  	_, err := cfg.Build(testutil.NewBuildContext(t))
    47  	require.Error(t, err)
    48  	require.Contains(t, err.Error(), "operator config has an invalid `on_error` field.")
    49  }
    50  
    51  func TestTransformerConfigSetNamespace(t *testing.T) {
    52  	cfg := NewTransformerConfig("test-id", "test-type")
    53  	cfg.OutputIDs = []string{"test-output"}
    54  	cfg.SetNamespace("test-namespace")
    55  	require.Equal(t, "test-namespace.test-id", cfg.OperatorID)
    56  	require.Equal(t, "test-namespace.test-output", cfg.OutputIDs[0])
    57  }
    58  
    59  func TestTransformerOperatorCanProcess(t *testing.T) {
    60  	cfg := NewTransformerConfig("test", "test")
    61  	transformer, err := cfg.Build(testutil.NewBuildContext(t))
    62  	require.NoError(t, err)
    63  	require.True(t, transformer.CanProcess())
    64  }
    65  
    66  func TestTransformerDropOnError(t *testing.T) {
    67  	output := &testutil.Operator{}
    68  	output.On("ID").Return("test-output")
    69  	output.On("Process", mock.Anything, mock.Anything).Return(nil)
    70  	buildContext := testutil.NewBuildContext(t)
    71  	transformer := TransformerOperator{
    72  		OnError: DropOnError,
    73  		WriterOperator: WriterOperator{
    74  			BasicOperator: BasicOperator{
    75  				OperatorID:    "test-id",
    76  				OperatorType:  "test-type",
    77  				SugaredLogger: buildContext.Logger,
    78  			},
    79  			OutputOperators: []operator.Operator{output},
    80  			OutputIDs:       []string{"test-output"},
    81  		},
    82  	}
    83  	ctx := context.Background()
    84  	testEntry := entry.New()
    85  	transform := func(e *entry.Entry) (*entry.Entry, error) {
    86  		return e, fmt.Errorf("Failure")
    87  	}
    88  
    89  	err := transformer.ProcessWith(ctx, testEntry, transform)
    90  	require.Error(t, err)
    91  	output.AssertNotCalled(t, "Process", mock.Anything, mock.Anything)
    92  }
    93  
    94  func TestTransformerSendOnError(t *testing.T) {
    95  	output := &testutil.Operator{}
    96  	output.On("ID").Return("test-output")
    97  	output.On("Process", mock.Anything, mock.Anything).Return(nil)
    98  	buildContext := testutil.NewBuildContext(t)
    99  	transformer := TransformerOperator{
   100  		OnError: SendOnError,
   101  		WriterOperator: WriterOperator{
   102  			BasicOperator: BasicOperator{
   103  				OperatorID:    "test-id",
   104  				OperatorType:  "test-type",
   105  				SugaredLogger: buildContext.Logger,
   106  			},
   107  			OutputOperators: []operator.Operator{output},
   108  			OutputIDs:       []string{"test-output"},
   109  		},
   110  	}
   111  	ctx := context.Background()
   112  	testEntry := entry.New()
   113  	transform := func(e *entry.Entry) (*entry.Entry, error) {
   114  		return e, fmt.Errorf("Failure")
   115  	}
   116  
   117  	err := transformer.ProcessWith(ctx, testEntry, transform)
   118  	require.NoError(t, err)
   119  	output.AssertCalled(t, "Process", mock.Anything, mock.Anything)
   120  }
   121  
   122  func TestTransformerProcessWithValid(t *testing.T) {
   123  	output := &testutil.Operator{}
   124  	output.On("ID").Return("test-output")
   125  	output.On("Process", mock.Anything, mock.Anything).Return(nil)
   126  	buildContext := testutil.NewBuildContext(t)
   127  	transformer := TransformerOperator{
   128  		OnError: SendOnError,
   129  		WriterOperator: WriterOperator{
   130  			BasicOperator: BasicOperator{
   131  				OperatorID:    "test-id",
   132  				OperatorType:  "test-type",
   133  				SugaredLogger: buildContext.Logger,
   134  			},
   135  			OutputOperators: []operator.Operator{output},
   136  			OutputIDs:       []string{"test-output"},
   137  		},
   138  	}
   139  	ctx := context.Background()
   140  	testEntry := entry.New()
   141  	transform := func(e *entry.Entry) (*entry.Entry, error) {
   142  		return e, nil
   143  	}
   144  
   145  	err := transformer.ProcessWith(ctx, testEntry, transform)
   146  	require.NoError(t, err)
   147  	output.AssertCalled(t, "Process", mock.Anything, mock.Anything)
   148  }