github.com/netdata/go.d.plugin@v0.58.1/pkg/logs/ltsv_test.go (about)

     1  // SPDX-License-Identifier: GPL-3.0-or-later
     2  
     3  package logs
     4  
     5  import (
     6  	"strings"
     7  	"testing"
     8  
     9  	"github.com/Wing924/ltsv"
    10  	"github.com/stretchr/testify/assert"
    11  	"github.com/stretchr/testify/require"
    12  )
    13  
    14  var testLTSVConfig = LTSVConfig{
    15  	FieldDelimiter: " ",
    16  	ValueDelimiter: "=",
    17  	Mapping:        map[string]string{"KEY": "key"},
    18  }
    19  
    20  func TestNewLTSVParser(t *testing.T) {
    21  	tests := []struct {
    22  		name    string
    23  		config  LTSVConfig
    24  		wantErr bool
    25  	}{
    26  		{name: "config", config: testLTSVConfig},
    27  		{name: "empty config"},
    28  	}
    29  
    30  	for _, tt := range tests {
    31  		t.Run(tt.name, func(t *testing.T) {
    32  			p, err := NewLTSVParser(tt.config, nil)
    33  
    34  			if tt.wantErr {
    35  				assert.Error(t, err)
    36  				assert.Nil(t, p)
    37  			} else {
    38  				assert.NoError(t, err)
    39  				assert.NotNil(t, p)
    40  				if tt.config.FieldDelimiter == "" {
    41  					assert.Equal(t, ltsv.DefaultParser.FieldDelimiter, p.parser.FieldDelimiter)
    42  				} else {
    43  					assert.Equal(t, tt.config.FieldDelimiter, string(p.parser.FieldDelimiter))
    44  				}
    45  				if tt.config.ValueDelimiter == "" {
    46  					assert.Equal(t, ltsv.DefaultParser.ValueDelimiter, p.parser.ValueDelimiter)
    47  				} else {
    48  					assert.Equal(t, tt.config.ValueDelimiter, string(p.parser.ValueDelimiter))
    49  				}
    50  				assert.Equal(t, tt.config.Mapping, p.mapping)
    51  			}
    52  		})
    53  	}
    54  }
    55  
    56  func TestLTSVParser_ReadLine(t *testing.T) {
    57  	tests := []struct {
    58  		name         string
    59  		row          string
    60  		wantErr      bool
    61  		wantParseErr bool
    62  	}{
    63  		{name: "no error", row: "A=1 B=2 KEY=3"},
    64  		{name: "error on parsing", row: "NO LABEL", wantErr: true, wantParseErr: true},
    65  		{name: "error on assigning", row: "A=1 ERR=2", wantErr: true, wantParseErr: true},
    66  		{name: "error on reading EOF", row: "", wantErr: true},
    67  	}
    68  
    69  	for _, tt := range tests {
    70  		t.Run(tt.name, func(t *testing.T) {
    71  			var line logLine
    72  			r := strings.NewReader(tt.row)
    73  			p, err := NewLTSVParser(testLTSVConfig, r)
    74  			require.NoError(t, err)
    75  
    76  			err = p.ReadLine(&line)
    77  
    78  			if tt.wantErr {
    79  				require.Error(t, err)
    80  				if tt.wantParseErr {
    81  					assert.True(t, IsParseError(err))
    82  				} else {
    83  					assert.False(t, IsParseError(err))
    84  				}
    85  			} else {
    86  				assert.NoError(t, err)
    87  			}
    88  		})
    89  	}
    90  }
    91  
    92  func TestLTSVParser_Parse(t *testing.T) {
    93  	tests := []struct {
    94  		name    string
    95  		row     string
    96  		wantErr bool
    97  	}{
    98  		{name: "no error", row: "A=1 B=2"},
    99  		{name: "error on parsing", row: "NO LABEL", wantErr: true},
   100  		{name: "error on assigning", row: "A=1 ERR=2", wantErr: true},
   101  	}
   102  
   103  	for _, tt := range tests {
   104  		t.Run(tt.name, func(t *testing.T) {
   105  			var line logLine
   106  			p, err := NewLTSVParser(testLTSVConfig, nil)
   107  			require.NoError(t, err)
   108  
   109  			err = p.Parse([]byte(tt.row), &line)
   110  
   111  			if tt.wantErr {
   112  				require.Error(t, err)
   113  				assert.True(t, IsParseError(err))
   114  			} else {
   115  				assert.NoError(t, err)
   116  			}
   117  		})
   118  	}
   119  }
   120  
   121  func TestLTSVParser_Info(t *testing.T) {
   122  	p, err := NewLTSVParser(testLTSVConfig, nil)
   123  	require.NoError(t, err)
   124  	assert.NotZero(t, p.Info())
   125  }