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

     1  package parser
     2  
     3  import (
     4  	"context"
     5  	"regexp"
     6  	"testing"
     7  
     8  	"github.com/observiq/carbon/entry"
     9  	"github.com/observiq/carbon/operator"
    10  	"github.com/observiq/carbon/operator/helper"
    11  	"github.com/observiq/carbon/testutil"
    12  	"github.com/stretchr/testify/mock"
    13  	"github.com/stretchr/testify/require"
    14  )
    15  
    16  func newFakeRegexParser() (*RegexParser, *testutil.Operator) {
    17  	mockOperator := testutil.Operator{}
    18  	return &RegexParser{
    19  		ParserOperator: helper.ParserOperator{
    20  			TransformerOperator: helper.TransformerOperator{
    21  				WriterOperator: helper.WriterOperator{
    22  					BasicOperator: helper.BasicOperator{
    23  						OperatorID:   "regex_parser",
    24  						OperatorType: "regex_parser",
    25  					},
    26  					OutputIDs:       []string{"mock_output"},
    27  					OutputOperators: []operator.Operator{&mockOperator},
    28  				},
    29  			},
    30  			ParseFrom: entry.NewRecordField(),
    31  			ParseTo:   entry.NewRecordField(),
    32  		},
    33  	}, &mockOperator
    34  }
    35  
    36  func TestParserRegex(t *testing.T) {
    37  	cases := []struct {
    38  		name         string
    39  		configure    func(*RegexParser)
    40  		inputRecord  interface{}
    41  		outputRecord interface{}
    42  	}{
    43  		{
    44  			"RootString",
    45  			func(p *RegexParser) {
    46  				p.regexp = regexp.MustCompile("a=(?P<a>.*)")
    47  			},
    48  			"a=b",
    49  			map[string]interface{}{
    50  				"a": "b",
    51  			},
    52  		},
    53  		{
    54  			"RootBytes",
    55  			func(p *RegexParser) {
    56  				p.regexp = regexp.MustCompile("a=(?P<a>.*)")
    57  			},
    58  			[]byte("a=b"),
    59  			map[string]interface{}{
    60  				"a": "b",
    61  			},
    62  		},
    63  	}
    64  
    65  	for _, tc := range cases {
    66  		t.Run(tc.name, func(t *testing.T) {
    67  			parser, mockOutput := newFakeRegexParser()
    68  			tc.configure(parser)
    69  
    70  			var parsedRecord interface{}
    71  			mockOutput.On("Process", mock.Anything, mock.Anything).Return(nil).Run(func(args mock.Arguments) {
    72  				parsedRecord = args.Get(1).(*entry.Entry).Record
    73  			})
    74  
    75  			entry := entry.Entry{
    76  				Record: tc.inputRecord,
    77  			}
    78  			err := parser.Process(context.Background(), &entry)
    79  			require.NoError(t, err)
    80  
    81  			require.Equal(t, tc.outputRecord, parsedRecord)
    82  
    83  		})
    84  	}
    85  }
    86  
    87  func TestBuildParserRegex(t *testing.T) {
    88  	newBasicRegexParser := func() *RegexParserConfig {
    89  		cfg := NewRegexParserConfig("test")
    90  		cfg.OutputIDs = []string{"test"}
    91  		cfg.Regex = "(?P<all>.*)"
    92  		return cfg
    93  	}
    94  
    95  	t.Run("BasicConfig", func(t *testing.T) {
    96  		c := newBasicRegexParser()
    97  		_, err := c.Build(testutil.NewBuildContext(t))
    98  		require.NoError(t, err)
    99  	})
   100  
   101  	t.Run("MissingRegexField", func(t *testing.T) {
   102  		c := newBasicRegexParser()
   103  		c.Regex = ""
   104  		_, err := c.Build(testutil.NewBuildContext(t))
   105  		require.Error(t, err)
   106  	})
   107  
   108  	t.Run("InvalidRegexField", func(t *testing.T) {
   109  		c := newBasicRegexParser()
   110  		c.Regex = "())()"
   111  		_, err := c.Build(testutil.NewBuildContext(t))
   112  		require.Error(t, err)
   113  	})
   114  
   115  	t.Run("NoNamedGroups", func(t *testing.T) {
   116  		c := newBasicRegexParser()
   117  		c.Regex = ".*"
   118  		_, err := c.Build(testutil.NewBuildContext(t))
   119  		require.Error(t, err)
   120  		require.Contains(t, err.Error(), "no named capture groups")
   121  	})
   122  
   123  	t.Run("NoNamedGroups", func(t *testing.T) {
   124  		c := newBasicRegexParser()
   125  		c.Regex = "(.*)"
   126  		_, err := c.Build(testutil.NewBuildContext(t))
   127  		require.Error(t, err)
   128  		require.Contains(t, err.Error(), "no named capture groups")
   129  	})
   130  }