github.com/alibaba/ilogtail/pkg@v0.0.0-20250526110833-c53b480d046c/protocol/converter/converter_raw_test.go (about)

     1  package protocol
     2  
     3  import (
     4  	"fmt"
     5  	"testing"
     6  
     7  	"github.com/stretchr/testify/assert"
     8  
     9  	"github.com/alibaba/ilogtail/pkg/models"
    10  )
    11  
    12  func TestConverter_ConvertToRawStream(t *testing.T) {
    13  	type fields struct {
    14  		Protocol             string
    15  		Encoding             string
    16  		Separator            string
    17  		TagKeyRenameMap      map[string]string
    18  		ProtocolKeyRenameMap map[string]string
    19  	}
    20  	type args struct {
    21  		groupEvents  *models.PipelineGroupEvents
    22  		targetFields []string
    23  	}
    24  	mockValidFields := fields{
    25  		Protocol:  ProtocolRaw,
    26  		Encoding:  EncodingCustom,
    27  		Separator: "\n",
    28  	}
    29  	mockInvalidFields := fields{
    30  		Protocol: ProtocolRaw,
    31  		Encoding: EncodingJSON,
    32  	}
    33  	mockGroup := models.NewGroup(models.NewMetadataWithMap(map[string]string{"db": "test"}), nil)
    34  	mockByteEvent := []byte("cpu.load.short,host=server01,region=cn value=0.6")
    35  	tests := []struct {
    36  		name       string
    37  		fields     fields
    38  		args       args
    39  		wantStream [][]byte
    40  		wantValues []map[string]string
    41  		wantErr    assert.ErrorAssertionFunc
    42  	}{
    43  		{
    44  			name:   "single byte event",
    45  			fields: mockValidFields,
    46  			args: args{
    47  				groupEvents: &models.PipelineGroupEvents{Group: mockGroup,
    48  					Events: []models.PipelineEvent{models.ByteArray(mockByteEvent)}},
    49  				targetFields: []string{"metadata.db"},
    50  			},
    51  			wantStream: [][]byte{mockByteEvent},
    52  			wantValues: []map[string]string{{"metadata.db": "test"}},
    53  			wantErr:    assert.NoError,
    54  		}, {
    55  			name:   "multiple events",
    56  			fields: mockValidFields,
    57  			args: args{
    58  				groupEvents: &models.PipelineGroupEvents{Group: mockGroup,
    59  					Events: []models.PipelineEvent{models.ByteArray(mockByteEvent), models.ByteArray(mockByteEvent)}},
    60  				targetFields: []string{"metadata.db"},
    61  			},
    62  			wantStream: [][]byte{append(append(mockByteEvent, "\n"...), mockByteEvent...)},
    63  			wantValues: []map[string]string{{"metadata.db": "test"}},
    64  			wantErr:    assert.NoError,
    65  		}, {
    66  			name:   "unsupported metric event type",
    67  			fields: mockInvalidFields,
    68  			args: args{
    69  				groupEvents: &models.PipelineGroupEvents{Group: mockGroup,
    70  					Events: []models.PipelineEvent{&models.Metric{
    71  						Name:      "cpu.load.short",
    72  						Timestamp: 0,
    73  						Tags:      models.NewTagsWithKeyValues("host", "server01", "region", "cn"),
    74  						Value:     &models.MetricSingleValue{Value: 0.64},
    75  					}, models.ByteArray(mockByteEvent)}},
    76  				targetFields: []string{"metadata.db"},
    77  			},
    78  			wantStream: nil,
    79  			wantValues: nil,
    80  			wantErr:    assert.Error,
    81  		},
    82  	}
    83  	for _, tt := range tests {
    84  		t.Run(tt.name, func(t *testing.T) {
    85  			c := &Converter{
    86  				Protocol:             tt.fields.Protocol,
    87  				Encoding:             tt.fields.Encoding,
    88  				Separator:            tt.fields.Separator,
    89  				TagKeyRenameMap:      tt.fields.TagKeyRenameMap,
    90  				ProtocolKeyRenameMap: tt.fields.ProtocolKeyRenameMap,
    91  			}
    92  			gotStream, gotValues, err := c.ConvertToRawStream(tt.args.groupEvents, tt.args.targetFields)
    93  			if !tt.wantErr(t, err, fmt.Sprintf("ConvertToRawStream(%v, %v)", tt.args.groupEvents, tt.args.targetFields)) {
    94  				return
    95  			}
    96  			assert.Equalf(t, tt.wantStream, gotStream, "ConvertToRawStream(%v, %v)", tt.args.groupEvents, tt.args.targetFields)
    97  			assert.Equalf(t, tt.wantValues, gotValues, "ConvertToRawStream(%v, %v)", tt.args.groupEvents, tt.args.targetFields)
    98  		})
    99  	}
   100  }
   101  
   102  func TestConverter_ConvertToRawStreamSeparator(t *testing.T) {
   103  	type fields struct {
   104  		Protocol             string
   105  		Encoding             string
   106  		Separator            string
   107  		TagKeyRenameMap      map[string]string
   108  		ProtocolKeyRenameMap map[string]string
   109  	}
   110  	type args struct {
   111  		groupEvents  *models.PipelineGroupEvents
   112  		targetFields []string
   113  	}
   114  	mockFieldsWithSep := fields{
   115  		Protocol:  ProtocolRaw,
   116  		Encoding:  EncodingCustom,
   117  		Separator: "\r\n",
   118  	}
   119  	mockFieldsWithoutSep := fields{
   120  		Protocol: ProtocolRaw,
   121  		Encoding: EncodingJSON,
   122  	}
   123  	mockGroup := models.NewGroup(models.NewMetadataWithMap(map[string]string{"db": "test"}), nil)
   124  	mockByteEvent := []byte("cpu.load.short,host=server01,region=cn value=0.6")
   125  	tests := []struct {
   126  		name       string
   127  		fields     fields
   128  		args       args
   129  		wantStream [][]byte
   130  		wantValues []map[string]string
   131  		wantErr    assert.ErrorAssertionFunc
   132  	}{
   133  		{
   134  			name:   "join with sep",
   135  			fields: mockFieldsWithSep,
   136  			args: args{
   137  				groupEvents: &models.PipelineGroupEvents{Group: mockGroup,
   138  					Events: []models.PipelineEvent{models.ByteArray(mockByteEvent), models.ByteArray(mockByteEvent)}},
   139  				targetFields: []string{"metadata.db"},
   140  			},
   141  			wantStream: [][]byte{append(append(mockByteEvent, "\r\n"...), mockByteEvent...)},
   142  			wantValues: []map[string]string{{"metadata.db": "test"}},
   143  			wantErr:    assert.NoError,
   144  		}, {
   145  			name:   "not join",
   146  			fields: mockFieldsWithoutSep,
   147  			args: args{
   148  				groupEvents: &models.PipelineGroupEvents{Group: mockGroup,
   149  					Events: []models.PipelineEvent{models.ByteArray(mockByteEvent), models.ByteArray(mockByteEvent)}},
   150  				targetFields: []string{"metadata.db"},
   151  			},
   152  			wantStream: [][]byte{mockByteEvent, mockByteEvent},
   153  			wantValues: []map[string]string{{"metadata.db": "test"}, {"metadata.db": "test"}},
   154  			wantErr:    assert.NoError,
   155  		},
   156  	}
   157  	for _, tt := range tests {
   158  		t.Run(tt.name, func(t *testing.T) {
   159  			c := &Converter{
   160  				Protocol:             tt.fields.Protocol,
   161  				Encoding:             tt.fields.Encoding,
   162  				Separator:            tt.fields.Separator,
   163  				TagKeyRenameMap:      tt.fields.TagKeyRenameMap,
   164  				ProtocolKeyRenameMap: tt.fields.ProtocolKeyRenameMap,
   165  			}
   166  			gotStream, gotValues, err := c.ConvertToRawStream(tt.args.groupEvents, tt.args.targetFields)
   167  			if !tt.wantErr(t, err, fmt.Sprintf("ConvertToRawStream(%v, %v)", tt.args.groupEvents, tt.args.targetFields)) {
   168  				return
   169  			}
   170  			assert.Equalf(t, tt.wantStream, gotStream, "ConvertToRawStream(%v, %v)", tt.args.groupEvents, tt.args.targetFields)
   171  			assert.Equalf(t, tt.wantValues, gotValues, "ConvertToRawStream(%v, %v)", tt.args.groupEvents, tt.args.targetFields)
   172  		})
   173  	}
   174  }
   175  
   176  func Test_findTargetFieldsInGroup(t *testing.T) {
   177  	type args struct {
   178  		targetFields []string
   179  		group        *models.GroupInfo
   180  	}
   181  	tests := []struct {
   182  		name string
   183  		args args
   184  		want map[string]string
   185  	}{
   186  		{name: "find metadata fields",
   187  			args: args{
   188  				targetFields: []string{"metadata.db"},
   189  				group:        models.NewGroup(models.NewMetadataWithMap(map[string]string{"db": "test"}), nil),
   190  			}, want: map[string]string{"metadata.db": "test"},
   191  		},
   192  		{
   193  			name: "find tags fields",
   194  			args: args{
   195  				targetFields: []string{"tag.tagKey"},
   196  				group:        models.NewGroup(nil, models.NewTagsWithMap(map[string]string{"tagKey": "tagValue"})),
   197  			}, want: map[string]string{"tag.tagKey": "tagValue"},
   198  		},
   199  		{name: "can not find metadata fields",
   200  			args: args{
   201  				targetFields: []string{"metadata.db"},
   202  				group:        models.NewGroup(models.NewMetadataWithMap(map[string]string{"nodb": "test"}), nil),
   203  			}, want: map[string]string{"metadata.db": ""},
   204  		},
   205  		{
   206  			name: "can not find tags fields",
   207  			args: args{
   208  				targetFields: []string{"tag.tagKey"},
   209  				group:        models.NewGroup(nil, models.NewTagsWithMap(map[string]string{"noTagKey": "tagValue"})),
   210  			}, want: map[string]string{"tag.tagKey": ""},
   211  		},
   212  	}
   213  	for _, tt := range tests {
   214  		t.Run(tt.name, func(t *testing.T) {
   215  			assert.Equalf(t, tt.want, findTargetFieldsInGroup(tt.args.targetFields, tt.args.group), "findTargetFieldsInGroup(%v, %v)", tt.args.targetFields, tt.args.group)
   216  		})
   217  	}
   218  }