github.com/netdata/go.d.plugin@v0.58.1/agent/confgroup/group_test.go (about)

     1  // SPDX-License-Identifier: GPL-3.0-or-later
     2  
     3  package confgroup
     4  
     5  import (
     6  	"testing"
     7  
     8  	"github.com/netdata/go.d.plugin/agent/module"
     9  
    10  	"github.com/stretchr/testify/assert"
    11  )
    12  
    13  func TestConfig_Name(t *testing.T) {
    14  	tests := map[string]struct {
    15  		cfg      Config
    16  		expected interface{}
    17  	}{
    18  		"string":       {cfg: Config{"name": "name"}, expected: "name"},
    19  		"empty string": {cfg: Config{"name": ""}, expected: ""},
    20  		"not string":   {cfg: Config{"name": 0}, expected: ""},
    21  		"not set":      {cfg: Config{}, expected: ""},
    22  		"nil cfg":      {expected: ""},
    23  	}
    24  
    25  	for name, test := range tests {
    26  		t.Run(name, func(t *testing.T) {
    27  			assert.Equal(t, test.expected, test.cfg.Name())
    28  		})
    29  	}
    30  }
    31  
    32  func TestConfig_Module(t *testing.T) {
    33  	tests := map[string]struct {
    34  		cfg      Config
    35  		expected interface{}
    36  	}{
    37  		"string":       {cfg: Config{"module": "module"}, expected: "module"},
    38  		"empty string": {cfg: Config{"module": ""}, expected: ""},
    39  		"not string":   {cfg: Config{"module": 0}, expected: ""},
    40  		"not set":      {cfg: Config{}, expected: ""},
    41  		"nil cfg":      {expected: ""},
    42  	}
    43  
    44  	for name, test := range tests {
    45  		t.Run(name, func(t *testing.T) {
    46  			assert.Equal(t, test.expected, test.cfg.Module())
    47  		})
    48  	}
    49  }
    50  
    51  func TestConfig_FullName(t *testing.T) {
    52  	tests := map[string]struct {
    53  		cfg      Config
    54  		expected interface{}
    55  	}{
    56  		"name == module": {cfg: Config{"name": "name", "module": "name"}, expected: "name"},
    57  		"name != module": {cfg: Config{"name": "name", "module": "module"}, expected: "module_name"},
    58  		"nil cfg":        {expected: ""},
    59  	}
    60  
    61  	for name, test := range tests {
    62  		t.Run(name, func(t *testing.T) {
    63  			assert.Equal(t, test.expected, test.cfg.FullName())
    64  		})
    65  	}
    66  }
    67  
    68  func TestConfig_UpdateEvery(t *testing.T) {
    69  	tests := map[string]struct {
    70  		cfg      Config
    71  		expected interface{}
    72  	}{
    73  		"int":     {cfg: Config{"update_every": 1}, expected: 1},
    74  		"not int": {cfg: Config{"update_every": "1"}, expected: 0},
    75  		"not set": {cfg: Config{}, expected: 0},
    76  		"nil cfg": {expected: 0},
    77  	}
    78  
    79  	for name, test := range tests {
    80  		t.Run(name, func(t *testing.T) {
    81  			assert.Equal(t, test.expected, test.cfg.UpdateEvery())
    82  		})
    83  	}
    84  }
    85  
    86  func TestConfig_AutoDetectionRetry(t *testing.T) {
    87  	tests := map[string]struct {
    88  		cfg      Config
    89  		expected interface{}
    90  	}{
    91  		"int":     {cfg: Config{"autodetection_retry": 1}, expected: 1},
    92  		"not int": {cfg: Config{"autodetection_retry": "1"}, expected: 0},
    93  		"not set": {cfg: Config{}, expected: 0},
    94  		"nil cfg": {expected: 0},
    95  	}
    96  
    97  	for name, test := range tests {
    98  		t.Run(name, func(t *testing.T) {
    99  			assert.Equal(t, test.expected, test.cfg.AutoDetectionRetry())
   100  		})
   101  	}
   102  }
   103  
   104  func TestConfig_Priority(t *testing.T) {
   105  	tests := map[string]struct {
   106  		cfg      Config
   107  		expected interface{}
   108  	}{
   109  		"int":     {cfg: Config{"priority": 1}, expected: 1},
   110  		"not int": {cfg: Config{"priority": "1"}, expected: 0},
   111  		"not set": {cfg: Config{}, expected: 0},
   112  		"nil cfg": {expected: 0},
   113  	}
   114  
   115  	for name, test := range tests {
   116  		t.Run(name, func(t *testing.T) {
   117  			assert.Equal(t, test.expected, test.cfg.Priority())
   118  		})
   119  	}
   120  }
   121  
   122  func TestConfig_Hash(t *testing.T) {
   123  	tests := map[string]struct {
   124  		one, two Config
   125  		equal    bool
   126  	}{
   127  		"same keys, no internal keys": {
   128  			one:   Config{"name": "name"},
   129  			two:   Config{"name": "name"},
   130  			equal: true,
   131  		},
   132  		"same keys, different internal keys": {
   133  			one:   Config{"name": "name", "__key__": 1},
   134  			two:   Config{"name": "name", "__value__": 1},
   135  			equal: true,
   136  		},
   137  		"same keys, same internal keys": {
   138  			one:   Config{"name": "name", "__key__": 1},
   139  			two:   Config{"name": "name", "__key__": 1},
   140  			equal: true,
   141  		},
   142  		"diff keys, no internal keys": {
   143  			one:   Config{"name": "name1"},
   144  			two:   Config{"name": "name2"},
   145  			equal: false,
   146  		},
   147  		"diff keys, different internal keys": {
   148  			one:   Config{"name": "name1", "__key__": 1},
   149  			two:   Config{"name": "name2", "__value__": 1},
   150  			equal: false,
   151  		},
   152  		"diff keys, same internal keys": {
   153  			one:   Config{"name": "name1", "__key__": 1},
   154  			two:   Config{"name": "name2", "__key__": 1},
   155  			equal: false,
   156  		},
   157  	}
   158  
   159  	for name, test := range tests {
   160  		t.Run(name, func(t *testing.T) {
   161  			if test.equal {
   162  				assert.Equal(t, test.one.Hash(), test.two.Hash())
   163  			} else {
   164  				assert.NotEqual(t, test.one.Hash(), test.two.Hash())
   165  			}
   166  		})
   167  	}
   168  	cfg := Config{"name": "name", "module": "module"}
   169  	assert.NotZero(t, cfg.Hash())
   170  }
   171  
   172  func TestConfig_SetModule(t *testing.T) {
   173  	cfg := Config{}
   174  	cfg.SetModule("name")
   175  
   176  	assert.Equal(t, cfg.Module(), "name")
   177  }
   178  
   179  func TestConfig_SetSource(t *testing.T) {
   180  	cfg := Config{}
   181  	cfg.SetSource("name")
   182  
   183  	assert.Equal(t, cfg.Source(), "name")
   184  }
   185  
   186  func TestConfig_SetProvider(t *testing.T) {
   187  	cfg := Config{}
   188  	cfg.SetProvider("name")
   189  
   190  	assert.Equal(t, cfg.Provider(), "name")
   191  }
   192  
   193  func TestConfig_Apply(t *testing.T) {
   194  	const jobDef = 11
   195  	const applyDef = 22
   196  	tests := map[string]struct {
   197  		def         Default
   198  		origCfg     Config
   199  		expectedCfg Config
   200  	}{
   201  		"+job +def": {
   202  			def: Default{
   203  				UpdateEvery:        applyDef,
   204  				AutoDetectionRetry: applyDef,
   205  				Priority:           applyDef,
   206  			},
   207  			origCfg: Config{
   208  				"name":                "name",
   209  				"module":              "module",
   210  				"update_every":        jobDef,
   211  				"autodetection_retry": jobDef,
   212  				"priority":            jobDef,
   213  			},
   214  			expectedCfg: Config{
   215  				"name":                "name",
   216  				"module":              "module",
   217  				"update_every":        jobDef,
   218  				"autodetection_retry": jobDef,
   219  				"priority":            jobDef,
   220  			},
   221  		},
   222  		"-job +def": {
   223  			def: Default{
   224  				UpdateEvery:        applyDef,
   225  				AutoDetectionRetry: applyDef,
   226  				Priority:           applyDef,
   227  			},
   228  			origCfg: Config{
   229  				"name":   "name",
   230  				"module": "module",
   231  			},
   232  			expectedCfg: Config{
   233  				"name":                "name",
   234  				"module":              "module",
   235  				"update_every":        applyDef,
   236  				"autodetection_retry": applyDef,
   237  				"priority":            applyDef,
   238  			},
   239  		},
   240  		"-job -def (+global)": {
   241  			def: Default{},
   242  			origCfg: Config{
   243  				"name":   "name",
   244  				"module": "module",
   245  			},
   246  			expectedCfg: Config{
   247  				"name":                "name",
   248  				"module":              "module",
   249  				"update_every":        module.UpdateEvery,
   250  				"autodetection_retry": module.AutoDetectionRetry,
   251  				"priority":            module.Priority,
   252  			},
   253  		},
   254  		"adjust update_every (update_every < min update every)": {
   255  			def: Default{
   256  				MinUpdateEvery: jobDef + 10,
   257  			},
   258  			origCfg: Config{
   259  				"name":         "name",
   260  				"module":       "module",
   261  				"update_every": jobDef,
   262  			},
   263  			expectedCfg: Config{
   264  				"name":                "name",
   265  				"module":              "module",
   266  				"update_every":        jobDef + 10,
   267  				"autodetection_retry": module.AutoDetectionRetry,
   268  				"priority":            module.Priority,
   269  			},
   270  		},
   271  		"do not adjust update_every (update_every > min update every)": {
   272  			def: Default{
   273  				MinUpdateEvery: 2,
   274  			},
   275  			origCfg: Config{
   276  				"name":         "name",
   277  				"module":       "module",
   278  				"update_every": jobDef,
   279  			},
   280  			expectedCfg: Config{
   281  				"name":                "name",
   282  				"module":              "module",
   283  				"update_every":        jobDef,
   284  				"autodetection_retry": module.AutoDetectionRetry,
   285  				"priority":            module.Priority,
   286  			},
   287  		},
   288  		"set name to module name if name not set": {
   289  			def: Default{},
   290  			origCfg: Config{
   291  				"module": "module",
   292  			},
   293  			expectedCfg: Config{
   294  				"name":                "module",
   295  				"module":              "module",
   296  				"update_every":        module.UpdateEvery,
   297  				"autodetection_retry": module.AutoDetectionRetry,
   298  				"priority":            module.Priority,
   299  			},
   300  		},
   301  		"clean name": {
   302  			def: Default{},
   303  			origCfg: Config{
   304  				"name":   "na me",
   305  				"module": "module",
   306  			},
   307  			expectedCfg: Config{
   308  				"name":                "na_me",
   309  				"module":              "module",
   310  				"update_every":        module.UpdateEvery,
   311  				"autodetection_retry": module.AutoDetectionRetry,
   312  				"priority":            module.Priority,
   313  			},
   314  		},
   315  	}
   316  
   317  	for name, test := range tests {
   318  		t.Run(name, func(t *testing.T) {
   319  			test.origCfg.Apply(test.def)
   320  
   321  			assert.Equal(t, test.expectedCfg, test.origCfg)
   322  		})
   323  	}
   324  }
   325  
   326  func Test_urlResolveHostname(t *testing.T) {
   327  	tests := map[string]struct {
   328  		input       string
   329  		wantChanged bool
   330  	}{
   331  		"hostname with suffix": {
   332  			wantChanged: true,
   333  			input:       "http://hostname.local:80/metrics",
   334  		},
   335  		"hostname without suffix": {
   336  			wantChanged: true,
   337  			input:       "http://hostname:80/metrics",
   338  		},
   339  		"no hostname": {
   340  			wantChanged: false,
   341  			input:       "http://127.0.0.1:80/metrics",
   342  		},
   343  	}
   344  
   345  	for name, test := range tests {
   346  		t.Run(name, func(t *testing.T) {
   347  
   348  			if test.wantChanged {
   349  				assert.NotEqual(t, test.input, urlResolveHostname(test.input))
   350  			} else {
   351  				assert.Equal(t, test.input, urlResolveHostname(test.input))
   352  			}
   353  		})
   354  	}
   355  }
   356  
   357  func Test_jobNameResolveHostname(t *testing.T) {
   358  	tests := map[string]struct {
   359  		input       string
   360  		wantChanged bool
   361  	}{
   362  		"hostname with dot suffix": {
   363  			wantChanged: true,
   364  			input:       "hostname.local",
   365  		},
   366  		"hostname with underscore suffix": {
   367  			wantChanged: true,
   368  			input:       "hostname_local",
   369  		},
   370  		"hostname without suffix": {
   371  			wantChanged: true,
   372  			input:       "hostname",
   373  		},
   374  		"no hostname": {
   375  			wantChanged: false,
   376  			input:       "name",
   377  		},
   378  	}
   379  
   380  	for name, test := range tests {
   381  		t.Run(name, func(t *testing.T) {
   382  
   383  			if test.wantChanged {
   384  				assert.NotEqual(t, test.input, jobNameResolveHostname(test.input))
   385  			} else {
   386  				assert.Equal(t, test.input, jobNameResolveHostname(test.input))
   387  			}
   388  		})
   389  	}
   390  }