github.com/netdata/go.d.plugin@v0.58.1/agent/discovery/file/parse_test.go (about)

     1  // SPDX-License-Identifier: GPL-3.0-or-later
     2  
     3  package file
     4  
     5  import (
     6  	"testing"
     7  
     8  	"github.com/netdata/go.d.plugin/agent/confgroup"
     9  	"github.com/netdata/go.d.plugin/agent/module"
    10  
    11  	"github.com/stretchr/testify/assert"
    12  	"github.com/stretchr/testify/require"
    13  )
    14  
    15  func TestParse(t *testing.T) {
    16  	const (
    17  		jobDef = 11
    18  		cfgDef = 22
    19  		modDef = 33
    20  	)
    21  	tests := map[string]func(t *testing.T, tmp *tmpDir){
    22  		"static, default: +job +conf +module": func(t *testing.T, tmp *tmpDir) {
    23  			reg := confgroup.Registry{
    24  				"module": {
    25  					UpdateEvery:        modDef,
    26  					AutoDetectionRetry: modDef,
    27  					Priority:           modDef,
    28  				},
    29  			}
    30  			cfg := staticConfig{
    31  				Default: confgroup.Default{
    32  					UpdateEvery:        cfgDef,
    33  					AutoDetectionRetry: cfgDef,
    34  					Priority:           cfgDef,
    35  				},
    36  				Jobs: []confgroup.Config{
    37  					{
    38  						"name":                "name",
    39  						"update_every":        jobDef,
    40  						"autodetection_retry": jobDef,
    41  						"priority":            jobDef,
    42  					},
    43  				},
    44  			}
    45  			filename := tmp.join("module.conf")
    46  			tmp.writeYAML(filename, cfg)
    47  
    48  			expected := &confgroup.Group{
    49  				Source: filename,
    50  				Configs: []confgroup.Config{
    51  					{
    52  						"name":                "name",
    53  						"module":              "module",
    54  						"update_every":        jobDef,
    55  						"autodetection_retry": jobDef,
    56  						"priority":            jobDef,
    57  					},
    58  				},
    59  			}
    60  
    61  			group, err := parse(reg, filename)
    62  
    63  			require.NoError(t, err)
    64  			assert.Equal(t, expected, group)
    65  		},
    66  		"static, default: +job +conf +module (merge all)": func(t *testing.T, tmp *tmpDir) {
    67  			reg := confgroup.Registry{
    68  				"module": {
    69  					Priority: modDef,
    70  				},
    71  			}
    72  			cfg := staticConfig{
    73  				Default: confgroup.Default{
    74  					AutoDetectionRetry: cfgDef,
    75  				},
    76  				Jobs: []confgroup.Config{
    77  					{
    78  						"name":         "name",
    79  						"update_every": jobDef,
    80  					},
    81  				},
    82  			}
    83  			filename := tmp.join("module.conf")
    84  			tmp.writeYAML(filename, cfg)
    85  
    86  			expected := &confgroup.Group{
    87  				Source: filename,
    88  				Configs: []confgroup.Config{
    89  					{
    90  						"name":                "name",
    91  						"module":              "module",
    92  						"update_every":        jobDef,
    93  						"autodetection_retry": cfgDef,
    94  						"priority":            modDef,
    95  					},
    96  				},
    97  			}
    98  
    99  			group, err := parse(reg, filename)
   100  
   101  			require.NoError(t, err)
   102  			assert.Equal(t, expected, group)
   103  		},
   104  		"static, default: -job +conf +module": func(t *testing.T, tmp *tmpDir) {
   105  			reg := confgroup.Registry{
   106  				"module": {
   107  					UpdateEvery:        modDef,
   108  					AutoDetectionRetry: modDef,
   109  					Priority:           modDef,
   110  				},
   111  			}
   112  			cfg := staticConfig{
   113  				Default: confgroup.Default{
   114  					UpdateEvery:        cfgDef,
   115  					AutoDetectionRetry: cfgDef,
   116  					Priority:           cfgDef,
   117  				},
   118  				Jobs: []confgroup.Config{
   119  					{
   120  						"name": "name",
   121  					},
   122  				},
   123  			}
   124  			filename := tmp.join("module.conf")
   125  			tmp.writeYAML(filename, cfg)
   126  
   127  			expected := &confgroup.Group{
   128  				Source: filename,
   129  				Configs: []confgroup.Config{
   130  					{
   131  						"name":                "name",
   132  						"module":              "module",
   133  						"update_every":        cfgDef,
   134  						"autodetection_retry": cfgDef,
   135  						"priority":            cfgDef,
   136  					},
   137  				},
   138  			}
   139  
   140  			group, err := parse(reg, filename)
   141  
   142  			require.NoError(t, err)
   143  			assert.Equal(t, expected, group)
   144  		},
   145  		"static, default: -job -conf +module": func(t *testing.T, tmp *tmpDir) {
   146  			reg := confgroup.Registry{
   147  				"module": {
   148  					UpdateEvery:        modDef,
   149  					AutoDetectionRetry: modDef,
   150  					Priority:           modDef,
   151  				},
   152  			}
   153  			cfg := staticConfig{
   154  				Jobs: []confgroup.Config{
   155  					{
   156  						"name": "name",
   157  					},
   158  				},
   159  			}
   160  			filename := tmp.join("module.conf")
   161  			tmp.writeYAML(filename, cfg)
   162  
   163  			expected := &confgroup.Group{
   164  				Source: filename,
   165  				Configs: []confgroup.Config{
   166  					{
   167  						"name":                "name",
   168  						"module":              "module",
   169  						"autodetection_retry": modDef,
   170  						"priority":            modDef,
   171  						"update_every":        modDef,
   172  					},
   173  				},
   174  			}
   175  
   176  			group, err := parse(reg, filename)
   177  
   178  			require.NoError(t, err)
   179  			assert.Equal(t, expected, group)
   180  		},
   181  		"static, default: -job -conf -module (+global)": func(t *testing.T, tmp *tmpDir) {
   182  			reg := confgroup.Registry{
   183  				"module": {},
   184  			}
   185  			cfg := staticConfig{
   186  				Jobs: []confgroup.Config{
   187  					{
   188  						"name": "name",
   189  					},
   190  				},
   191  			}
   192  			filename := tmp.join("module.conf")
   193  			tmp.writeYAML(filename, cfg)
   194  
   195  			expected := &confgroup.Group{
   196  				Source: filename,
   197  				Configs: []confgroup.Config{
   198  					{
   199  						"name":                "name",
   200  						"module":              "module",
   201  						"autodetection_retry": module.AutoDetectionRetry,
   202  						"priority":            module.Priority,
   203  						"update_every":        module.UpdateEvery,
   204  					},
   205  				},
   206  			}
   207  
   208  			group, err := parse(reg, filename)
   209  
   210  			require.NoError(t, err)
   211  			assert.Equal(t, expected, group)
   212  		},
   213  		"sd, default: +job +module": func(t *testing.T, tmp *tmpDir) {
   214  			reg := confgroup.Registry{
   215  				"sd_module": {
   216  					UpdateEvery:        modDef,
   217  					AutoDetectionRetry: modDef,
   218  					Priority:           modDef,
   219  				},
   220  			}
   221  			cfg := sdConfig{
   222  				{
   223  					"name":                "name",
   224  					"module":              "sd_module",
   225  					"update_every":        jobDef,
   226  					"autodetection_retry": jobDef,
   227  					"priority":            jobDef,
   228  				},
   229  			}
   230  			filename := tmp.join("module.conf")
   231  			tmp.writeYAML(filename, cfg)
   232  
   233  			expected := &confgroup.Group{
   234  				Source: filename,
   235  				Configs: []confgroup.Config{
   236  					{
   237  						"module":              "sd_module",
   238  						"name":                "name",
   239  						"update_every":        jobDef,
   240  						"autodetection_retry": jobDef,
   241  						"priority":            jobDef,
   242  					},
   243  				},
   244  			}
   245  
   246  			group, err := parse(reg, filename)
   247  
   248  			require.NoError(t, err)
   249  			assert.Equal(t, expected, group)
   250  		},
   251  		"sd, default: -job +module": func(t *testing.T, tmp *tmpDir) {
   252  			reg := confgroup.Registry{
   253  				"sd_module": {
   254  					UpdateEvery:        modDef,
   255  					AutoDetectionRetry: modDef,
   256  					Priority:           modDef,
   257  				},
   258  			}
   259  			cfg := sdConfig{
   260  				{
   261  					"name":   "name",
   262  					"module": "sd_module",
   263  				},
   264  			}
   265  			filename := tmp.join("module.conf")
   266  			tmp.writeYAML(filename, cfg)
   267  
   268  			expected := &confgroup.Group{
   269  				Source: filename,
   270  				Configs: []confgroup.Config{
   271  					{
   272  						"name":                "name",
   273  						"module":              "sd_module",
   274  						"update_every":        modDef,
   275  						"autodetection_retry": modDef,
   276  						"priority":            modDef,
   277  					},
   278  				},
   279  			}
   280  
   281  			group, err := parse(reg, filename)
   282  
   283  			require.NoError(t, err)
   284  			assert.Equal(t, expected, group)
   285  		},
   286  		"sd, default: -job -module (+global)": func(t *testing.T, tmp *tmpDir) {
   287  			reg := confgroup.Registry{
   288  				"sd_module": {},
   289  			}
   290  			cfg := sdConfig{
   291  				{
   292  					"name":   "name",
   293  					"module": "sd_module",
   294  				},
   295  			}
   296  			filename := tmp.join("module.conf")
   297  			tmp.writeYAML(filename, cfg)
   298  
   299  			expected := &confgroup.Group{
   300  				Source: filename,
   301  				Configs: []confgroup.Config{
   302  					{
   303  						"name":                "name",
   304  						"module":              "sd_module",
   305  						"update_every":        module.UpdateEvery,
   306  						"autodetection_retry": module.AutoDetectionRetry,
   307  						"priority":            module.Priority,
   308  					},
   309  				},
   310  			}
   311  
   312  			group, err := parse(reg, filename)
   313  
   314  			require.NoError(t, err)
   315  			assert.Equal(t, expected, group)
   316  		},
   317  		"sd, job has no 'module' or 'module' is empty": func(t *testing.T, tmp *tmpDir) {
   318  			reg := confgroup.Registry{
   319  				"sd_module": {},
   320  			}
   321  			cfg := sdConfig{
   322  				{
   323  					"name": "name",
   324  				},
   325  			}
   326  			filename := tmp.join("module.conf")
   327  			tmp.writeYAML(filename, cfg)
   328  
   329  			expected := &confgroup.Group{
   330  				Source:  filename,
   331  				Configs: []confgroup.Config{},
   332  			}
   333  
   334  			group, err := parse(reg, filename)
   335  
   336  			require.NoError(t, err)
   337  			assert.Equal(t, expected, group)
   338  		},
   339  		"conf registry has no module": func(t *testing.T, tmp *tmpDir) {
   340  			reg := confgroup.Registry{
   341  				"sd_module": {},
   342  			}
   343  			cfg := sdConfig{
   344  				{
   345  					"name":   "name",
   346  					"module": "module",
   347  				},
   348  			}
   349  			filename := tmp.join("module.conf")
   350  			tmp.writeYAML(filename, cfg)
   351  
   352  			expected := &confgroup.Group{
   353  				Source:  filename,
   354  				Configs: []confgroup.Config{},
   355  			}
   356  
   357  			group, err := parse(reg, filename)
   358  
   359  			require.NoError(t, err)
   360  			assert.Equal(t, expected, group)
   361  		},
   362  		"empty file": func(t *testing.T, tmp *tmpDir) {
   363  			reg := confgroup.Registry{
   364  				"module": {},
   365  			}
   366  
   367  			filename := tmp.createFile("empty-*")
   368  			group, err := parse(reg, filename)
   369  
   370  			assert.Nil(t, group)
   371  			require.NoError(t, err)
   372  		},
   373  		"only comments, unknown empty format": func(t *testing.T, tmp *tmpDir) {
   374  			reg := confgroup.Registry{}
   375  
   376  			filename := tmp.createFile("unknown-empty-format-*")
   377  			tmp.writeString(filename, "# a comment")
   378  			group, err := parse(reg, filename)
   379  
   380  			assert.Nil(t, group)
   381  			assert.NoError(t, err)
   382  		},
   383  		"unknown format": func(t *testing.T, tmp *tmpDir) {
   384  			reg := confgroup.Registry{}
   385  
   386  			filename := tmp.createFile("unknown-format-*")
   387  			tmp.writeYAML(filename, "unknown")
   388  			group, err := parse(reg, filename)
   389  
   390  			assert.Nil(t, group)
   391  			assert.Error(t, err)
   392  		},
   393  	}
   394  
   395  	for name, scenario := range tests {
   396  		t.Run(name, func(t *testing.T) {
   397  			tmp := newTmpDir(t, "parse-file-*")
   398  			defer tmp.cleanup()
   399  			scenario(t, tmp)
   400  		})
   401  	}
   402  }