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

     1  package helper
     2  
     3  import (
     4  	"context"
     5  	"encoding/json"
     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  	yaml "gopkg.in/yaml.v2"
    14  )
    15  
    16  func TestWriterConfigMissingOutput(t *testing.T) {
    17  	config := WriterConfig{
    18  		BasicConfig: BasicConfig{
    19  			OperatorType: "testtype",
    20  		},
    21  	}
    22  	context := testutil.NewBuildContext(t)
    23  	_, err := config.Build(context)
    24  	require.NoError(t, err)
    25  }
    26  
    27  func TestWriterConfigValidBuild(t *testing.T) {
    28  	config := WriterConfig{
    29  		OutputIDs: OutputIDs{"output"},
    30  		BasicConfig: BasicConfig{
    31  			OperatorType: "testtype",
    32  		},
    33  	}
    34  	context := testutil.NewBuildContext(t)
    35  	_, err := config.Build(context)
    36  	require.NoError(t, err)
    37  }
    38  
    39  func TestWriterConfigSetNamespace(t *testing.T) {
    40  	config := WriterConfig{
    41  		OutputIDs: OutputIDs{"output1", "output2"},
    42  	}
    43  	config.SetNamespace("namespace")
    44  	require.Equal(t, OutputIDs{"namespace.output1", "namespace.output2"}, config.OutputIDs)
    45  }
    46  
    47  func TestWriterOperatorWrite(t *testing.T) {
    48  	output1 := &testutil.Operator{}
    49  	output1.On("Process", mock.Anything, mock.Anything).Return(nil)
    50  	output2 := &testutil.Operator{}
    51  	output2.On("Process", mock.Anything, mock.Anything).Return(nil)
    52  	writer := WriterOperator{
    53  		OutputOperators: []operator.Operator{output1, output2},
    54  	}
    55  
    56  	ctx := context.Background()
    57  	testEntry := entry.New()
    58  
    59  	writer.Write(ctx, testEntry)
    60  	output1.AssertCalled(t, "Process", ctx, mock.Anything)
    61  	output2.AssertCalled(t, "Process", ctx, mock.Anything)
    62  }
    63  
    64  func TestWriterOperatorCanOutput(t *testing.T) {
    65  	writer := WriterOperator{}
    66  	require.True(t, writer.CanOutput())
    67  }
    68  
    69  func TestWriterOperatorOutputs(t *testing.T) {
    70  	output1 := &testutil.Operator{}
    71  	output1.On("Process", mock.Anything, mock.Anything).Return(nil)
    72  	output2 := &testutil.Operator{}
    73  	output2.On("Process", mock.Anything, mock.Anything).Return(nil)
    74  	writer := WriterOperator{
    75  		OutputOperators: []operator.Operator{output1, output2},
    76  	}
    77  
    78  	ctx := context.Background()
    79  	testEntry := entry.New()
    80  
    81  	writer.Write(ctx, testEntry)
    82  	output1.AssertCalled(t, "Process", ctx, mock.Anything)
    83  	output2.AssertCalled(t, "Process", ctx, mock.Anything)
    84  }
    85  
    86  func TestWriterSetOutputsMissing(t *testing.T) {
    87  	output1 := &testutil.Operator{}
    88  	output1.On("ID").Return("output1")
    89  	writer := WriterOperator{
    90  		OutputIDs: OutputIDs{"output2"},
    91  	}
    92  
    93  	err := writer.SetOutputs([]operator.Operator{output1})
    94  	require.Error(t, err)
    95  	require.Contains(t, err.Error(), "does not exist")
    96  }
    97  
    98  func TestWriterSetOutputsInvalid(t *testing.T) {
    99  	output1 := &testutil.Operator{}
   100  	output1.On("ID").Return("output1")
   101  	output1.On("CanProcess").Return(false)
   102  	writer := WriterOperator{
   103  		OutputIDs: OutputIDs{"output1"},
   104  	}
   105  
   106  	err := writer.SetOutputs([]operator.Operator{output1})
   107  	require.Error(t, err)
   108  	require.Contains(t, err.Error(), "can not process entries")
   109  }
   110  
   111  func TestWriterSetOutputsValid(t *testing.T) {
   112  	output1 := &testutil.Operator{}
   113  	output1.On("ID").Return("output1")
   114  	output1.On("CanProcess").Return(true)
   115  	output2 := &testutil.Operator{}
   116  	output2.On("ID").Return("output2")
   117  	output2.On("CanProcess").Return(true)
   118  	writer := WriterOperator{
   119  		OutputIDs: OutputIDs{"output1", "output2"},
   120  	}
   121  
   122  	err := writer.SetOutputs([]operator.Operator{output1, output2})
   123  	require.NoError(t, err)
   124  	require.Equal(t, []operator.Operator{output1, output2}, writer.Outputs())
   125  }
   126  
   127  func TestUnmarshalJSONString(t *testing.T) {
   128  	bytes := []byte("{\"output\":\"test\"}")
   129  	var config WriterConfig
   130  	err := json.Unmarshal(bytes, &config)
   131  	require.NoError(t, err)
   132  	require.Equal(t, OutputIDs{"test"}, config.OutputIDs)
   133  }
   134  
   135  func TestUnmarshalJSONArray(t *testing.T) {
   136  	bytes := []byte("{\"output\":[\"test1\",\"test2\"]}")
   137  	var config WriterConfig
   138  	err := json.Unmarshal(bytes, &config)
   139  	require.NoError(t, err)
   140  	require.Equal(t, OutputIDs{"test1", "test2"}, config.OutputIDs)
   141  }
   142  
   143  func TestUnmarshalJSONInvalidValue(t *testing.T) {
   144  	bytes := []byte("..")
   145  	var config WriterConfig
   146  	err := json.Unmarshal(bytes, &config)
   147  	require.Error(t, err)
   148  	require.Contains(t, err.Error(), "invalid character")
   149  }
   150  
   151  func TestUnmarshalJSONInvalidString(t *testing.T) {
   152  	bytes := []byte("{\"output\": true}")
   153  	var config WriterConfig
   154  	err := json.Unmarshal(bytes, &config)
   155  	require.Error(t, err)
   156  	require.Contains(t, err.Error(), "value is not of type string or string array")
   157  }
   158  
   159  func TestUnmarshalJSONInvalidArray(t *testing.T) {
   160  	bytes := []byte("{\"output\":[\"test1\", true]}")
   161  	var config WriterConfig
   162  	err := json.Unmarshal(bytes, &config)
   163  	require.Error(t, err)
   164  	require.Contains(t, err.Error(), "value in array is not of type string")
   165  }
   166  
   167  func TestUnmarshalYAMLString(t *testing.T) {
   168  	bytes := []byte("output: test")
   169  	var config WriterConfig
   170  	err := yaml.Unmarshal(bytes, &config)
   171  	require.NoError(t, err)
   172  	require.Equal(t, OutputIDs{"test"}, config.OutputIDs)
   173  }
   174  
   175  func TestUnmarshalYAMLArray(t *testing.T) {
   176  	bytes := []byte("output: [test1, test2]")
   177  	var config WriterConfig
   178  	err := yaml.Unmarshal(bytes, &config)
   179  	require.NoError(t, err)
   180  	require.Equal(t, OutputIDs{"test1", "test2"}, config.OutputIDs)
   181  }
   182  
   183  func TestUnmarshalYAMLInvalidValue(t *testing.T) {
   184  	bytes := []byte("..")
   185  	var config WriterConfig
   186  	err := yaml.Unmarshal(bytes, &config)
   187  	require.Error(t, err)
   188  	require.Contains(t, err.Error(), "cannot unmarshal")
   189  }
   190  
   191  func TestUnmarshalYAMLInvalidString(t *testing.T) {
   192  	bytes := []byte("output: true")
   193  	var config WriterConfig
   194  	err := yaml.Unmarshal(bytes, &config)
   195  	require.Error(t, err)
   196  	require.Contains(t, err.Error(), "value is not of type string or string array")
   197  }
   198  
   199  func TestUnmarshalYAMLInvalidArray(t *testing.T) {
   200  	bytes := []byte("output: [test1, true]")
   201  	var config WriterConfig
   202  	err := yaml.Unmarshal(bytes, &config)
   203  	require.Error(t, err)
   204  	require.Contains(t, err.Error(), "value in array is not of type string")
   205  }