github.com/Jeffail/benthos/v3@v3.65.0/public/service/plugins_test.go (about)

     1  package service_test
     2  
     3  import (
     4  	"errors"
     5  	"testing"
     6  
     7  	"github.com/Jeffail/benthos/v3/internal/docs"
     8  	"github.com/Jeffail/benthos/v3/lib/cache"
     9  	"github.com/Jeffail/benthos/v3/lib/input"
    10  	"github.com/Jeffail/benthos/v3/lib/log"
    11  	"github.com/Jeffail/benthos/v3/lib/manager"
    12  	"github.com/Jeffail/benthos/v3/lib/metrics"
    13  	"github.com/Jeffail/benthos/v3/lib/output"
    14  	"github.com/Jeffail/benthos/v3/lib/processor"
    15  	"github.com/Jeffail/benthos/v3/lib/ratelimit"
    16  	"github.com/Jeffail/benthos/v3/lib/types"
    17  	"github.com/Jeffail/benthos/v3/public/service"
    18  	"github.com/stretchr/testify/assert"
    19  	"github.com/stretchr/testify/require"
    20  	"gopkg.in/yaml.v3"
    21  )
    22  
    23  func TestCachePluginWithConfig(t *testing.T) {
    24  	type testConfig struct {
    25  		A int `yaml:"a"`
    26  	}
    27  
    28  	configSpec, err := service.NewStructConfigSpec(func() interface{} {
    29  		return &testConfig{A: 100}
    30  	})
    31  	require.NoError(t, err)
    32  
    33  	var initConf *testConfig
    34  	var initLabel string
    35  	require.NoError(t, service.RegisterCache("test_cache_plugin_with_config", configSpec,
    36  		func(conf *service.ParsedConfig, mgr *service.Resources) (service.Cache, error) {
    37  			initConf = conf.AsStruct().(*testConfig)
    38  			initLabel = mgr.Label()
    39  			return nil, errors.New("this is a test error")
    40  		}))
    41  
    42  	cacheConfStr := `label: foo
    43  test_cache_plugin_with_config:
    44      a: 20
    45  `
    46  
    47  	cacheConf := cache.NewConfig()
    48  	require.NoError(t, yaml.Unmarshal([]byte(cacheConfStr), &cacheConf))
    49  
    50  	var cacheNode yaml.Node
    51  	require.NoError(t, cacheNode.Encode(cacheConf))
    52  
    53  	require.NoError(t, docs.SanitiseYAML(docs.TypeCache, &cacheNode, docs.SanitiseConfig{
    54  		RemoveTypeField:  true,
    55  		RemoveDeprecated: true,
    56  	}))
    57  
    58  	cacheConfOutBytes, err := yaml.Marshal(cacheNode)
    59  	require.NoError(t, err)
    60  	assert.Equal(t, cacheConfStr, string(cacheConfOutBytes))
    61  
    62  	mgr, err := manager.New(manager.NewConfig(), types.NoopMgr(), log.Noop(), metrics.Noop())
    63  	require.NoError(t, err)
    64  
    65  	_, err = mgr.NewCache(cacheConf)
    66  	assert.EqualError(t, err, "this is a test error")
    67  	require.NotNil(t, initConf)
    68  	assert.Equal(t, 20, initConf.A)
    69  	assert.Equal(t, "foo", initLabel)
    70  }
    71  
    72  func TestCachePluginWithoutConfig(t *testing.T) {
    73  	configSpec := service.NewConfigSpec()
    74  
    75  	var initLabel string
    76  	require.NoError(t, service.RegisterCache("test_cache_plugin_without_config", configSpec,
    77  		func(conf *service.ParsedConfig, mgr *service.Resources) (service.Cache, error) {
    78  			initLabel = mgr.Label()
    79  			return nil, errors.New("this is a test error")
    80  		}))
    81  
    82  	cacheConfStr := `label: foo
    83  test_cache_plugin_without_config: null
    84  `
    85  
    86  	cacheConf := cache.NewConfig()
    87  	require.NoError(t, yaml.Unmarshal([]byte(cacheConfStr), &cacheConf))
    88  
    89  	var cacheNode yaml.Node
    90  	require.NoError(t, cacheNode.Encode(cacheConf))
    91  
    92  	require.NoError(t, docs.SanitiseYAML(docs.TypeCache, &cacheNode, docs.SanitiseConfig{
    93  		RemoveTypeField:  true,
    94  		RemoveDeprecated: true,
    95  	}))
    96  
    97  	cacheConfOutBytes, err := yaml.Marshal(cacheNode)
    98  	require.NoError(t, err)
    99  	assert.Equal(t, cacheConfStr, string(cacheConfOutBytes))
   100  
   101  	mgr, err := manager.New(manager.NewConfig(), types.NoopMgr(), log.Noop(), metrics.Noop())
   102  	require.NoError(t, err)
   103  
   104  	_, err = mgr.NewCache(cacheConf)
   105  	assert.EqualError(t, err, "this is a test error")
   106  	assert.Equal(t, "foo", initLabel)
   107  }
   108  
   109  func TestInputPluginWithConfig(t *testing.T) {
   110  	type testConfig struct {
   111  		A int `yaml:"a"`
   112  	}
   113  
   114  	configSpec, err := service.NewStructConfigSpec(func() interface{} {
   115  		return &testConfig{A: 100}
   116  	})
   117  	require.NoError(t, err)
   118  
   119  	var initConf *testConfig
   120  	var initLabel string
   121  	require.NoError(t, service.RegisterInput("test_input_plugin_with_config", configSpec,
   122  		func(conf *service.ParsedConfig, mgr *service.Resources) (service.Input, error) {
   123  			initConf = conf.AsStruct().(*testConfig)
   124  			initLabel = mgr.Label()
   125  			return nil, errors.New("this is a test error")
   126  		}))
   127  
   128  	inConfStr := `label: foo
   129  test_input_plugin_with_config:
   130      a: 20
   131  `
   132  
   133  	inConf := input.NewConfig()
   134  	require.NoError(t, yaml.Unmarshal([]byte(inConfStr), &inConf))
   135  
   136  	var outNode yaml.Node
   137  	require.NoError(t, outNode.Encode(inConf))
   138  
   139  	require.NoError(t, docs.SanitiseYAML(docs.TypeInput, &outNode, docs.SanitiseConfig{
   140  		RemoveTypeField:  true,
   141  		RemoveDeprecated: true,
   142  	}))
   143  
   144  	outConfOutBytes, err := yaml.Marshal(outNode)
   145  	require.NoError(t, err)
   146  	assert.Equal(t, inConfStr, string(outConfOutBytes))
   147  
   148  	mgr, err := manager.New(manager.NewConfig(), types.NoopMgr(), log.Noop(), metrics.Noop())
   149  	require.NoError(t, err)
   150  
   151  	_, err = mgr.NewInput(inConf, false)
   152  	assert.EqualError(t, err, "failed to create input 'test_input_plugin_with_config': this is a test error")
   153  	require.NotNil(t, initConf)
   154  	assert.Equal(t, 20, initConf.A)
   155  	assert.Equal(t, "foo", initLabel)
   156  }
   157  
   158  func TestInputPluginWithoutConfig(t *testing.T) {
   159  	configSpec := service.NewConfigSpec()
   160  
   161  	var initLabel string
   162  	require.NoError(t, service.RegisterInput("test_input_plugin_without_config", configSpec,
   163  		func(conf *service.ParsedConfig, mgr *service.Resources) (service.Input, error) {
   164  			initLabel = mgr.Label()
   165  			return nil, errors.New("this is a test error")
   166  		}))
   167  
   168  	inConfStr := `label: foo
   169  test_input_plugin_without_config: null
   170  `
   171  
   172  	inConf := input.NewConfig()
   173  	require.NoError(t, yaml.Unmarshal([]byte(inConfStr), &inConf))
   174  
   175  	var outNode yaml.Node
   176  	require.NoError(t, outNode.Encode(inConf))
   177  
   178  	require.NoError(t, docs.SanitiseYAML(docs.TypeInput, &outNode, docs.SanitiseConfig{
   179  		RemoveTypeField:  true,
   180  		RemoveDeprecated: true,
   181  	}))
   182  
   183  	outConfOutBytes, err := yaml.Marshal(outNode)
   184  	require.NoError(t, err)
   185  	assert.Equal(t, inConfStr, string(outConfOutBytes))
   186  
   187  	mgr, err := manager.New(manager.NewConfig(), types.NoopMgr(), log.Noop(), metrics.Noop())
   188  	require.NoError(t, err)
   189  
   190  	_, err = mgr.NewInput(inConf, false)
   191  	assert.EqualError(t, err, "failed to create input 'test_input_plugin_without_config': this is a test error")
   192  	assert.Equal(t, "foo", initLabel)
   193  }
   194  
   195  func TestOutputPluginWithConfig(t *testing.T) {
   196  	type testConfig struct {
   197  		A int `yaml:"a"`
   198  	}
   199  
   200  	configSpec, err := service.NewStructConfigSpec(func() interface{} {
   201  		return &testConfig{A: 100}
   202  	})
   203  	require.NoError(t, err)
   204  
   205  	var initConf *testConfig
   206  	var initLabel string
   207  	require.NoError(t, service.RegisterOutput("test_output_plugin_with_config", configSpec,
   208  		func(conf *service.ParsedConfig, mgr *service.Resources) (service.Output, int, error) {
   209  			initConf = conf.AsStruct().(*testConfig)
   210  			initLabel = mgr.Label()
   211  			return nil, 1, errors.New("this is a test error")
   212  		}))
   213  
   214  	inConfStr := `label: foo
   215  test_output_plugin_with_config:
   216      a: 20
   217  `
   218  
   219  	inConf := output.NewConfig()
   220  	require.NoError(t, yaml.Unmarshal([]byte(inConfStr), &inConf))
   221  
   222  	var outNode yaml.Node
   223  	require.NoError(t, outNode.Encode(inConf))
   224  
   225  	require.NoError(t, docs.SanitiseYAML(docs.TypeOutput, &outNode, docs.SanitiseConfig{
   226  		RemoveTypeField:  true,
   227  		RemoveDeprecated: true,
   228  	}))
   229  
   230  	outConfOutBytes, err := yaml.Marshal(outNode)
   231  	require.NoError(t, err)
   232  	assert.Equal(t, inConfStr, string(outConfOutBytes))
   233  
   234  	mgr, err := manager.New(manager.NewConfig(), types.NoopMgr(), log.Noop(), metrics.Noop())
   235  	require.NoError(t, err)
   236  
   237  	_, err = mgr.NewOutput(inConf)
   238  	assert.EqualError(t, err, "failed to create output 'test_output_plugin_with_config': this is a test error")
   239  	require.NotNil(t, initConf)
   240  	assert.Equal(t, 20, initConf.A)
   241  	assert.Equal(t, "foo", initLabel)
   242  }
   243  
   244  func TestOutputPluginWithoutConfig(t *testing.T) {
   245  	configSpec := service.NewConfigSpec()
   246  
   247  	var initLabel string
   248  	require.NoError(t, service.RegisterOutput("test_output_plugin_without_config", configSpec,
   249  		func(conf *service.ParsedConfig, mgr *service.Resources) (service.Output, int, error) {
   250  			initLabel = mgr.Label()
   251  			return nil, 1, errors.New("this is a test error")
   252  		}))
   253  
   254  	inConfStr := `label: foo
   255  test_output_plugin_without_config: null
   256  `
   257  
   258  	inConf := output.NewConfig()
   259  	require.NoError(t, yaml.Unmarshal([]byte(inConfStr), &inConf))
   260  
   261  	var outNode yaml.Node
   262  	require.NoError(t, outNode.Encode(inConf))
   263  
   264  	require.NoError(t, docs.SanitiseYAML(docs.TypeOutput, &outNode, docs.SanitiseConfig{
   265  		RemoveTypeField:  true,
   266  		RemoveDeprecated: true,
   267  	}))
   268  
   269  	outConfOutBytes, err := yaml.Marshal(outNode)
   270  	require.NoError(t, err)
   271  	assert.Equal(t, inConfStr, string(outConfOutBytes))
   272  
   273  	mgr, err := manager.New(manager.NewConfig(), types.NoopMgr(), log.Noop(), metrics.Noop())
   274  	require.NoError(t, err)
   275  
   276  	_, err = mgr.NewOutput(inConf)
   277  	assert.EqualError(t, err, "failed to create output 'test_output_plugin_without_config': this is a test error")
   278  	assert.Equal(t, "foo", initLabel)
   279  }
   280  
   281  func TestBatchOutputPluginWithConfig(t *testing.T) {
   282  	type testConfig struct {
   283  		A     int `yaml:"a"`
   284  		Count int `yaml:"count"`
   285  	}
   286  
   287  	configSpec, err := service.NewStructConfigSpec(func() interface{} {
   288  		return &testConfig{A: 100, Count: 10}
   289  	})
   290  	require.NoError(t, err)
   291  
   292  	var initConf *testConfig
   293  	var initLabel string
   294  	require.NoError(t, service.RegisterBatchOutput("test_batch_output_plugin_with_config", configSpec,
   295  		func(conf *service.ParsedConfig, mgr *service.Resources) (service.BatchOutput, service.BatchPolicy, int, error) {
   296  			initConf = conf.AsStruct().(*testConfig)
   297  			initLabel = mgr.Label()
   298  			batchPolicy := service.BatchPolicy{Count: initConf.Count}
   299  			return nil, batchPolicy, 1, errors.New("this is a test error")
   300  		}))
   301  
   302  	inConfStr := `label: foo
   303  test_batch_output_plugin_with_config:
   304      a: 20
   305      count: 21
   306  `
   307  
   308  	inConf := output.NewConfig()
   309  	require.NoError(t, yaml.Unmarshal([]byte(inConfStr), &inConf))
   310  
   311  	var outNode yaml.Node
   312  	require.NoError(t, outNode.Encode(inConf))
   313  
   314  	require.NoError(t, docs.SanitiseYAML(docs.TypeOutput, &outNode, docs.SanitiseConfig{
   315  		RemoveTypeField:  true,
   316  		RemoveDeprecated: true,
   317  	}))
   318  
   319  	outConfOutBytes, err := yaml.Marshal(outNode)
   320  	require.NoError(t, err)
   321  	assert.Equal(t, inConfStr, string(outConfOutBytes))
   322  
   323  	mgr, err := manager.New(manager.NewConfig(), types.NoopMgr(), log.Noop(), metrics.Noop())
   324  	require.NoError(t, err)
   325  
   326  	_, err = mgr.NewOutput(inConf)
   327  	assert.EqualError(t, err, "failed to create output 'test_batch_output_plugin_with_config': this is a test error")
   328  	require.NotNil(t, initConf)
   329  	assert.Equal(t, 20, initConf.A)
   330  	assert.Equal(t, 21, initConf.Count)
   331  	assert.Equal(t, "foo", initLabel)
   332  }
   333  
   334  func TestBatchOutputPluginWithoutConfig(t *testing.T) {
   335  	configSpec := service.NewConfigSpec()
   336  
   337  	var initLabel string
   338  	require.NoError(t, service.RegisterOutput("test_batch_output_plugin_without_config", configSpec,
   339  		func(conf *service.ParsedConfig, mgr *service.Resources) (service.Output, int, error) {
   340  			initLabel = mgr.Label()
   341  			return nil, 1, errors.New("this is a test error")
   342  		}))
   343  
   344  	inConfStr := `label: foo
   345  test_batch_output_plugin_without_config: null
   346  `
   347  
   348  	inConf := output.NewConfig()
   349  	require.NoError(t, yaml.Unmarshal([]byte(inConfStr), &inConf))
   350  
   351  	var outNode yaml.Node
   352  	require.NoError(t, outNode.Encode(inConf))
   353  
   354  	require.NoError(t, docs.SanitiseYAML(docs.TypeOutput, &outNode, docs.SanitiseConfig{
   355  		RemoveTypeField:  true,
   356  		RemoveDeprecated: true,
   357  	}))
   358  
   359  	outConfOutBytes, err := yaml.Marshal(outNode)
   360  	require.NoError(t, err)
   361  	assert.Equal(t, inConfStr, string(outConfOutBytes))
   362  
   363  	mgr, err := manager.New(manager.NewConfig(), types.NoopMgr(), log.Noop(), metrics.Noop())
   364  	require.NoError(t, err)
   365  
   366  	_, err = mgr.NewOutput(inConf)
   367  	assert.EqualError(t, err, "failed to create output 'test_batch_output_plugin_without_config': this is a test error")
   368  	assert.Equal(t, "foo", initLabel)
   369  }
   370  
   371  func TestProcessorPluginWithConfig(t *testing.T) {
   372  	type testConfig struct {
   373  		A int `yaml:"a"`
   374  	}
   375  
   376  	configSpec, err := service.NewStructConfigSpec(func() interface{} {
   377  		return &testConfig{A: 100}
   378  	})
   379  	require.NoError(t, err)
   380  
   381  	var initConf *testConfig
   382  	var initLabel string
   383  	require.NoError(t, service.RegisterProcessor("test_processor_plugin_with_config", configSpec,
   384  		func(conf *service.ParsedConfig, mgr *service.Resources) (service.Processor, error) {
   385  			initConf = conf.AsStruct().(*testConfig)
   386  			initLabel = mgr.Label()
   387  			return nil, errors.New("this is a test error")
   388  		}))
   389  
   390  	inConfStr := `label: foo
   391  test_processor_plugin_with_config:
   392      a: 20
   393  `
   394  
   395  	inConf := processor.NewConfig()
   396  	require.NoError(t, yaml.Unmarshal([]byte(inConfStr), &inConf))
   397  
   398  	var outNode yaml.Node
   399  	require.NoError(t, outNode.Encode(inConf))
   400  
   401  	require.NoError(t, docs.SanitiseYAML(docs.TypeProcessor, &outNode, docs.SanitiseConfig{
   402  		RemoveTypeField:  true,
   403  		RemoveDeprecated: true,
   404  	}))
   405  
   406  	outConfOutBytes, err := yaml.Marshal(outNode)
   407  	require.NoError(t, err)
   408  	assert.Equal(t, inConfStr, string(outConfOutBytes))
   409  
   410  	mgr, err := manager.New(manager.NewConfig(), types.NoopMgr(), log.Noop(), metrics.Noop())
   411  	require.NoError(t, err)
   412  
   413  	_, err = mgr.NewProcessor(inConf)
   414  	assert.EqualError(t, err, "this is a test error")
   415  	require.NotNil(t, initConf)
   416  	assert.Equal(t, 20, initConf.A)
   417  	assert.Equal(t, "foo", initLabel)
   418  }
   419  
   420  func TestProcessorPluginWithoutConfig(t *testing.T) {
   421  	configSpec := service.NewConfigSpec()
   422  
   423  	var initLabel string
   424  	require.NoError(t, service.RegisterProcessor("test_processor_plugin_without_config", configSpec,
   425  		func(conf *service.ParsedConfig, mgr *service.Resources) (service.Processor, error) {
   426  			initLabel = mgr.Label()
   427  			return nil, errors.New("this is a test error")
   428  		}))
   429  
   430  	inConfStr := `label: foo
   431  test_processor_plugin_without_config: null
   432  `
   433  
   434  	inConf := processor.NewConfig()
   435  	require.NoError(t, yaml.Unmarshal([]byte(inConfStr), &inConf))
   436  
   437  	var outNode yaml.Node
   438  	require.NoError(t, outNode.Encode(inConf))
   439  
   440  	require.NoError(t, docs.SanitiseYAML(docs.TypeProcessor, &outNode, docs.SanitiseConfig{
   441  		RemoveTypeField:  true,
   442  		RemoveDeprecated: true,
   443  	}))
   444  
   445  	outConfOutBytes, err := yaml.Marshal(outNode)
   446  	require.NoError(t, err)
   447  	assert.Equal(t, inConfStr, string(outConfOutBytes))
   448  
   449  	mgr, err := manager.New(manager.NewConfig(), types.NoopMgr(), log.Noop(), metrics.Noop())
   450  	require.NoError(t, err)
   451  
   452  	_, err = mgr.NewProcessor(inConf)
   453  	assert.EqualError(t, err, "this is a test error")
   454  	assert.Equal(t, "foo", initLabel)
   455  }
   456  
   457  func TestBatchProcessorPluginWithConfig(t *testing.T) {
   458  	type testConfig struct {
   459  		A int `yaml:"a"`
   460  	}
   461  
   462  	configSpec, err := service.NewStructConfigSpec(func() interface{} {
   463  		return &testConfig{A: 100}
   464  	})
   465  	require.NoError(t, err)
   466  
   467  	var initConf *testConfig
   468  	var initLabel string
   469  	require.NoError(t, service.RegisterBatchProcessor("test_batch_processor_plugin_with_config", configSpec,
   470  		func(conf *service.ParsedConfig, mgr *service.Resources) (service.BatchProcessor, error) {
   471  			initConf = conf.AsStruct().(*testConfig)
   472  			initLabel = mgr.Label()
   473  			return nil, errors.New("this is a test error")
   474  		}))
   475  
   476  	inConfStr := `label: foo
   477  test_batch_processor_plugin_with_config:
   478      a: 20
   479  `
   480  
   481  	inConf := processor.NewConfig()
   482  	require.NoError(t, yaml.Unmarshal([]byte(inConfStr), &inConf))
   483  
   484  	var outNode yaml.Node
   485  	require.NoError(t, outNode.Encode(inConf))
   486  
   487  	require.NoError(t, docs.SanitiseYAML(docs.TypeProcessor, &outNode, docs.SanitiseConfig{
   488  		RemoveTypeField:  true,
   489  		RemoveDeprecated: true,
   490  	}))
   491  
   492  	outConfOutBytes, err := yaml.Marshal(outNode)
   493  	require.NoError(t, err)
   494  	assert.Equal(t, inConfStr, string(outConfOutBytes))
   495  
   496  	mgr, err := manager.New(manager.NewConfig(), types.NoopMgr(), log.Noop(), metrics.Noop())
   497  	require.NoError(t, err)
   498  
   499  	_, err = mgr.NewProcessor(inConf)
   500  	assert.EqualError(t, err, "this is a test error")
   501  	require.NotNil(t, initConf)
   502  	assert.Equal(t, 20, initConf.A)
   503  	assert.Equal(t, "foo", initLabel)
   504  }
   505  
   506  func TestBatchProcessorPluginWithoutConfig(t *testing.T) {
   507  	configSpec := service.NewConfigSpec()
   508  
   509  	var initLabel string
   510  	require.NoError(t, service.RegisterBatchProcessor("test_batch_processor_plugin_without_config", configSpec,
   511  		func(conf *service.ParsedConfig, mgr *service.Resources) (service.BatchProcessor, error) {
   512  			initLabel = mgr.Label()
   513  			return nil, errors.New("this is a test error")
   514  		}))
   515  
   516  	inConfStr := `label: foo
   517  test_batch_processor_plugin_without_config: null
   518  `
   519  
   520  	inConf := processor.NewConfig()
   521  	require.NoError(t, yaml.Unmarshal([]byte(inConfStr), &inConf))
   522  
   523  	var outNode yaml.Node
   524  	require.NoError(t, outNode.Encode(inConf))
   525  
   526  	require.NoError(t, docs.SanitiseYAML(docs.TypeProcessor, &outNode, docs.SanitiseConfig{
   527  		RemoveTypeField:  true,
   528  		RemoveDeprecated: true,
   529  	}))
   530  
   531  	outConfOutBytes, err := yaml.Marshal(outNode)
   532  	require.NoError(t, err)
   533  	assert.Equal(t, inConfStr, string(outConfOutBytes))
   534  
   535  	mgr, err := manager.New(manager.NewConfig(), types.NoopMgr(), log.Noop(), metrics.Noop())
   536  	require.NoError(t, err)
   537  
   538  	_, err = mgr.NewProcessor(inConf)
   539  	assert.EqualError(t, err, "this is a test error")
   540  	assert.Equal(t, "foo", initLabel)
   541  }
   542  
   543  func TestRateLimitPluginWithConfig(t *testing.T) {
   544  	type testConfig struct {
   545  		A int `yaml:"a"`
   546  	}
   547  
   548  	configSpec, err := service.NewStructConfigSpec(func() interface{} {
   549  		return &testConfig{A: 100}
   550  	})
   551  	require.NoError(t, err)
   552  
   553  	var initConf *testConfig
   554  	var initLabel string
   555  	require.NoError(t, service.RegisterRateLimit("test_rate_limit_plugin_with_config", configSpec,
   556  		func(conf *service.ParsedConfig, mgr *service.Resources) (service.RateLimit, error) {
   557  			initConf = conf.AsStruct().(*testConfig)
   558  			initLabel = mgr.Label()
   559  			return nil, errors.New("this is a test error")
   560  		}))
   561  
   562  	inConfStr := `label: foo
   563  test_rate_limit_plugin_with_config:
   564      a: 20
   565  `
   566  
   567  	inConf := ratelimit.NewConfig()
   568  	require.NoError(t, yaml.Unmarshal([]byte(inConfStr), &inConf))
   569  
   570  	var outNode yaml.Node
   571  	require.NoError(t, outNode.Encode(inConf))
   572  
   573  	require.NoError(t, docs.SanitiseYAML(docs.TypeRateLimit, &outNode, docs.SanitiseConfig{
   574  		RemoveTypeField:  true,
   575  		RemoveDeprecated: true,
   576  	}))
   577  
   578  	outConfOutBytes, err := yaml.Marshal(outNode)
   579  	require.NoError(t, err)
   580  	assert.Equal(t, inConfStr, string(outConfOutBytes))
   581  
   582  	mgr, err := manager.New(manager.NewConfig(), types.NoopMgr(), log.Noop(), metrics.Noop())
   583  	require.NoError(t, err)
   584  
   585  	_, err = mgr.NewRateLimit(inConf)
   586  	assert.EqualError(t, err, "this is a test error")
   587  	require.NotNil(t, initConf)
   588  	assert.Equal(t, 20, initConf.A)
   589  	assert.Equal(t, "foo", initLabel)
   590  }
   591  
   592  func TestRateLimitPluginWithoutConfig(t *testing.T) {
   593  	configSpec := service.NewConfigSpec()
   594  
   595  	var initLabel string
   596  	require.NoError(t, service.RegisterRateLimit("test_rate_limit_plugin_without_config", configSpec,
   597  		func(conf *service.ParsedConfig, mgr *service.Resources) (service.RateLimit, error) {
   598  			initLabel = mgr.Label()
   599  			return nil, errors.New("this is a test error")
   600  		}))
   601  
   602  	inConfStr := `label: foo
   603  test_rate_limit_plugin_without_config: null
   604  `
   605  
   606  	inConf := ratelimit.NewConfig()
   607  	require.NoError(t, yaml.Unmarshal([]byte(inConfStr), &inConf))
   608  
   609  	var outNode yaml.Node
   610  	require.NoError(t, outNode.Encode(inConf))
   611  
   612  	require.NoError(t, docs.SanitiseYAML(docs.TypeRateLimit, &outNode, docs.SanitiseConfig{
   613  		RemoveTypeField:  true,
   614  		RemoveDeprecated: true,
   615  	}))
   616  
   617  	outConfOutBytes, err := yaml.Marshal(outNode)
   618  	require.NoError(t, err)
   619  	assert.Equal(t, inConfStr, string(outConfOutBytes))
   620  
   621  	mgr, err := manager.New(manager.NewConfig(), types.NoopMgr(), log.Noop(), metrics.Noop())
   622  	require.NoError(t, err)
   623  
   624  	_, err = mgr.NewRateLimit(inConf)
   625  	assert.EqualError(t, err, "this is a test error")
   626  	assert.Equal(t, "foo", initLabel)
   627  }