github.com/observiq/carbon@v0.9.11-0.20200820160507-1b872e368a5e/operator/builtin/transformer/metadata_test.go (about)

     1  package transformer
     2  
     3  import (
     4  	"context"
     5  	"os"
     6  	"testing"
     7  	"time"
     8  
     9  	"github.com/observiq/carbon/entry"
    10  	"github.com/observiq/carbon/operator"
    11  	"github.com/observiq/carbon/operator/helper"
    12  	"github.com/observiq/carbon/testutil"
    13  	"github.com/stretchr/testify/mock"
    14  	"github.com/stretchr/testify/require"
    15  )
    16  
    17  func TestMetadata(t *testing.T) {
    18  	os.Setenv("TEST_METADATA_PLUGIN_ENV", "foo")
    19  	defer os.Unsetenv("TEST_METADATA_PLUGIN_ENV")
    20  
    21  	baseConfig := func() *MetadataOperatorConfig {
    22  		cfg := NewMetadataOperatorConfig("test_operator_id")
    23  		cfg.OutputIDs = []string{"output1"}
    24  		return cfg
    25  	}
    26  
    27  	cases := []struct {
    28  		name     string
    29  		config   *MetadataOperatorConfig
    30  		input    *entry.Entry
    31  		expected *entry.Entry
    32  	}{
    33  		{
    34  			"AddLabelLiteral",
    35  			func() *MetadataOperatorConfig {
    36  				cfg := baseConfig()
    37  				cfg.Labels = map[string]helper.ExprStringConfig{
    38  					"label1": "value1",
    39  				}
    40  				return cfg
    41  			}(),
    42  			entry.New(),
    43  			func() *entry.Entry {
    44  				e := entry.New()
    45  				e.Labels = map[string]string{
    46  					"label1": "value1",
    47  				}
    48  				return e
    49  			}(),
    50  		},
    51  		{
    52  			"AddLabelExpr",
    53  			func() *MetadataOperatorConfig {
    54  				cfg := baseConfig()
    55  				cfg.Labels = map[string]helper.ExprStringConfig{
    56  					"label1": `EXPR("start" + "end")`,
    57  				}
    58  				return cfg
    59  			}(),
    60  			entry.New(),
    61  			func() *entry.Entry {
    62  				e := entry.New()
    63  				e.Labels = map[string]string{
    64  					"label1": "startend",
    65  				}
    66  				return e
    67  			}(),
    68  		},
    69  		{
    70  			"AddLabelEnv",
    71  			func() *MetadataOperatorConfig {
    72  				cfg := baseConfig()
    73  				cfg.Labels = map[string]helper.ExprStringConfig{
    74  					"label1": `EXPR(env("TEST_METADATA_PLUGIN_ENV"))`,
    75  				}
    76  				return cfg
    77  			}(),
    78  			entry.New(),
    79  			func() *entry.Entry {
    80  				e := entry.New()
    81  				e.Labels = map[string]string{
    82  					"label1": "foo",
    83  				}
    84  				return e
    85  			}(),
    86  		},
    87  		{
    88  			"AddResourceLiteral",
    89  			func() *MetadataOperatorConfig {
    90  				cfg := baseConfig()
    91  				cfg.Resource = map[string]helper.ExprStringConfig{
    92  					"key1": "value1",
    93  				}
    94  				return cfg
    95  			}(),
    96  			entry.New(),
    97  			func() *entry.Entry {
    98  				e := entry.New()
    99  				e.Resource = map[string]string{
   100  					"key1": "value1",
   101  				}
   102  				return e
   103  			}(),
   104  		},
   105  		{
   106  			"AddResourceExpr",
   107  			func() *MetadataOperatorConfig {
   108  				cfg := baseConfig()
   109  				cfg.Resource = map[string]helper.ExprStringConfig{
   110  					"key1": `EXPR("start" + "end")`,
   111  				}
   112  				return cfg
   113  			}(),
   114  			entry.New(),
   115  			func() *entry.Entry {
   116  				e := entry.New()
   117  				e.Resource = map[string]string{
   118  					"key1": "startend",
   119  				}
   120  				return e
   121  			}(),
   122  		},
   123  		{
   124  			"AddResourceEnv",
   125  			func() *MetadataOperatorConfig {
   126  				cfg := baseConfig()
   127  				cfg.Resource = map[string]helper.ExprStringConfig{
   128  					"key1": `EXPR(env("TEST_METADATA_PLUGIN_ENV"))`,
   129  				}
   130  				return cfg
   131  			}(),
   132  			entry.New(),
   133  			func() *entry.Entry {
   134  				e := entry.New()
   135  				e.Resource = map[string]string{
   136  					"key1": "foo",
   137  				}
   138  				return e
   139  			}(),
   140  		},
   141  	}
   142  
   143  	for _, tc := range cases {
   144  		t.Run(tc.name, func(t *testing.T) {
   145  			metadataOperator, err := tc.config.Build(testutil.NewBuildContext(t))
   146  			require.NoError(t, err)
   147  
   148  			mockOutput := testutil.NewMockOperator("output1")
   149  			entryChan := make(chan *entry.Entry, 1)
   150  			mockOutput.On("Process", mock.Anything, mock.Anything).Run(func(args mock.Arguments) {
   151  				entryChan <- args.Get(1).(*entry.Entry)
   152  			}).Return(nil)
   153  
   154  			err = metadataOperator.SetOutputs([]operator.Operator{mockOutput})
   155  			require.NoError(t, err)
   156  
   157  			err = metadataOperator.Process(context.Background(), tc.input)
   158  			require.NoError(t, err)
   159  
   160  			select {
   161  			case e := <-entryChan:
   162  				require.Equal(t, e.Labels, tc.expected.Labels)
   163  				require.Equal(t, e.Resource, tc.expected.Resource)
   164  			case <-time.After(time.Second):
   165  				require.FailNow(t, "Timed out waiting for entry to be processed")
   166  			}
   167  		})
   168  	}
   169  }