github.com/GuanceCloud/cliutils@v1.1.21/point/equal_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 point
     7  
     8  import (
     9  	T "testing"
    10  	"time"
    11  
    12  	"github.com/stretchr/testify/assert"
    13  )
    14  
    15  func TestEqual(t *T.T) {
    16  	DefaultEncoding = Protobuf // set protobuf the default encoding
    17  
    18  	cases := []struct {
    19  		name        string
    20  		l, r        *Point
    21  		expectEqual bool
    22  	}{
    23  		{
    24  			name:        "basic",
    25  			expectEqual: true,
    26  			l: func() *Point {
    27  				x, err := NewPoint("abc", nil,
    28  					map[string]interface{}{"f1": 123.1},
    29  					WithTime(time.Unix(0, 123)))
    30  				assert.NoError(t, err)
    31  				return x
    32  			}(),
    33  			r: func() *Point {
    34  				x, err := NewPoint("abc", nil,
    35  					map[string]interface{}{"f1": 123.1},
    36  					WithTime(time.Unix(0, 123)))
    37  				assert.NoError(t, err)
    38  				return x
    39  			}(),
    40  		},
    41  
    42  		{
    43  			name:        "time-not-equal",
    44  			expectEqual: false,
    45  			l: func() *Point {
    46  				x, err := NewPoint("abc", nil,
    47  					map[string]interface{}{"f1": 123.1},
    48  					WithTime(time.Unix(0, 123)))
    49  				assert.NoError(t, err)
    50  				return x
    51  			}(),
    52  			r: func() *Point {
    53  				x, err := NewPoint("abc", nil,
    54  					map[string]interface{}{"f1": 123.1},
    55  					WithTime(time.Unix(1, 0)))
    56  				assert.NoError(t, err)
    57  				return x
    58  			}(),
    59  		},
    60  
    61  		{
    62  			name:        "with-warns",
    63  			expectEqual: true,
    64  			l: func() *Point {
    65  				x, err := NewPoint("abc",
    66  					map[string]string{"t1": "v1"},
    67  					map[string]interface{}{"f1": 123.1},
    68  					WithTime(time.Unix(0, 123)))
    69  				assert.NoError(t, err)
    70  				return x
    71  			}(),
    72  			r: func() *Point {
    73  				x, err := NewPoint("abc",
    74  					map[string]string{"t1": "v1"},
    75  					map[string]interface{}{
    76  						"f1": 123.1,
    77  						"t1": "duplicated-tag-key", // duplicated key
    78  					},
    79  					WithTime(time.Unix(0, 123)))
    80  				assert.NoError(t, err)
    81  				return x
    82  			}(),
    83  		},
    84  
    85  		{
    86  			name:        "tags-not-equal",
    87  			expectEqual: false,
    88  			l: func() *Point {
    89  				x, err := NewPoint("abc",
    90  					map[string]string{"t1": "v1"},
    91  					map[string]interface{}{"f1": 123.1},
    92  					WithTime(time.Unix(0, 123)))
    93  				assert.NoError(t, err)
    94  				return x
    95  			}(),
    96  			r: func() *Point {
    97  				x, err := NewPoint("abc",
    98  					map[string]string{"t1": "v1", "t2": "v2"},
    99  					map[string]interface{}{"f1": 123.1},
   100  					WithTime(time.Unix(0, 123)))
   101  				assert.NoError(t, err)
   102  				return x
   103  			}(),
   104  		},
   105  
   106  		{
   107  			name:        "measurement-name-not-equal",
   108  			expectEqual: false,
   109  			l: func() *Point {
   110  				x, err := NewPoint("abc",
   111  					map[string]string{"t1": "v1"},
   112  					map[string]interface{}{"f1": 123.1},
   113  					WithTime(time.Unix(0, 123)))
   114  				assert.NoError(t, err)
   115  				return x
   116  			}(),
   117  			r: func() *Point {
   118  				x, err := NewPoint("def",
   119  					map[string]string{"t1": "v1"},
   120  					map[string]interface{}{"f1": 123.1},
   121  					WithTime(time.Unix(0, 123)))
   122  				assert.NoError(t, err)
   123  				return x
   124  			}(),
   125  		},
   126  
   127  		{
   128  			name:        "field-value-type-not-match",
   129  			expectEqual: false,
   130  			l: func() *Point {
   131  				x, err := NewPoint("abc",
   132  					map[string]string{"t1": "v1"},
   133  					map[string]interface{}{"f1": 123.1},
   134  					WithTime(time.Unix(0, 123)))
   135  				assert.NoError(t, err)
   136  				return x
   137  			}(),
   138  			r: func() *Point {
   139  				x, err := NewPoint("abc",
   140  					map[string]string{"t1": "v1"},
   141  					map[string]interface{}{"f1": "foo"},
   142  					WithTime(time.Unix(0, 123)))
   143  				assert.NoError(t, err)
   144  				return x
   145  			}(),
   146  		},
   147  
   148  		{
   149  			name:        "field-key-not-match",
   150  			expectEqual: false,
   151  			l: func() *Point {
   152  				x, err := NewPoint("abc",
   153  					map[string]string{"t1": "v1"},
   154  					map[string]interface{}{"f1": 123.1},
   155  					WithTime(time.Unix(0, 123)))
   156  				assert.NoError(t, err)
   157  				return x
   158  			}(),
   159  			r: func() *Point {
   160  				x, err := NewPoint("abc",
   161  					map[string]string{"t1": "v1"},
   162  					map[string]interface{}{"f2": "foo"},
   163  					WithTime(time.Unix(0, 123)))
   164  				assert.NoError(t, err)
   165  				return x
   166  			}(),
   167  		},
   168  
   169  		{
   170  			name:        "field-count-not-match",
   171  			expectEqual: false,
   172  			l: func() *Point {
   173  				x, err := NewPoint("abc",
   174  					map[string]string{"t1": "v1"},
   175  					map[string]interface{}{"f1": 123.1, "f2": "haha"},
   176  					WithTime(time.Unix(0, 123)))
   177  				assert.NoError(t, err)
   178  				return x
   179  			}(),
   180  			r: func() *Point {
   181  				x, err := NewPoint("abc",
   182  					map[string]string{"t1": "v1"},
   183  					map[string]interface{}{"f2": "foo"},
   184  					WithTime(time.Unix(0, 123)))
   185  				assert.NoError(t, err)
   186  				return x
   187  			}(),
   188  		},
   189  
   190  		{
   191  			name:        "tag-count-not-match",
   192  			expectEqual: false,
   193  			l: func() *Point {
   194  				x, err := NewPoint("abc",
   195  					map[string]string{"t1": "v1", "t2": "v2"},
   196  					map[string]interface{}{"f1": 123.1},
   197  					WithTime(time.Unix(0, 123)))
   198  				assert.NoError(t, err)
   199  				return x
   200  			}(),
   201  			r: func() *Point {
   202  				x, err := NewPoint("abc",
   203  					map[string]string{"t1": "v1"},
   204  					map[string]interface{}{"f1": 123.1},
   205  					WithTime(time.Unix(0, 123)))
   206  				assert.NoError(t, err)
   207  				return x
   208  			}(),
   209  		},
   210  
   211  		{
   212  			name:        "tag-key-not-match",
   213  			expectEqual: false,
   214  			l: func() *Point {
   215  				x, err := NewPoint("abc",
   216  					map[string]string{"t1": "v1"},
   217  					map[string]interface{}{"f1": 123.1},
   218  					WithTime(time.Unix(0, 123)))
   219  				assert.NoError(t, err)
   220  				return x
   221  			}(),
   222  			r: func() *Point {
   223  				x, err := NewPoint("abc",
   224  					map[string]string{"t2": "v2"},
   225  					map[string]interface{}{"f1": 123.1},
   226  					WithTime(time.Unix(0, 123)))
   227  				assert.NoError(t, err)
   228  				return x
   229  			}(),
   230  		},
   231  
   232  		{
   233  			name:        "tag-value-not-match",
   234  			expectEqual: false,
   235  			l: func() *Point {
   236  				x, err := NewPoint("abc",
   237  					map[string]string{"t1": "v1"},
   238  					map[string]interface{}{"f1": 123.1},
   239  					WithTime(time.Unix(0, 123)))
   240  				assert.NoError(t, err)
   241  				return x
   242  			}(),
   243  			r: func() *Point {
   244  				x, err := NewPoint("abc",
   245  					map[string]string{"t1": "vx"},
   246  					map[string]interface{}{"f1": 123.1},
   247  					WithTime(time.Unix(0, 123)))
   248  				assert.NoError(t, err)
   249  				return x
   250  			}(),
   251  		},
   252  
   253  		{
   254  			name:        "field-value-match",
   255  			expectEqual: true,
   256  			l: func() *Point {
   257  				x, err := NewPoint("abc", nil,
   258  					map[string]interface{}{
   259  						"f1":           int64(123),
   260  						"f2_f64":       123.01234567890123456789,
   261  						"f2_large_f64": 1234567890123456789.01234567890123456789, // -> 1234567890123456800
   262  						"f2_f32":       float32(123.4),
   263  						"f2_f32_long":  float32(123.1234567890), // -> 123.12346
   264  						"f3":           false,
   265  						"f4":           "abc",
   266  						"f5":           []byte("xyz"),
   267  						"f6":           uint64(1234567890),
   268  					},
   269  					WithTime(time.Unix(0, 123)))
   270  				assert.NoError(t, err)
   271  				return x
   272  			}(),
   273  			r: func() *Point {
   274  				x, err := NewPoint("abc", nil,
   275  					map[string]interface{}{
   276  						"f1":           int64(123),
   277  						"f2_f64":       123.01234567890123456789,
   278  						"f2_large_f64": 1234567890123456789.01234567890123456789,
   279  						"f2_f32":       float32(123.4000),
   280  						"f2_f32_long":  float32(123.1234567890),
   281  						"f3":           false,
   282  						"f4":           "abc",
   283  						"f5":           []byte("xyz"),
   284  						"f6":           uint64(1234567890),
   285  					},
   286  					WithTime(time.Unix(0, 123)))
   287  				assert.NoError(t, err)
   288  				return x
   289  			}(),
   290  		},
   291  	}
   292  
   293  	for _, tc := range cases {
   294  		t.Run(tc.name, func(t *T.T) {
   295  			eq, reason := tc.l.EqualWithReason(tc.r)
   296  			assert.Equal(t, tc.expectEqual, eq, "l: %s\nr: %s", tc.l.Pretty(), tc.r.Pretty())
   297  
   298  			if reason != "" {
   299  				t.Logf("reason: %s", reason)
   300  			}
   301  
   302  			t.Logf("pt %s", tc.l.Pretty())
   303  		})
   304  	}
   305  
   306  	t.Cleanup(func() {
   307  		// reset them
   308  		DefaultEncoding = LineProtocol
   309  	})
   310  }
   311  
   312  func TestHash(t *T.T) {
   313  	cases := []struct {
   314  		name        string
   315  		l, r        *Point
   316  		expectEqual bool
   317  	}{
   318  		{
   319  			name:        "diff-fields",
   320  			expectEqual: true,
   321  			l: func() *Point {
   322  				x, err := NewPoint("abc",
   323  					map[string]string{"t1": "v1"},
   324  					map[string]interface{}{"f1": 123.1},
   325  					WithTime(time.Unix(0, 123)))
   326  				assert.NoError(t, err)
   327  				return x
   328  			}(),
   329  			r: func() *Point {
   330  				x, err := NewPoint("abc",
   331  					map[string]string{"t1": "v1"},
   332  					map[string]interface{}{"f2": 123},
   333  					WithTime(time.Unix(0, 123)))
   334  				assert.NoError(t, err)
   335  				return x
   336  			}(),
   337  		},
   338  
   339  		{
   340  			name:        "diff-time",
   341  			expectEqual: true,
   342  			l: func() *Point {
   343  				x, err := NewPoint("abc",
   344  					map[string]string{"t1": "v1"},
   345  					map[string]interface{}{"f1": 123.1},
   346  					WithTime(time.Unix(0, 123)))
   347  				assert.NoError(t, err)
   348  				return x
   349  			}(),
   350  			r: func() *Point {
   351  				x, err := NewPoint("abc",
   352  					map[string]string{"t1": "v1"},
   353  					map[string]interface{}{"f2": 123},
   354  					WithTime(time.Unix(0, 456)))
   355  				assert.NoError(t, err)
   356  				return x
   357  			}(),
   358  		},
   359  
   360  		{
   361  			name:        "diff-measurement",
   362  			expectEqual: false,
   363  			l: func() *Point {
   364  				x, err := NewPoint("def",
   365  					map[string]string{"t1": "v1"},
   366  					map[string]interface{}{"f1": 123.1},
   367  					WithTime(time.Unix(0, 123)))
   368  				assert.NoError(t, err)
   369  				return x
   370  			}(),
   371  			r: func() *Point {
   372  				x, err := NewPoint("abc",
   373  					map[string]string{"t1": "v1"},
   374  					map[string]interface{}{"f2": 123},
   375  					WithTime(time.Unix(0, 456)))
   376  				assert.NoError(t, err)
   377  				return x
   378  			}(),
   379  		},
   380  
   381  		{
   382  			name:        "diff-tags",
   383  			expectEqual: false,
   384  			l: func() *Point {
   385  				x, err := NewPoint("def",
   386  					map[string]string{"t2": "v1"},
   387  					map[string]interface{}{"f1": 123.1},
   388  					WithTime(time.Unix(0, 123)))
   389  				assert.NoError(t, err)
   390  				return x
   391  			}(),
   392  			r: func() *Point {
   393  				x, err := NewPoint("abc",
   394  					map[string]string{"t1": "v1"},
   395  					map[string]interface{}{"f2": 123},
   396  					WithTime(time.Unix(0, 456)))
   397  				assert.NoError(t, err)
   398  				return x
   399  			}(),
   400  		},
   401  	}
   402  
   403  	for _, tc := range cases {
   404  		t.Run(tc.name, func(t *T.T) {
   405  			if tc.expectEqual {
   406  				assert.Equal(t, tc.l.MD5(), tc.r.MD5())
   407  				assert.Equal(t, tc.l.Sha256(), tc.r.Sha256())
   408  
   409  				t.Logf("md5: %s\nsha256: %s", tc.l.MD5(), tc.l.Sha256())
   410  			} else {
   411  				assert.NotEqual(t, tc.l.MD5(), tc.r.MD5())
   412  				assert.NotEqual(t, tc.l.Sha256(), tc.r.Sha256())
   413  				t.Logf("md5: %s\nsha256: %s", tc.l.MD5(), tc.l.Sha256())
   414  			}
   415  		})
   416  	}
   417  }
   418  
   419  func TestTimeSeriesHash(t *T.T) {
   420  	cases := []struct {
   421  		name        string
   422  		p           *Point
   423  		expectCount int
   424  	}{
   425  		{
   426  			name:        "zero tags and 1 fields",
   427  			expectCount: 1,
   428  			p: func() *Point {
   429  				x, err := NewPoint("abc",
   430  					map[string]string{},
   431  					map[string]interface{}{"f1": 123.1},
   432  					WithTime(time.Unix(0, 123)))
   433  				assert.NoError(t, err)
   434  				return x
   435  			}(),
   436  		},
   437  		{
   438  			name:        "two fields",
   439  			expectCount: 2,
   440  			p: func() *Point {
   441  				x, err := NewPoint("abc",
   442  					map[string]string{"t1": "v1"},
   443  					map[string]interface{}{"f1": 123.1, "f2": 123.2},
   444  					WithTime(time.Unix(0, 123)))
   445  				assert.NoError(t, err)
   446  				return x
   447  			}(),
   448  		},
   449  		{
   450  			name:        "no fields",
   451  			expectCount: 0,
   452  			p: func() *Point {
   453  				x := NewPointV2("abc",
   454  					NewTags(map[string]string{"t1": "v1"}),
   455  					WithTime(time.Unix(0, 123)))
   456  				return x
   457  			}(),
   458  		},
   459  	}
   460  
   461  	for _, tc := range cases {
   462  		t.Run(tc.name, func(t *T.T) {
   463  			assert.Equal(t, tc.expectCount, len(tc.p.TimeSeriesHash()))
   464  		})
   465  	}
   466  }