github.com/Jeffail/benthos/v3@v3.65.0/internal/interop/resources_test.go (about)

     1  package interop_test
     2  
     3  import (
     4  	"context"
     5  	"net/http"
     6  	"testing"
     7  
     8  	"github.com/Jeffail/benthos/v3/internal/interop"
     9  	"github.com/Jeffail/benthos/v3/lib/cache"
    10  	"github.com/Jeffail/benthos/v3/lib/input"
    11  	"github.com/Jeffail/benthos/v3/lib/log"
    12  	"github.com/Jeffail/benthos/v3/lib/manager"
    13  	"github.com/Jeffail/benthos/v3/lib/metrics"
    14  	"github.com/Jeffail/benthos/v3/lib/output"
    15  	"github.com/Jeffail/benthos/v3/lib/processor"
    16  	"github.com/Jeffail/benthos/v3/lib/ratelimit"
    17  	"github.com/Jeffail/benthos/v3/lib/types"
    18  	"github.com/stretchr/testify/assert"
    19  	"github.com/stretchr/testify/require"
    20  
    21  	_ "github.com/Jeffail/benthos/v3/public/components/all"
    22  )
    23  
    24  func TestMissingProbesNewIface(t *testing.T) {
    25  	mgr, err := manager.NewV2(manager.NewResourceConfig(), nil, log.Noop(), metrics.Noop())
    26  	require.NoError(t, err)
    27  
    28  	ctx := context.Background()
    29  
    30  	assert.EqualError(t, interop.ProbeCache(ctx, mgr, "foo"), "cache resource 'foo' was not found")
    31  	assert.EqualError(t, interop.ProbeInput(ctx, mgr, "bar"), "input resource 'bar' was not found")
    32  	assert.EqualError(t, interop.ProbeOutput(ctx, mgr, "baz"), "output resource 'baz' was not found")
    33  	assert.EqualError(t, interop.ProbeProcessor(ctx, mgr, "buz"), "processor resource 'buz' was not found")
    34  	assert.EqualError(t, interop.ProbeRateLimit(ctx, mgr, "bev"), "rate limit resource 'bev' was not found")
    35  
    36  	assert.EqualError(t, interop.AccessCache(ctx, mgr, "foo", nil), "unable to locate resource: foo")
    37  	assert.EqualError(t, interop.AccessInput(ctx, mgr, "bar", nil), "unable to locate resource: bar")
    38  	assert.EqualError(t, interop.AccessOutput(ctx, mgr, "baz", nil), "unable to locate resource: baz")
    39  	assert.EqualError(t, interop.AccessProcessor(ctx, mgr, "buz", nil), "unable to locate resource: buz")
    40  	assert.EqualError(t, interop.AccessRateLimit(ctx, mgr, "bev", nil), "unable to locate resource: bev")
    41  
    42  	inConf := input.NewConfig()
    43  	inConf.Type = input.TypeDynamic
    44  
    45  	outConf := output.NewConfig()
    46  	outConf.Type = output.TypeDynamic
    47  
    48  	require.NoError(t, mgr.StoreCache(ctx, "foo", cache.NewConfig()))
    49  	require.NoError(t, mgr.StoreInput(ctx, "bar", inConf))
    50  	require.NoError(t, mgr.StoreOutput(ctx, "baz", outConf))
    51  	require.NoError(t, mgr.StoreProcessor(ctx, "buz", processor.NewConfig()))
    52  	require.NoError(t, mgr.StoreRateLimit(ctx, "bev", ratelimit.NewConfig()))
    53  
    54  	assert.NoError(t, interop.ProbeCache(ctx, mgr, "foo"))
    55  	assert.NoError(t, interop.ProbeInput(ctx, mgr, "bar"))
    56  	assert.NoError(t, interop.ProbeOutput(ctx, mgr, "baz"))
    57  	assert.NoError(t, interop.ProbeProcessor(ctx, mgr, "buz"))
    58  	assert.NoError(t, interop.ProbeRateLimit(ctx, mgr, "bev"))
    59  
    60  	var ccalled, icalled, ocalled, pcalled, rcalled bool
    61  	assert.NoError(t, interop.AccessCache(ctx, mgr, "foo", func(c types.Cache) {
    62  		ccalled = true
    63  	}))
    64  	assert.True(t, ccalled)
    65  	assert.NoError(t, interop.AccessInput(ctx, mgr, "bar", func(i types.Input) {
    66  		icalled = true
    67  	}))
    68  	assert.True(t, icalled)
    69  	assert.NoError(t, interop.AccessOutput(ctx, mgr, "baz", func(ow types.OutputWriter) {
    70  		ocalled = true
    71  	}))
    72  	assert.True(t, ocalled)
    73  	assert.NoError(t, interop.AccessProcessor(ctx, mgr, "buz", func(p types.Processor) {
    74  		pcalled = true
    75  	}))
    76  	assert.True(t, pcalled)
    77  	assert.NoError(t, interop.AccessRateLimit(ctx, mgr, "bev", func(rl types.RateLimit) {
    78  		rcalled = true
    79  	}))
    80  	assert.True(t, rcalled)
    81  }
    82  
    83  func TestMissingProbesNoSupport(t *testing.T) {
    84  	ctx := context.Background()
    85  
    86  	assert.EqualError(t, interop.ProbeInput(ctx, nil, "bar"), "manager does not support input resources")
    87  	assert.EqualError(t, interop.ProbeOutput(ctx, nil, "baz"), "manager does not support output resources")
    88  	assert.EqualError(t, interop.ProbeProcessor(ctx, nil, "buz"), "manager does not support processor resources")
    89  }
    90  
    91  type oldMgr struct {
    92  	caches     map[string]types.Cache
    93  	inputs     map[string]types.Input
    94  	outputs    map[string]types.OutputWriter
    95  	processors map[string]types.Processor
    96  	ratelimits map[string]types.RateLimit
    97  }
    98  
    99  func (o *oldMgr) RegisterEndpoint(path, desc string, h http.HandlerFunc) {
   100  }
   101  
   102  func (o *oldMgr) GetCache(name string) (types.Cache, error) {
   103  	if c, ok := o.caches[name]; ok {
   104  		return c, nil
   105  	}
   106  	return nil, types.ErrCacheNotFound
   107  }
   108  
   109  func (o *oldMgr) GetCondition(name string) (types.Condition, error) {
   110  	return nil, types.ErrConditionNotFound
   111  }
   112  
   113  func (o *oldMgr) GetRateLimit(name string) (types.RateLimit, error) {
   114  	if c, ok := o.ratelimits[name]; ok {
   115  		return c, nil
   116  	}
   117  	return nil, types.ErrRateLimitNotFound
   118  }
   119  
   120  func (o *oldMgr) GetPlugin(name string) (interface{}, error) {
   121  	return nil, types.ErrPluginNotFound
   122  }
   123  
   124  func (o *oldMgr) GetPipe(name string) (<-chan types.Transaction, error) {
   125  	return nil, types.ErrPipeNotFound
   126  }
   127  
   128  func (o *oldMgr) SetPipe(name string, t <-chan types.Transaction) {}
   129  
   130  func (o *oldMgr) UnsetPipe(name string, t <-chan types.Transaction) {}
   131  
   132  type oldMgr2 struct {
   133  	*oldMgr
   134  }
   135  
   136  func (o *oldMgr2) GetInput(name string) (types.Input, error) {
   137  	if c, ok := o.inputs[name]; ok {
   138  		return c, nil
   139  	}
   140  	return nil, types.ErrInputNotFound
   141  }
   142  
   143  func (o *oldMgr2) GetOutput(name string) (types.OutputWriter, error) {
   144  	if c, ok := o.outputs[name]; ok {
   145  		return c, nil
   146  	}
   147  	return nil, types.ErrOutputNotFound
   148  }
   149  
   150  func (o *oldMgr2) GetProcessor(name string) (types.Processor, error) {
   151  	if c, ok := o.processors[name]; ok {
   152  		return c, nil
   153  	}
   154  	return nil, types.ErrProcessorNotFound
   155  }
   156  
   157  func TestMissingProbesOldIface(t *testing.T) {
   158  	mgr := &oldMgr{
   159  		caches:     map[string]types.Cache{},
   160  		inputs:     map[string]types.Input{},
   161  		outputs:    map[string]types.OutputWriter{},
   162  		processors: map[string]types.Processor{},
   163  		ratelimits: map[string]types.RateLimit{},
   164  	}
   165  	mgr2 := &oldMgr2{mgr}
   166  
   167  	ctx := context.Background()
   168  
   169  	assert.EqualError(t, interop.ProbeCache(ctx, mgr, "foo"), "cache resource 'foo' was not found")
   170  	assert.EqualError(t, interop.ProbeInput(ctx, mgr, "bar"), "manager does not support input resources")
   171  	assert.EqualError(t, interop.ProbeInput(ctx, mgr2, "bar"), "input resource 'bar' was not found")
   172  	assert.EqualError(t, interop.ProbeOutput(ctx, mgr, "baz"), "manager does not support output resources")
   173  	assert.EqualError(t, interop.ProbeOutput(ctx, mgr2, "baz"), "output resource 'baz' was not found")
   174  	assert.EqualError(t, interop.ProbeProcessor(ctx, mgr, "buz"), "manager does not support processor resources")
   175  	assert.EqualError(t, interop.ProbeProcessor(ctx, mgr2, "buz"), "processor resource 'buz' was not found")
   176  	assert.EqualError(t, interop.ProbeRateLimit(ctx, mgr, "bev"), "rate limit resource 'bev' was not found")
   177  
   178  	mgr.caches["foo"] = nil
   179  	mgr.inputs["bar"] = nil
   180  	mgr.outputs["baz"] = nil
   181  	mgr.processors["buz"] = nil
   182  	mgr.ratelimits["bev"] = nil
   183  
   184  	assert.NoError(t, interop.ProbeCache(ctx, mgr, "foo"))
   185  	assert.EqualError(t, interop.ProbeInput(ctx, mgr, "bar"), "manager does not support input resources")
   186  	assert.NoError(t, interop.ProbeInput(ctx, mgr2, "bar"))
   187  	assert.EqualError(t, interop.ProbeOutput(ctx, mgr, "baz"), "manager does not support output resources")
   188  	assert.NoError(t, interop.ProbeOutput(ctx, mgr2, "baz"))
   189  	assert.EqualError(t, interop.ProbeProcessor(ctx, mgr, "buz"), "manager does not support processor resources")
   190  	assert.NoError(t, interop.ProbeProcessor(ctx, mgr2, "buz"))
   191  	assert.NoError(t, interop.ProbeRateLimit(ctx, mgr, "bev"))
   192  
   193  	assert.EqualError(t, interop.AccessCache(ctx, mgr, "foo", nil), "cache not found")
   194  	assert.EqualError(t, interop.AccessInput(ctx, mgr, "bar", nil), "manager does not support input resources")
   195  	assert.EqualError(t, interop.AccessInput(ctx, mgr2, "bar", nil), "input not found")
   196  	assert.EqualError(t, interop.AccessOutput(ctx, mgr, "baz", nil), "manager does not support output resources")
   197  	assert.EqualError(t, interop.AccessOutput(ctx, mgr2, "baz", nil), "output not found")
   198  	assert.EqualError(t, interop.AccessProcessor(ctx, mgr, "buz", nil), "manager does not support processor resources")
   199  	assert.EqualError(t, interop.AccessProcessor(ctx, mgr2, "buz", nil), "processor not found")
   200  	assert.EqualError(t, interop.AccessRateLimit(ctx, mgr, "bev", nil), "rate limit not found")
   201  }