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

     1  package helper
     2  
     3  import (
     4  	"context"
     5  	"testing"
     6  
     7  	"github.com/observiq/carbon/entry"
     8  	"github.com/observiq/carbon/testutil"
     9  	"github.com/stretchr/testify/require"
    10  )
    11  
    12  func TestInputConfigMissingBase(t *testing.T) {
    13  	config := InputConfig{
    14  		WriteTo: entry.Field{},
    15  		WriterConfig: WriterConfig{
    16  			OutputIDs: []string{"test-output"},
    17  		},
    18  	}
    19  	context := testutil.NewBuildContext(t)
    20  	_, err := config.Build(context)
    21  	require.Error(t, err)
    22  	require.Contains(t, err.Error(), "missing required `type` field.")
    23  }
    24  
    25  func TestInputConfigMissingOutput(t *testing.T) {
    26  	config := InputConfig{
    27  		WriterConfig: WriterConfig{
    28  			BasicConfig: BasicConfig{
    29  				OperatorID:   "test-id",
    30  				OperatorType: "test-type",
    31  			},
    32  		},
    33  		WriteTo: entry.Field{},
    34  	}
    35  	context := testutil.NewBuildContext(t)
    36  	_, err := config.Build(context)
    37  	require.NoError(t, err)
    38  }
    39  
    40  func TestInputConfigValid(t *testing.T) {
    41  	config := InputConfig{
    42  		WriteTo: entry.Field{},
    43  		WriterConfig: WriterConfig{
    44  			BasicConfig: BasicConfig{
    45  				OperatorID:   "test-id",
    46  				OperatorType: "test-type",
    47  			},
    48  			OutputIDs: []string{"test-output"},
    49  		},
    50  	}
    51  	context := testutil.NewBuildContext(t)
    52  	_, err := config.Build(context)
    53  	require.NoError(t, err)
    54  }
    55  
    56  func TestInputConfigSetNamespace(t *testing.T) {
    57  	config := InputConfig{
    58  		WriteTo: entry.Field{},
    59  		WriterConfig: WriterConfig{
    60  			BasicConfig: BasicConfig{
    61  				OperatorID:   "test-id",
    62  				OperatorType: "test-type",
    63  			},
    64  			OutputIDs: []string{"test-output"},
    65  		},
    66  	}
    67  	config.SetNamespace("test-namespace")
    68  	require.Equal(t, "test-namespace.test-id", config.OperatorID)
    69  	require.Equal(t, "test-namespace.test-output", config.OutputIDs[0])
    70  }
    71  
    72  func TestInputOperatorCanProcess(t *testing.T) {
    73  	buildContext := testutil.NewBuildContext(t)
    74  	input := InputOperator{
    75  		WriterOperator: WriterOperator{
    76  			BasicOperator: BasicOperator{
    77  				OperatorID:    "test-id",
    78  				OperatorType:  "test-type",
    79  				SugaredLogger: buildContext.Logger,
    80  			},
    81  		},
    82  	}
    83  	require.False(t, input.CanProcess())
    84  }
    85  
    86  func TestInputOperatorProcess(t *testing.T) {
    87  	buildContext := testutil.NewBuildContext(t)
    88  	input := InputOperator{
    89  		WriterOperator: WriterOperator{
    90  			BasicOperator: BasicOperator{
    91  				OperatorID:    "test-id",
    92  				OperatorType:  "test-type",
    93  				SugaredLogger: buildContext.Logger,
    94  			},
    95  		},
    96  	}
    97  	entry := entry.New()
    98  	ctx := context.Background()
    99  	err := input.Process(ctx, entry)
   100  	require.Error(t, err)
   101  	require.Equal(t, err.Error(), "Operator can not process logs.")
   102  }
   103  
   104  func TestInputOperatorNewEntry(t *testing.T) {
   105  	buildContext := testutil.NewBuildContext(t)
   106  	writeTo := entry.NewRecordField("test-field")
   107  
   108  	labelExpr, err := ExprStringConfig("test").Build()
   109  	require.NoError(t, err)
   110  
   111  	resourceExpr, err := ExprStringConfig("resource").Build()
   112  	require.NoError(t, err)
   113  
   114  	input := InputOperator{
   115  		Labeler: Labeler{
   116  			labels: map[string]*ExprString{
   117  				"test-label": labelExpr,
   118  			},
   119  		},
   120  		Identifier: Identifier{
   121  			resource: map[string]*ExprString{
   122  				"resource-key": resourceExpr,
   123  			},
   124  		},
   125  		WriterOperator: WriterOperator{
   126  			BasicOperator: BasicOperator{
   127  				OperatorID:    "test-id",
   128  				OperatorType:  "test-type",
   129  				SugaredLogger: buildContext.Logger,
   130  			},
   131  		},
   132  		WriteTo: writeTo,
   133  	}
   134  
   135  	entry, err := input.NewEntry("test")
   136  	require.NoError(t, err)
   137  
   138  	value, exists := entry.Get(writeTo)
   139  	require.True(t, exists)
   140  	require.Equal(t, "test", value)
   141  
   142  	labelValue, exists := entry.Labels["test-label"]
   143  	require.True(t, exists)
   144  	require.Equal(t, "test", labelValue)
   145  
   146  	resourceValue, exists := entry.Resource["resource-key"]
   147  	require.True(t, exists)
   148  	require.Equal(t, "resource", resourceValue)
   149  }