github.com/GuanceCloud/cliutils@v1.1.21/pipeline/manager/msgstatus_test.go (about)

     1  // Unless explicitly stated otherwise all files in this repository are licensed
     2  // under the MIT License.
     3  // This product includes software developed at Guance Cloud (https://www.guance.com/).
     4  // Copyright 2021-present Guance, Inc.
     5  
     6  package manager
     7  
     8  import (
     9  	"testing"
    10  	"time"
    11  
    12  	"github.com/GuanceCloud/cliutils/pipeline/ptinput"
    13  	"github.com/GuanceCloud/cliutils/point"
    14  	"github.com/stretchr/testify/assert"
    15  )
    16  
    17  type pt4t struct {
    18  	Fields map[string]interface{}
    19  	Tags   map[string]string
    20  	Drop   bool
    21  }
    22  
    23  func BenchmarkGTags(b *testing.B) {
    24  	b.Run("test-list", func(b *testing.B) {
    25  		s := [][2]string{{"1"}, {"2"}, {"3"}, {"4"}, {"5"}, {"6"}}
    26  		b.ResetTimer()
    27  		for i := 0; i < b.N; i++ {
    28  			for idx := range s {
    29  				_ = s[idx][0]
    30  				_ = s[idx][1]
    31  			}
    32  		}
    33  	})
    34  
    35  	b.Run("test-map", func(b *testing.B) {
    36  		s := map[string]string{
    37  			"1": "",
    38  			"2": "",
    39  			"3": "",
    40  			"4": "",
    41  			"5": "",
    42  			"6": "",
    43  		}
    44  		b.ResetTimer()
    45  		for i := 0; i < b.N; i++ {
    46  			for k, v := range s {
    47  				_ = k
    48  				_ = v
    49  			}
    50  		}
    51  	})
    52  }
    53  
    54  func TestStatus(t *testing.T) {
    55  	for k, v := range statusMap {
    56  		outp := &pt4t{
    57  			Fields: map[string]interface{}{
    58  				FieldStatus: k,
    59  			},
    60  		}
    61  		pt := ptinput.NewPlPoint(point.Logging, "", nil, outp.Fields, time.Now())
    62  		ProcLoggingStatus(pt, false, nil)
    63  		assert.Equal(t, v, pt.Fields()[FieldStatus])
    64  	}
    65  
    66  	{
    67  		outp := &pt4t{
    68  			Fields: map[string]interface{}{
    69  				FieldStatus:  "x",
    70  				FieldMessage: "1234567891011",
    71  			},
    72  		}
    73  		pt := ptinput.NewPlPoint(point.Logging, "", nil, outp.Fields, time.Now())
    74  		ProcLoggingStatus(pt, false, nil)
    75  		assert.Equal(t, "x", pt.Fields()[FieldStatus])
    76  		assert.Equal(t, "1234567891011", pt.Fields()[FieldMessage])
    77  	}
    78  
    79  	{
    80  		outp := &pt4t{
    81  			Fields: map[string]interface{}{
    82  				FieldStatus:  "x",
    83  				FieldMessage: "1234567891011",
    84  			},
    85  			Tags: map[string]string{
    86  				"xxxqqqddd": "1234567891011",
    87  			},
    88  		}
    89  		pt := ptinput.NewPlPoint(point.Logging, "", outp.Tags, outp.Fields, time.Now())
    90  		ProcLoggingStatus(pt, false, nil)
    91  		assert.Equal(t, map[string]interface{}{
    92  			FieldStatus:  "x",
    93  			FieldMessage: "1234567891011",
    94  		}, pt.Fields())
    95  		assert.Equal(t, map[string]string{
    96  			"xxxqqqddd": "1234567891011",
    97  		}, pt.Tags())
    98  	}
    99  
   100  	{
   101  		outp := &pt4t{
   102  			Fields: map[string]interface{}{
   103  				FieldStatus:  "n",
   104  				FieldMessage: "1234567891011",
   105  			},
   106  			Tags: map[string]string{
   107  				"xxxqqqddd": "1234567891011",
   108  			},
   109  		}
   110  		pt := ptinput.NewPlPoint(point.Logging, "", outp.Tags, outp.Fields, time.Now())
   111  		ProcLoggingStatus(pt, false, nil)
   112  		assert.Equal(t, map[string]interface{}{
   113  			FieldStatus:  "notice",
   114  			FieldMessage: "1234567891011",
   115  		}, pt.Fields())
   116  		assert.Equal(t, map[string]string{
   117  			"xxxqqqddd": "1234567891011",
   118  		}, pt.Tags())
   119  	}
   120  }
   121  
   122  func TestGetSetStatus(t *testing.T) {
   123  	out := &pt4t{
   124  		Tags: map[string]string{
   125  			"status": "n",
   126  		},
   127  		Fields: make(map[string]interface{}),
   128  	}
   129  
   130  	pt := ptinput.NewPlPoint(point.Logging, "", out.Tags, out.Fields, time.Now())
   131  	ProcLoggingStatus(pt, false, nil)
   132  	assert.Equal(t, map[string]string{
   133  		"status": "notice",
   134  	}, pt.Tags())
   135  	assert.Equal(t, make(map[string]interface{}), pt.Fields())
   136  
   137  	out.Fields = map[string]interface{}{
   138  		"status": "n",
   139  	}
   140  	out.Tags = make(map[string]string)
   141  	pt = ptinput.NewPlPoint(point.Logging, "", out.Tags, out.Fields, time.Now())
   142  
   143  	ProcLoggingStatus(pt, false, nil)
   144  	assert.Equal(t, map[string]interface{}{
   145  		"status": "notice",
   146  	}, pt.Fields())
   147  	assert.Equal(t, make(map[string]string), pt.Tags())
   148  
   149  	out.Fields = map[string]interface{}{
   150  		"status": "n",
   151  	}
   152  	out.Tags = map[string]string{
   153  		"status": "n",
   154  	}
   155  
   156  	pt = ptinput.NewPlPoint(point.Logging, "", out.Tags, out.Fields, time.Now())
   157  	ProcLoggingStatus(pt, false, nil)
   158  	assert.Equal(t, map[string]string{
   159  		"status": "notice",
   160  	}, pt.Tags())
   161  	assert.Equal(t, map[string]interface{}{
   162  		"status": "n",
   163  	}, pt.Fields())
   164  
   165  	pt = ptinput.NewPlPoint(point.Logging, "", out.Tags, out.Fields, time.Now())
   166  	ProcLoggingStatus(pt, false, []string{"notice"})
   167  	assert.Equal(t, map[string]string{
   168  		"status": "notice",
   169  	}, pt.Tags())
   170  	assert.Equal(t, map[string]interface{}{
   171  		"status": "n",
   172  	}, pt.Fields())
   173  }