Add convenience interface in consumertest that implements all consumers

Signed-off-by: Bogdan Drutu <[email protected]>

component/componenttest/nop_exporter.go

@@ -20,7 +20,6 @@ import (
 	"go.opentelemetry.io/collector/component"
 	"go.opentelemetry.io/collector/component/componenthelper"
 	"go.opentelemetry.io/collector/config"
-	"go.opentelemetry.io/collector/consumer"
 	"go.opentelemetry.io/collector/consumer/consumertest"
 )
 
@@ -75,15 +74,11 @@ func (f *nopExporterFactory) CreateLogsExporter(
 
 var nopExporterInstance = &nopExporter{
 	Component: componenthelper.New(),
-	Traces:    consumertest.NewTracesNop(),
-	Metrics:   consumertest.NewMetricsNop(),
-	Logs:      consumertest.NewLogsNop(),
+	Consumer:  consumertest.NewNop(),
 }
 
 // nopExporter stores consumed traces and metrics for testing purposes.
 type nopExporter struct {
 	component.Component
-	consumer.Traces
-	consumer.Metrics
-	consumer.Logs
+	consumertest.Consumer
 }

component/componenttest/nop_processor.go

@@ -78,17 +78,13 @@ func (f *nopProcessorFactory) CreateLogsProcessor(
 
 var nopProcessorInstance = &nopProcessor{
 	Component: componenthelper.New(),
-	Traces:    consumertest.NewTracesNop(),
-	Metrics:   consumertest.NewMetricsNop(),
-	Logs:      consumertest.NewLogsNop(),
+	Consumer:  consumertest.NewNop(),
 }
 
 // nopProcessor stores consumed traces and metrics for testing purposes.
 type nopProcessor struct {
 	component.Component
-	consumer.Traces
-	consumer.Metrics
-	consumer.Logs
+	consumertest.Consumer
 }
 
 func (*nopProcessor) GetCapabilities() component.ProcessorCapabilities {

component/componenttest/nop_processor_test.go

@@ -34,21 +34,21 @@ func TestNewNopProcessorFactory(t *testing.T) {
 	cfg := factory.CreateDefaultConfig()
 	assert.Equal(t, &config.ProcessorSettings{TypeVal: factory.Type()}, cfg)
 
-	traces, err := factory.CreateTracesProcessor(context.Background(), component.ProcessorCreateParams{}, cfg, consumertest.NewTracesNop())
+	traces, err := factory.CreateTracesProcessor(context.Background(), component.ProcessorCreateParams{}, cfg, consumertest.NewNop())
 	require.NoError(t, err)
 	assert.Equal(t, component.ProcessorCapabilities{MutatesConsumedData: false}, traces.GetCapabilities())
 	assert.NoError(t, traces.Start(context.Background(), NewNopHost()))
 	assert.NoError(t, traces.ConsumeTraces(context.Background(), pdata.NewTraces()))
 	assert.NoError(t, traces.Shutdown(context.Background()))
 
-	metrics, err := factory.CreateMetricsProcessor(context.Background(), component.ProcessorCreateParams{}, cfg, consumertest.NewMetricsNop())
+	metrics, err := factory.CreateMetricsProcessor(context.Background(), component.ProcessorCreateParams{}, cfg, consumertest.NewNop())
 	require.NoError(t, err)
 	assert.Equal(t, component.ProcessorCapabilities{MutatesConsumedData: false}, metrics.GetCapabilities())
 	assert.NoError(t, metrics.Start(context.Background(), NewNopHost()))
 	assert.NoError(t, metrics.ConsumeMetrics(context.Background(), pdata.NewMetrics()))
 	assert.NoError(t, metrics.Shutdown(context.Background()))
 
-	logs, err := factory.CreateLogsProcessor(context.Background(), component.ProcessorCreateParams{}, cfg, consumertest.NewLogsNop())
+	logs, err := factory.CreateLogsProcessor(context.Background(), component.ProcessorCreateParams{}, cfg, consumertest.NewNop())
 	require.NoError(t, err)
 	assert.Equal(t, component.ProcessorCapabilities{MutatesConsumedData: false}, logs.GetCapabilities())
 	assert.NoError(t, logs.Start(context.Background(), NewNopHost()))

component/componenttest/nop_receiver_test.go

@@ -33,17 +33,17 @@ func TestNewNopReceiverFactory(t *testing.T) {
 	cfg := factory.CreateDefaultConfig()
 	assert.Equal(t, &config.ReceiverSettings{TypeVal: factory.Type()}, cfg)
 
-	traces, err := factory.CreateTracesReceiver(context.Background(), component.ReceiverCreateParams{}, cfg, consumertest.NewTracesNop())
+	traces, err := factory.CreateTracesReceiver(context.Background(), component.ReceiverCreateParams{}, cfg, consumertest.NewNop())
 	require.NoError(t, err)
 	assert.NoError(t, traces.Start(context.Background(), NewNopHost()))
 	assert.NoError(t, traces.Shutdown(context.Background()))
 
-	metrics, err := factory.CreateMetricsReceiver(context.Background(), component.ReceiverCreateParams{}, cfg, consumertest.NewMetricsNop())
+	metrics, err := factory.CreateMetricsReceiver(context.Background(), component.ReceiverCreateParams{}, cfg, consumertest.NewNop())
 	require.NoError(t, err)
 	assert.NoError(t, metrics.Start(context.Background(), NewNopHost()))
 	assert.NoError(t, metrics.Shutdown(context.Background()))
 
-	logs, err := factory.CreateLogsReceiver(context.Background(), component.ReceiverCreateParams{}, cfg, consumertest.NewLogsNop())
+	logs, err := factory.CreateLogsReceiver(context.Background(), component.ReceiverCreateParams{}, cfg, consumertest.NewNop())
 	require.NoError(t, err)
 	assert.NoError(t, logs.Start(context.Background(), NewNopHost()))
 	assert.NoError(t, logs.Shutdown(context.Background()))

consumer/consumertest/consumer.go

@@ -0,0 +1,17 @@
+package consumertest
+
+import (
+	"go.opentelemetry.io/collector/consumer"
+)
+
+// Consumer is a convenience interface that implements all consumer interfaces.
+// It has a private function on it to forbid external users to implement it,
+// to allow us to add extra functions without breaking compatibility because
+// nobody else implements this interface.
+type Consumer interface {
+	consumer.Logs
+	consumer.Metrics
+	consumer.Traces
+
+	unexported()
+}

consumer/consumertest/err.go

@@ -25,6 +25,10 @@ type errConsumer struct {
 	err error
 }
 
+func (er *errConsumer) unexported() {
+	panic("must not be called")
+}
+
 func (er *errConsumer) ConsumeTraces(context.Context, pdata.Traces) error {
 	return er.err
 }
@@ -37,17 +41,25 @@ func (er *errConsumer) ConsumeLogs(context.Context, pdata.Logs) error {
 	return er.err
 }
 
+// NewErr returns a Consumer that just drops all received data and returns no error.
+func NewErr(err error) Consumer {
+	return &errConsumer{err: err}
+}
+
 // NewTracesErr returns a consumer.Traces that just drops all received data and returns the given error.
+// Deprecated: Use NewErr().
 func NewTracesErr(err error) consumer.Traces {
 	return &errConsumer{err: err}
 }
 
 // NewMetricsErr returns a consumer.Metrics that just drops all received data and returns the given error.
+// Deprecated: Use NewErr().
 func NewMetricsErr(err error) consumer.Metrics {
 	return &errConsumer{err: err}
 }
 
 // NewLogsErr returns a consumer.Logs that just drops all received data and returns the given error.
+// Deprecated: Use NewErr().
 func NewLogsErr(err error) consumer.Logs {
 	return &errConsumer{err: err}
 }

consumer/consumertest/err_test.go

@@ -25,6 +25,15 @@ import (
 	"go.opentelemetry.io/collector/consumer/pdata"
 )
 
+func TestErr(t *testing.T) {
+	err := errors.New("my error")
+	ec := NewErr(err)
+	require.NotNil(t, ec)
+	assert.Equal(t, err, ec.ConsumeLogs(context.Background(), pdata.NewLogs()))
+	assert.Equal(t, err, ec.ConsumeMetrics(context.Background(), pdata.NewMetrics()))
+	assert.Equal(t, err, ec.ConsumeTraces(context.Background(), pdata.NewTraces()))
+}
+
 func TestTracesErr(t *testing.T) {
 	err := errors.New("my error")
 	nt := NewTracesErr(err)

consumer/consumertest/nop.go

@@ -27,6 +27,10 @@ var (
 
 type nopConsumer struct{}
 
+func (nc *nopConsumer) unexported() {
+	panic("must not be called")
+}
+
 func (nc *nopConsumer) ConsumeTraces(context.Context, pdata.Traces) error {
 	return nil
 }
@@ -39,17 +43,25 @@ func (nc *nopConsumer) ConsumeLogs(context.Context, pdata.Logs) error {
 	return nil
 }
 
+// NewNop returns a Consumer that just drops all received data and returns no error.
+func NewNop() Consumer {
+	return nopInstance
+}
+
 // NewTracesNop returns a consumer.Traces that just drops all received data and returns no error.
+// Deprecated: Use NewNop().
 func NewTracesNop() consumer.Traces {
 	return nopInstance
 }
 
 // NewMetricsNop returns a consumer.Metrics that just drops all received data and returns no error.
+// Deprecated: Use NewNop().
 func NewMetricsNop() consumer.Metrics {
 	return nopInstance
 }
 
 // NewLogsNop returns a consumer.Logs that just drops all received data and returns no error.
+// Deprecated: Use NewNop().
 func NewLogsNop() consumer.Logs {
 	return nopInstance
 }

consumer/consumertest/nop_test.go

@@ -24,6 +24,14 @@ import (
 	"go.opentelemetry.io/collector/consumer/pdata"
 )
 
+func TestNop(t *testing.T) {
+	nc := NewNop()
+	require.NotNil(t, nc)
+	assert.NoError(t, nc.ConsumeLogs(context.Background(), pdata.NewLogs()))
+	assert.NoError(t, nc.ConsumeMetrics(context.Background(), pdata.NewMetrics()))
+	assert.NoError(t, nc.ConsumeTraces(context.Background(), pdata.NewTraces()))
+}
+
 func TestTracesNop(t *testing.T) {
 	nt := NewTracesNop()
 	require.NotNil(t, nt)

consumer/fanoutconsumer/cloningconsumer_test.go

@@ -26,7 +26,7 @@ import (
 )
 
 func TestTraceProcessorCloningNotMultiplexing(t *testing.T) {
-	nop := consumertest.NewTracesNop()
+	nop := consumertest.NewNop()
 	tfc := NewTracesCloning([]consumer.Traces{nop})
 	assert.Same(t, nop, tfc)
 }
@@ -69,7 +69,7 @@ func TestTraceProcessorCloningMultiplexing(t *testing.T) {
 }
 
 func TestMetricsProcessorCloningNotMultiplexing(t *testing.T) {
-	nop := consumertest.NewMetricsNop()
+	nop := consumertest.NewNop()
 	mfc := NewMetrics([]consumer.Metrics{nop})
 	assert.Same(t, nop, mfc)
 }
@@ -112,7 +112,7 @@ func TestMetricsProcessorCloningMultiplexing(t *testing.T) {
 }
 
 func TestLogsProcessorCloningNotMultiplexing(t *testing.T) {
-	nop := consumertest.NewLogsNop()
+	nop := consumertest.NewNop()
 	lfc := NewLogsCloning([]consumer.Logs{nop})
 	assert.Same(t, nop, lfc)
 }

consumer/fanoutconsumer/consumer_test.go

@@ -27,7 +27,7 @@ import (
 )
 
 func TestTracesProcessorNotMultiplexing(t *testing.T) {
-	nop := consumertest.NewTracesNop()
+	nop := consumertest.NewNop()
 	tfc := NewTraces([]consumer.Traces{nop})
 	assert.Same(t, nop, tfc)
 }
@@ -65,7 +65,7 @@ func TestTraceProcessorWhenOneErrors(t *testing.T) {
 	}
 
 	// Make one processor return error
-	processors[1] = consumertest.NewTracesErr(errors.New("my error"))
+	processors[1] = consumertest.NewErr(errors.New("my error"))
 
 	tfc := NewTraces(processors)
 	td := testdata.GenerateTraceDataOneSpan()
@@ -81,7 +81,7 @@ func TestTraceProcessorWhenOneErrors(t *testing.T) {
 }
 
 func TestMetricsProcessorNotMultiplexing(t *testing.T) {
-	nop := consumertest.NewMetricsNop()
+	nop := consumertest.NewNop()
 	mfc := NewMetrics([]consumer.Metrics{nop})
 	assert.Same(t, nop, mfc)
 }
@@ -119,7 +119,7 @@ func TestMetricsProcessorWhenOneErrors(t *testing.T) {
 	}
 
 	// Make one processor return error
-	processors[1] = consumertest.NewMetricsErr(errors.New("my error"))
+	processors[1] = consumertest.NewErr(errors.New("my error"))
 
 	mfc := NewMetrics(processors)
 	md := testdata.GenerateMetricsOneMetric()
@@ -135,7 +135,7 @@ func TestMetricsProcessorWhenOneErrors(t *testing.T) {
 }
 
 func TestLogsProcessorNotMultiplexing(t *testing.T) {
-	nop := consumertest.NewLogsNop()
+	nop := consumertest.NewNop()
 	lfc := NewLogs([]consumer.Logs{nop})
 	assert.Same(t, nop, lfc)
 }
@@ -173,7 +173,7 @@ func TestLogsProcessorWhenOneErrors(t *testing.T) {
 	}
 
 	// Make one processor return error
-	processors[1] = consumertest.NewLogsErr(errors.New("my error"))
+	processors[1] = consumertest.NewErr(errors.New("my error"))
 
 	lfc := NewLogs(processors)
 	ld := testdata.GenerateLogDataOneLog()

exporter/otlphttpexporter/otlp_test.go

@@ -80,7 +80,7 @@ func TestTraceInvalidUrl(t *testing.T) {
 func TestTraceError(t *testing.T) {
 	addr := testutil.GetAvailableLocalAddress(t)
 
-	startTraceReceiver(t, addr, consumertest.NewTracesErr(errors.New("my_error")))
+	startTraceReceiver(t, addr, consumertest.NewErr(errors.New("my_error")))
 	exp := startTraceExporter(t, "", fmt.Sprintf("http://%s/v1/traces", addr))
 
 	td := testdata.GenerateTraceDataOneSpan()
@@ -188,7 +188,7 @@ func TestCompressionOptions(t *testing.T) {
 func TestMetricsError(t *testing.T) {
 	addr := testutil.GetAvailableLocalAddress(t)
 
-	startMetricsReceiver(t, addr, consumertest.NewMetricsErr(errors.New("my_error")))
+	startMetricsReceiver(t, addr, consumertest.NewErr(errors.New("my_error")))
 	exp := startMetricsExporter(t, "", fmt.Sprintf("http://%s/v1/metrics", addr))
 
 	md := testdata.GenerateMetricsOneMetric()
@@ -241,7 +241,7 @@ func TestMetricsRoundTrip(t *testing.T) {
 func TestLogsError(t *testing.T) {
 	addr := testutil.GetAvailableLocalAddress(t)
 
-	startLogsReceiver(t, addr, consumertest.NewLogsErr(errors.New("my_error")))
+	startLogsReceiver(t, addr, consumertest.NewErr(errors.New("my_error")))
 	exp := startLogsExporter(t, "", fmt.Sprintf("http://%s/v1/logs", addr))
 
 	md := testdata.GenerateLogDataOneLog()

processor/attributesprocessor/attributes_log_test.go

@@ -111,7 +111,7 @@ func TestLogProcessor_NilEmptyData(t *testing.T) {
 	}
 
 	tp, err := factory.CreateLogsProcessor(
-		context.Background(), component.ProcessorCreateParams{Logger: zap.NewNop()}, oCfg, consumertest.NewLogsNop())
+		context.Background(), component.ProcessorCreateParams{Logger: zap.NewNop()}, oCfg, consumertest.NewNop())
 	require.Nil(t, err)
 	require.NotNil(t, tp)
 	for i := range testCases {
@@ -174,7 +174,7 @@ func TestAttributes_FilterLogs(t *testing.T) {
 		},
 		Config: *createConfig(filterset.Strict),
 	}
-	tp, err := factory.CreateLogsProcessor(context.Background(), component.ProcessorCreateParams{}, cfg, consumertest.NewLogsNop())
+	tp, err := factory.CreateLogsProcessor(context.Background(), component.ProcessorCreateParams{}, cfg, consumertest.NewNop())
 	require.Nil(t, err)
 	require.NotNil(t, tp)
 
@@ -237,7 +237,7 @@ func TestAttributes_FilterLogsByNameStrict(t *testing.T) {
 		LogNames: []string{"dont_apply"},
 		Config:   *createConfig(filterset.Strict),
 	}
-	tp, err := factory.CreateLogsProcessor(context.Background(), component.ProcessorCreateParams{}, cfg, consumertest.NewLogsNop())
+	tp, err := factory.CreateLogsProcessor(context.Background(), component.ProcessorCreateParams{}, cfg, consumertest.NewNop())
 	require.Nil(t, err)
 	require.NotNil(t, tp)
 
@@ -300,7 +300,7 @@ func TestAttributes_FilterLogsByNameRegexp(t *testing.T) {
 		LogNames: []string{".*dont_apply$"},
 		Config:   *createConfig(filterset.Regexp),
 	}
-	tp, err := factory.CreateLogsProcessor(context.Background(), component.ProcessorCreateParams{}, cfg, consumertest.NewLogsNop())
+	tp, err := factory.CreateLogsProcessor(context.Background(), component.ProcessorCreateParams{}, cfg, consumertest.NewNop())
 	require.Nil(t, err)
 	require.NotNil(t, tp)
 
@@ -359,7 +359,7 @@ func TestLogAttributes_Hash(t *testing.T) {
 		{Key: "user.authenticated", Action: processorhelper.HASH},
 	}
 
-	tp, err := factory.CreateLogsProcessor(context.Background(), component.ProcessorCreateParams{}, cfg, consumertest.NewLogsNop())
+	tp, err := factory.CreateLogsProcessor(context.Background(), component.ProcessorCreateParams{}, cfg, consumertest.NewNop())
 	require.Nil(t, err)
 	require.NotNil(t, tp)
 
@@ -403,7 +403,7 @@ func BenchmarkAttributes_FilterLogsByName(b *testing.B) {
 	oCfg.Include = &filterconfig.MatchProperties{
 		LogNames: []string{"^apply.*"},
 	}
-	tp, err := factory.CreateLogsProcessor(context.Background(), component.ProcessorCreateParams{}, cfg, consumertest.NewLogsNop())
+	tp, err := factory.CreateLogsProcessor(context.Background(), component.ProcessorCreateParams{}, cfg, consumertest.NewNop())
 	require.Nil(b, err)
 	require.NotNil(b, tp)