[chore]: enable require-error rule from testifylint (#11199)

#### Description

Testifylint is a linter that provides best practices with the use of
testify.

This PR enables
[require-error](https://github.com/Antonboom/testifylint?tab=readme-ov-file#require-error)
rule from [testifylint](https://github.com/Antonboom/testifylint)

Signed-off-by: Matthieu MOREL <matthieu.morel35@gmail.com>

.golangci.yml

@@ -122,9 +122,6 @@ linters-settings:
             - "!**/*_test.go"
 
   testifylint:
-    # TODO: enable all rules
-    disable:
-      - require-error
     enable-all: true   
 
 linters:

Makefile.Common

@@ -38,7 +38,7 @@ SEMCONVGEN   := $(TOOLS_BIN_DIR)/semconvgen
 SEMCONVKIT   := $(TOOLS_BIN_DIR)/semconvkit
 TESTIFYLINT  := $(TOOLS_BIN_DIR)/testifylint
 
-TESTIFYLINT_OPT?= --enable-all --disable=require-error
+TESTIFYLINT_OPT?= --enable-all
 
 .PHONY: install-tools
 install-tools: $(TOOLS_BIN_NAMES)

cmd/builder/internal/builder/config_test.go

@@ -28,7 +28,7 @@ func TestParseModules(t *testing.T) {
 
 	// test
 	err := cfg.ParseModules()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	// verify
 	assert.Equal(t, "github.com/org/repo v0.1.2", cfg.Extensions[0].GoMod)
@@ -47,7 +47,7 @@ func TestRelativePath(t *testing.T) {
 
 	// test
 	err := cfg.ParseModules()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	// verify
 	cwd, err := os.Getwd()
@@ -72,7 +72,7 @@ func TestModuleFromCore(t *testing.T) {
 
 	// test
 	err := cfg.ParseModules()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	// verify
 	assert.True(t, strings.HasPrefix(cfg.Extensions[0].Name, "otlpreceiver"))
@@ -206,7 +206,7 @@ func TestDebugOptionSetConfig(t *testing.T) {
 		SkipCompilation: true,
 		SkipGetModules:  true,
 	}
-	assert.NoError(t, cfg.Validate())
+	require.NoError(t, cfg.Validate())
 	assert.True(t, cfg.Distribution.DebugCompilation)
 }
 
@@ -314,7 +314,7 @@ func TestConfmapFactoryVersions(t *testing.T) {
 func TestAddsDefaultProviders(t *testing.T) {
 	cfg := NewDefaultConfig()
 	cfg.Providers = nil
-	assert.NoError(t, cfg.ParseModules())
+	require.NoError(t, cfg.ParseModules())
 	assert.Len(t, *cfg.Providers, 5)
 }
 

cmd/mdatagen/internal/embeded_templates_test.go

@@ -9,6 +9,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestEnsureTemplatesLoaded(t *testing.T) {
@@ -38,7 +39,7 @@ func TestEnsureTemplatesLoaded(t *testing.T) {
 		}
 		count = 0
 	)
-	assert.NoError(t, fs.WalkDir(TemplateFS, ".", func(path string, d fs.DirEntry, _ error) error {
+	require.NoError(t, fs.WalkDir(TemplateFS, ".", func(path string, d fs.DirEntry, _ error) error {
 		if d != nil && d.IsDir() {
 			return nil
 		}

component/identifiable_test.go

@@ -8,12 +8,13 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestMarshalText(t *testing.T) {
 	id := NewIDWithName(MustNewType("test"), "name")
 	got, err := id.MarshalText()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, id.String(), string(got))
 }
 
@@ -92,7 +93,7 @@ func TestUnmarshalText(t *testing.T) {
 				return
 			}
 
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.Equal(t, tt.expectedID, id)
 			assert.Equal(t, tt.expectedID.Type(), id.Type())
 			assert.Equal(t, tt.expectedID.Name(), id.Name())

config/configauth/configauth_test.go

@@ -8,6 +8,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 
 	"go.opentelemetry.io/collector/component"
 	"go.opentelemetry.io/collector/extension"
@@ -53,10 +54,10 @@ func TestGetServer(t *testing.T) {
 
 			// verify
 			if tt.expected != nil {
-				assert.ErrorIs(t, err, tt.expected)
+				require.ErrorIs(t, err, tt.expected)
 				assert.Nil(t, authenticator)
 			} else {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 				assert.NotNil(t, authenticator)
 			}
 		})
@@ -69,7 +70,7 @@ func TestGetServerFails(t *testing.T) {
 	}
 
 	authenticator, err := cfg.GetServerAuthenticator(context.Background(), map[component.ID]component.Component{})
-	assert.ErrorIs(t, err, errAuthenticatorNotFound)
+	require.ErrorIs(t, err, errAuthenticatorNotFound)
 	assert.Nil(t, authenticator)
 }
 
@@ -104,10 +105,10 @@ func TestGetClient(t *testing.T) {
 
 			// verify
 			if tt.expected != nil {
-				assert.ErrorIs(t, err, tt.expected)
+				require.ErrorIs(t, err, tt.expected)
 				assert.Nil(t, authenticator)
 			} else {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 				assert.NotNil(t, authenticator)
 			}
 		})
@@ -119,6 +120,6 @@ func TestGetClientFails(t *testing.T) {
 		AuthenticatorID: component.MustNewID("does_not_exist"),
 	}
 	authenticator, err := cfg.GetClientAuthenticator(context.Background(), map[component.ID]component.Component{})
-	assert.ErrorIs(t, err, errAuthenticatorNotFound)
+	require.ErrorIs(t, err, errAuthenticatorNotFound)
 	assert.Nil(t, authenticator)
 }

config/configgrpc/configgrpc_test.go

@@ -127,7 +127,7 @@ func TestDefaultGrpcClientSettings(t *testing.T) {
 		},
 	}
 	opts, err := gcs.toDialOptions(context.Background(), componenttest.NewNopHost(), tt.TelemetrySettings())
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Len(t, opts, 2)
 }
 
@@ -232,7 +232,7 @@ func TestAllGrpcClientSettings(t *testing.T) {
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
 			opts, err := test.settings.toDialOptions(context.Background(), test.host, tt.TelemetrySettings())
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.Len(t, opts, 9)
 		})
 	}
@@ -245,7 +245,7 @@ func TestDefaultGrpcServerSettings(t *testing.T) {
 		},
 	}
 	opts, err := gss.toServerOption(componenttest.NewNopHost(), componenttest.NewNopTelemetrySettings())
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Len(t, opts, 3)
 }
 
@@ -295,7 +295,7 @@ func TestGrpcServerValidate(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.err, func(t *testing.T) {
 			err := tt.gss.Validate()
-			assert.Error(t, err)
+			require.Error(t, err)
 			assert.Regexp(t, tt.err, err)
 		})
 	}
@@ -330,7 +330,7 @@ func TestAllGrpcServerSettingsExceptAuth(t *testing.T) {
 		},
 	}
 	opts, err := gss.toServerOption(componenttest.NewNopHost(), componenttest.NewNopTelemetrySettings())
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Len(t, opts, 10)
 }
 
@@ -349,7 +349,7 @@ func TestGrpcServerAuthSettings(t *testing.T) {
 		},
 	}
 	srv, err := gss.ToServer(context.Background(), host, componenttest.NewNopTelemetrySettings())
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.NotNil(t, srv)
 }
 
@@ -470,7 +470,7 @@ func TestGRPCClientSettingsError(t *testing.T) {
 	for _, test := range tests {
 		t.Run(test.err, func(t *testing.T) {
 			_, err := test.settings.ToClientConn(context.Background(), test.host, tt.TelemetrySettings())
-			assert.Error(t, err)
+			require.Error(t, err)
 			assert.Regexp(t, test.err, err)
 		})
 	}
@@ -489,7 +489,7 @@ func TestUseSecure(t *testing.T) {
 		Keepalive:   nil,
 	}
 	dialOpts, err := gcs.toDialOptions(context.Background(), componenttest.NewNopHost(), tt.TelemetrySettings())
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Len(t, dialOpts, 2)
 }
 
@@ -735,9 +735,9 @@ func TestHttpReception(t *testing.T) {
 				TLSSetting: test.tlsServerCreds,
 			}
 			ln, err := gss.NetAddr.Listen(context.Background())
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			s, err := gss.ToServer(context.Background(), componenttest.NewNopHost(), componenttest.NewNopTelemetrySettings())
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			ptraceotlp.RegisterGRPCServer(s, &grpcTraceServer{})
 
 			go func() {
@@ -749,15 +749,15 @@ func TestHttpReception(t *testing.T) {
 				TLSSetting: *test.tlsClientCreds,
 			}
 			grpcClientConn, errClient := gcs.ToClientConn(context.Background(), componenttest.NewNopHost(), tt.TelemetrySettings())
-			assert.NoError(t, errClient)
+			require.NoError(t, errClient)
 			defer func() { assert.NoError(t, grpcClientConn.Close()) }()
 			c := ptraceotlp.NewGRPCClient(grpcClientConn)
 			ctx, cancelFunc := context.WithTimeout(context.Background(), 2*time.Second)
 			resp, errResp := c.Export(ctx, ptraceotlp.NewExportRequest(), grpc.WaitForReady(true))
 			if test.hasError {
-				assert.Error(t, errResp)
+				require.Error(t, errResp)
 			} else {
-				assert.NoError(t, errResp)
+				require.NoError(t, errResp)
 				assert.NotNil(t, resp)
 			}
 			cancelFunc()
@@ -782,9 +782,9 @@ func TestReceiveOnUnixDomainSocket(t *testing.T) {
 		},
 	}
 	ln, err := gss.NetAddr.Listen(context.Background())
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	srv, err := gss.ToServer(context.Background(), componenttest.NewNopHost(), componenttest.NewNopTelemetrySettings())
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	ptraceotlp.RegisterGRPCServer(srv, &grpcTraceServer{})
 
 	go func() {
@@ -798,12 +798,12 @@ func TestReceiveOnUnixDomainSocket(t *testing.T) {
 		},
 	}
 	grpcClientConn, errClient := gcs.ToClientConn(context.Background(), componenttest.NewNopHost(), tt.TelemetrySettings())
-	assert.NoError(t, errClient)
+	require.NoError(t, errClient)
 	defer func() { assert.NoError(t, grpcClientConn.Close()) }()
 	c := ptraceotlp.NewGRPCClient(grpcClientConn)
 	ctx, cancelFunc := context.WithTimeout(context.Background(), 2*time.Second)
 	resp, errResp := c.Export(ctx, ptraceotlp.NewExportRequest(), grpc.WaitForReady(true))
-	assert.NoError(t, errResp)
+	require.NoError(t, errResp)
 	assert.NotNil(t, resp)
 	cancelFunc()
 	srv.Stop()
@@ -933,7 +933,7 @@ func TestStreamInterceptorEnhancesClient(t *testing.T) {
 	err := enhanceStreamWithClientInformation(false)(nil, stream, nil, handler)
 
 	// verify
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	cl := client.FromContext(outContext)
 	assert.Equal(t, "1.1.1.1", cl.Addr.String())
@@ -1052,7 +1052,7 @@ func TestDefaultUnaryInterceptorAuthSucceeded(t *testing.T) {
 
 	// verify
 	assert.Nil(t, res)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.True(t, authCalled)
 	assert.True(t, handlerCalled)
 }
@@ -1076,7 +1076,7 @@ func TestDefaultUnaryInterceptorAuthFailure(t *testing.T) {
 
 	// verify
 	assert.Nil(t, res)
-	assert.ErrorContains(t, err, expectedErr.Error())
+	require.ErrorContains(t, err, expectedErr.Error())
 	assert.Equal(t, codes.Unauthenticated, status.Code(err))
 	assert.True(t, authCalled)
 }
@@ -1127,7 +1127,7 @@ func TestDefaultStreamInterceptorAuthSucceeded(t *testing.T) {
 	err := authStreamServerInterceptor(nil, streamServer, &grpc.StreamServerInfo{}, handler, auth.NewServer(auth.WithServerAuthenticate(authFunc)))
 
 	// verify
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.True(t, authCalled)
 	assert.True(t, handlerCalled)
 }
@@ -1153,7 +1153,7 @@ func TestDefaultStreamInterceptorAuthFailure(t *testing.T) {
 	err := authStreamServerInterceptor(nil, streamServer, &grpc.StreamServerInfo{}, handler, auth.NewServer(auth.WithServerAuthenticate(authFunc)))
 
 	// verify
-	assert.ErrorContains(t, err, expectedErr.Error()) // unfortunately, grpc errors don't wrap the original ones
+	require.ErrorContains(t, err, expectedErr.Error()) // unfortunately, grpc errors don't wrap the original ones
 	assert.Equal(t, codes.Unauthenticated, status.Code(err))
 	assert.True(t, authCalled)
 }

config/confighttp/confighttp_test.go

@@ -165,7 +165,7 @@ func TestAllHTTPClientSettings(t *testing.T) {
 				assert.Error(t, err)
 				return
 			}
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			switch transport := client.Transport.(type) {
 			case *http.Transport:
 				assert.EqualValues(t, 1024, transport.ReadBufferSize)
@@ -213,7 +213,7 @@ func TestPartialHTTPClientSettings(t *testing.T) {
 			tel := componenttest.NewNopTelemetrySettings()
 			tel.TracerProvider = nil
 			client, err := tt.settings.ToClient(context.Background(), host, tel)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			transport := client.Transport.(*http.Transport)
 			assert.EqualValues(t, 1024, transport.ReadBufferSize)
 			assert.EqualValues(t, 512, transport.WriteBufferSize)
@@ -446,7 +446,7 @@ func TestHTTPClientSettingWithAuthConfig(t *testing.T) {
 				assert.Error(t, err)
 				return
 			}
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.NotNil(t, client)
 			transport := client.Transport
 
@@ -734,11 +734,11 @@ func TestHttpReception(t *testing.T) {
 
 			resp, errResp := client.Get(hcs.Endpoint)
 			if tt.hasError {
-				assert.Error(t, errResp)
+				require.Error(t, errResp)
 			} else {
-				assert.NoError(t, errResp)
+				require.NoError(t, errResp)
 				body, errRead := io.ReadAll(resp.Body)
-				assert.NoError(t, errRead)
+				require.NoError(t, errRead)
 				assert.Equal(t, "tt", string(body))
 				assert.Equal(t, expectedProto, resp.Proto)
 			}
@@ -1065,7 +1065,7 @@ func TestHttpClientHeaders(t *testing.T) {
 			}
 			client, _ := setting.ToClient(context.Background(), componenttest.NewNopHost(), componenttest.NewNopTelemetrySettings())
 			req, err := http.NewRequest(http.MethodGet, setting.Endpoint, nil)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			_, err = client.Do(req)
 			assert.NoError(t, err)
 		})
@@ -1101,7 +1101,7 @@ func TestHttpClientHostHeader(t *testing.T) {
 		}
 		client, _ := setting.ToClient(context.Background(), componenttest.NewNopHost(), componenttest.NewNopTelemetrySettings())
 		req, err := http.NewRequest(http.MethodGet, setting.Endpoint, nil)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		_, err = client.Do(req)
 		assert.NoError(t, err)
 	})

config/confignet/confignet_test.go

@@ -41,7 +41,7 @@ func TestAddrConfigTimeout(t *testing.T) {
 		},
 	}
 	_, err := nac.Dial(context.Background())
-	assert.Error(t, err)
+	require.Error(t, err)
 	var netErr net.Error
 	if errors.As(err, &netErr) {
 		assert.True(t, netErr.Timeout())
@@ -58,7 +58,7 @@ func TestTCPAddrConfigTimeout(t *testing.T) {
 		},
 	}
 	_, err := nac.Dial(context.Background())
-	assert.Error(t, err)
+	require.Error(t, err)
 	var netErr net.Error
 	if errors.As(err, &netErr) {
 		assert.True(t, netErr.Timeout())
@@ -73,7 +73,7 @@ func TestAddrConfig(t *testing.T) {
 		Transport: TransportTypeTCP,
 	}
 	ln, err := nas.Listen(context.Background())
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	done := make(chan bool, 1)
 
 	go func() {
@@ -94,7 +94,7 @@ func TestAddrConfig(t *testing.T) {
 	}
 	var conn net.Conn
 	conn, err = nac.Dial(context.Background())
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	_, err = conn.Write([]byte("test"))
 	assert.NoError(t, err)
 	assert.NoError(t, conn.Close())
@@ -106,12 +106,12 @@ func Test_NetAddr_Validate(t *testing.T) {
 	na := &AddrConfig{
 		Transport: TransportTypeTCP,
 	}
-	assert.NoError(t, na.Validate())
+	require.NoError(t, na.Validate())
 
 	na = &AddrConfig{
 		Transport: transportTypeEmpty,
 	}
-	assert.Error(t, na.Validate())
+	require.Error(t, na.Validate())
 
 	na = &AddrConfig{
 		Transport: "random string",
@@ -124,7 +124,7 @@ func TestTCPAddrConfig(t *testing.T) {
 		Endpoint: "localhost:0",
 	}
 	ln, err := nas.Listen(context.Background())
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	done := make(chan bool, 1)
 
 	go func() {
@@ -144,7 +144,7 @@ func TestTCPAddrConfig(t *testing.T) {
 	}
 	var conn net.Conn
 	conn, err = nac.Dial(context.Background())
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	_, err = conn.Write([]byte("test"))
 	assert.NoError(t, err)
 	assert.NoError(t, conn.Close())

config/configretry/backoff_test.go

@@ -8,11 +8,12 @@ import (
 	"time"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestNewDefaultBackOffSettings(t *testing.T) {
 	cfg := NewDefaultBackOffConfig()
-	assert.NoError(t, cfg.Validate())
+	require.NoError(t, cfg.Validate())
 	assert.Equal(t,
 		BackOffConfig{
 			Enabled:             true,
@@ -26,23 +27,23 @@ func TestNewDefaultBackOffSettings(t *testing.T) {
 
 func TestInvalidInitialInterval(t *testing.T) {
 	cfg := NewDefaultBackOffConfig()
-	assert.NoError(t, cfg.Validate())
+	require.NoError(t, cfg.Validate())
 	cfg.InitialInterval = -1
 	assert.Error(t, cfg.Validate())
 }
 
 func TestInvalidRandomizationFactor(t *testing.T) {
 	cfg := NewDefaultBackOffConfig()
-	assert.NoError(t, cfg.Validate())
+	require.NoError(t, cfg.Validate())
 	cfg.RandomizationFactor = -1
-	assert.Error(t, cfg.Validate())
+	require.Error(t, cfg.Validate())
 	cfg.RandomizationFactor = 2
 	assert.Error(t, cfg.Validate())
 }
 
 func TestInvalidMultiplier(t *testing.T) {
 	cfg := NewDefaultBackOffConfig()
-	assert.NoError(t, cfg.Validate())
+	require.NoError(t, cfg.Validate())
 	cfg.Multiplier = -1
 	assert.Error(t, cfg.Validate())
 }
@@ -56,22 +57,22 @@ func TestZeroMultiplierIsValid(t *testing.T) {
 
 func TestInvalidMaxInterval(t *testing.T) {
 	cfg := NewDefaultBackOffConfig()
-	assert.NoError(t, cfg.Validate())
+	require.NoError(t, cfg.Validate())
 	cfg.MaxInterval = -1
 	assert.Error(t, cfg.Validate())
 }
 
 func TestInvalidMaxElapsedTime(t *testing.T) {
 	cfg := NewDefaultBackOffConfig()
-	assert.NoError(t, cfg.Validate())
+	require.NoError(t, cfg.Validate())
 	cfg.MaxElapsedTime = -1
-	assert.Error(t, cfg.Validate())
+	require.Error(t, cfg.Validate())
 	cfg.MaxElapsedTime = 60
 	// MaxElapsedTime is 60, InitialInterval is 5s, so it should be invalid
-	assert.Error(t, cfg.Validate())
+	require.Error(t, cfg.Validate())
 	cfg.InitialInterval = 0
 	// MaxElapsedTime is 60, MaxInterval is 30s, so it should be invalid
-	assert.Error(t, cfg.Validate())
+	require.Error(t, cfg.Validate())
 	cfg.MaxInterval = 0
 	assert.NoError(t, cfg.Validate())
 	cfg.InitialInterval = 50

config/configtelemetry/configtelemetry_test.go

@@ -8,6 +8,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 var _ encoding.TextMarshaler = (*Level)(nil)
@@ -50,7 +51,7 @@ func TestUnmarshalText(t *testing.T) {
 				if test.err {
 					assert.Error(t, err)
 				} else {
-					assert.NoError(t, err)
+					require.NoError(t, err)
 					assert.Equal(t, test.level, lvl)
 				}
 			})
@@ -94,7 +95,7 @@ func TestLevelStringMarshal(t *testing.T) {
 		t.Run(tt.str, func(t *testing.T) {
 			assert.Equal(t, tt.str, tt.level.String())
 			got, err := tt.level.MarshalText()
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.Equal(t, tt.str, string(got))
 		})
 	}

config/configtls/clientcasfilereloader_test.go

@@ -13,6 +13,7 @@ import (
 	"time"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestCannotShutdownIfNotWatching(t *testing.T) {
@@ -25,10 +26,10 @@ func TestCannotStartIfAlreadyWatching(t *testing.T) {
 	reloader, _, _ := createReloader(t)
 
 	err := reloader.startWatching()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	err = reloader.startWatching()
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	err = reloader.shutdown()
 	assert.NoError(t, err)
@@ -38,12 +39,12 @@ func TestClosingWatcherDoesntBreakReloader(t *testing.T) {
 	reloader, loader, _ := createReloader(t)
 
 	err := reloader.startWatching()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	assert.Equal(t, 1, loader.reloadNumber())
 
 	err = reloader.watcher.Close()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	err = reloader.shutdown()
 	assert.NoError(t, err)
@@ -53,14 +54,14 @@ func TestErrorRecordedIfFileDeleted(t *testing.T) {
 	reloader, loader, filePath := createReloader(t)
 
 	err := reloader.startWatching()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	assert.Equal(t, 1, loader.reloadNumber())
 
 	loader.returnErrorOnSubsequentCalls("test error on reload")
 
 	err = os.WriteFile(filePath, []byte("some_data"), 0600)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	assert.Eventually(t, func() bool {
 		return loader.reloadNumber() > 1 && reloader.getLastError() != nil
@@ -82,7 +83,7 @@ func createReloader(t *testing.T) (*clientCAsFileReloader, *testLoader, string)
 
 func createTempFile(t *testing.T) string {
 	tmpCa, err := os.CreateTemp("", "clientCAs.crt")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	tmpCaPath, err := filepath.Abs(tmpCa.Name())
 	assert.NoError(t, err)
 	assert.NoError(t, tmpCa.Close())

config/configtls/configtls_test.go

@@ -286,19 +286,19 @@ func TestLoadTLSClientConfig(t *testing.T) {
 		Insecure: true,
 	}
 	tlsCfg, err := tlsSetting.LoadTLSConfig(context.Background())
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Nil(t, tlsCfg)
 
 	tlsSetting = ClientConfig{}
 	tlsCfg, err = tlsSetting.LoadTLSConfig(context.Background())
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.NotNil(t, tlsCfg)
 
 	tlsSetting = ClientConfig{
 		InsecureSkipVerify: true,
 	}
 	tlsCfg, err = tlsSetting.LoadTLSConfig(context.Background())
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.NotNil(t, tlsCfg)
 	assert.True(t, tlsCfg.InsecureSkipVerify)
 }
@@ -311,7 +311,7 @@ func TestLoadTLSServerConfigError(t *testing.T) {
 		},
 	}
 	_, err := tlsSetting.LoadTLSConfig(context.Background())
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	tlsSetting = ServerConfig{
 		ClientCAFile: "doesnt/exist",
@@ -323,7 +323,7 @@ func TestLoadTLSServerConfigError(t *testing.T) {
 func TestLoadTLSServerConfig(t *testing.T) {
 	tlsSetting := ServerConfig{}
 	tlsCfg, err := tlsSetting.LoadTLSConfig(context.Background())
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.NotNil(t, tlsCfg)
 }
 
@@ -339,11 +339,11 @@ func TestLoadTLSServerConfigReload(t *testing.T) {
 	}
 
 	tlsCfg, err := tlsSetting.LoadTLSConfig(context.Background())
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.NotNil(t, tlsCfg)
 
 	firstClient, err := tlsCfg.GetConfigForClient(nil)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	overwriteClientCA(t, tmpCaPath, "ca-2.crt")
 
@@ -353,7 +353,7 @@ func TestLoadTLSServerConfigReload(t *testing.T) {
 	}, 5*time.Second, 10*time.Millisecond)
 
 	secondClient, err := tlsCfg.GetConfigForClient(nil)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	assert.NotEqual(t, firstClient.ClientCAs, secondClient.ClientCAs)
 }
@@ -370,11 +370,11 @@ func TestLoadTLSServerConfigFailingReload(t *testing.T) {
 	}
 
 	tlsCfg, err := tlsSetting.LoadTLSConfig(context.Background())
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.NotNil(t, tlsCfg)
 
 	firstClient, err := tlsCfg.GetConfigForClient(nil)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	overwriteClientCA(t, tmpCaPath, "testCA-bad.txt")
 
@@ -384,7 +384,7 @@ func TestLoadTLSServerConfigFailingReload(t *testing.T) {
 	}, 5*time.Second, 10*time.Millisecond)
 
 	secondClient, err := tlsCfg.GetConfigForClient(nil)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	assert.Equal(t, firstClient.ClientCAs, secondClient.ClientCAs)
 }
@@ -401,7 +401,7 @@ func TestLoadTLSServerConfigFailingInitialLoad(t *testing.T) {
 	}
 
 	tlsCfg, err := tlsSetting.LoadTLSConfig(context.Background())
-	assert.Error(t, err)
+	require.Error(t, err)
 	assert.Nil(t, tlsCfg)
 }
 
@@ -415,7 +415,7 @@ func TestLoadTLSServerConfigWrongPath(t *testing.T) {
 	}
 
 	tlsCfg, err := tlsSetting.LoadTLSConfig(context.Background())
-	assert.Error(t, err)
+	require.Error(t, err)
 	assert.Nil(t, tlsCfg)
 }
 
@@ -431,28 +431,28 @@ func TestLoadTLSServerConfigFailing(t *testing.T) {
 	}
 
 	tlsCfg, err := tlsSetting.LoadTLSConfig(context.Background())
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.NotNil(t, tlsCfg)
 
 	firstClient, err := tlsCfg.GetConfigForClient(nil)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.NotNil(t, firstClient)
 
 	err = os.Remove(tmpCaPath)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	firstClient, err = tlsCfg.GetConfigForClient(nil)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.NotNil(t, firstClient)
 }
 
 func overwriteClientCA(t *testing.T, targetFilePath string, testdataFileName string) {
 	targetFile, err := os.OpenFile(filepath.Clean(targetFilePath), os.O_RDWR, 0600)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	testdataFilePath := filepath.Join("testdata", testdataFileName)
 	testdataFile, err := os.OpenFile(filepath.Clean(testdataFilePath), os.O_RDONLY, 0200)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	_, err = io.Copy(targetFile, testdataFile)
 	assert.NoError(t, err)
@@ -463,7 +463,7 @@ func overwriteClientCA(t *testing.T, targetFilePath string, testdataFileName str
 
 func createTempClientCaFile(t *testing.T) string {
 	tmpCa, err := os.CreateTemp("", "ca-tmp.crt")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	tmpCaPath, err := filepath.Abs(tmpCa.Name())
 	assert.NoError(t, err)
 	assert.NoError(t, tmpCa.Close())
@@ -476,13 +476,13 @@ func TestEagerlyLoadCertificate(t *testing.T) {
 		KeyFile:  filepath.Join("testdata", "client-1.key"),
 	}
 	cfg, err := options.loadTLSConfig()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.NotNil(t, cfg)
 	cert, err := cfg.GetCertificate(&tls.ClientHelloInfo{})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.NotNil(t, cert)
 	pCert, err := x509.ParseCertificate(cert.Certificate[0])
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.NotNil(t, pCert)
 	assert.ElementsMatch(t, []string{"example1"}, pCert.DNSNames)
 }
@@ -540,20 +540,20 @@ func TestCertificateReload(t *testing.T) {
 		t.Run(test.name, func(t *testing.T) {
 			// Copy certs into a temp dir so we can safely modify them
 			certFile, err := os.CreateTemp("", "cert")
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			defer os.Remove(certFile.Name())
 
 			keyFile, err := os.CreateTemp("", "key")
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			defer os.Remove(keyFile.Name())
 
 			fdc, err := os.Open(filepath.Join("testdata", "client-1.crt"))
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			_, err = io.Copy(certFile, fdc)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 
 			fdk, err := os.Open(filepath.Join("testdata", "client-1.key"))
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			_, err = io.Copy(keyFile, fdk)
 			assert.NoError(t, err)
 			assert.NoError(t, fdk.Close())
@@ -564,15 +564,15 @@ func TestCertificateReload(t *testing.T) {
 				ReloadInterval: test.reloadInterval,
 			}
 			cfg, err := options.loadTLSConfig()
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.NotNil(t, cfg)
 
 			// Asssert that we loaded the original certificate
 			cert, err := cfg.GetCertificate(&tls.ClientHelloInfo{})
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.NotNil(t, cert)
 			pCert, err := x509.ParseCertificate(cert.Certificate[0])
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.NotNil(t, pCert)
 			assert.Equal(t, test.dns1, pCert.DNSNames[0])
 
@@ -580,18 +580,18 @@ func TestCertificateReload(t *testing.T) {
 			assert.NoError(t, certFile.Truncate(0))
 			assert.NoError(t, keyFile.Truncate(0))
 			_, err = certFile.Seek(0, 0)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			_, err = keyFile.Seek(0, 0)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 
 			fdc2, err := os.Open(filepath.Join("testdata", test.cert2))
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			_, err = io.Copy(certFile, fdc2)
 			assert.NoError(t, err)
 			assert.NoError(t, fdc2.Close())
 
 			fdk2, err := os.Open(filepath.Join("testdata", test.key2))
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			_, err = io.Copy(keyFile, fdk2)
 			assert.NoError(t, err)
 			assert.NoError(t, fdk2.Close())
@@ -602,10 +602,10 @@ func TestCertificateReload(t *testing.T) {
 			// Assert that we loaded the new certificate
 			cert, err = cfg.GetCertificate(&tls.ClientHelloInfo{})
 			if test.errText == "" {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 				assert.NotNil(t, cert)
 				pCert, err = x509.ParseCertificate(cert.Certificate[0])
-				assert.NoError(t, err)
+				require.NoError(t, err)
 				assert.NotNil(t, pCert)
 				assert.Equal(t, test.dns2, pCert.DNSNames[0])
 			} else {
@@ -729,7 +729,7 @@ invalid TLS cipher suite: "BAR"`,
 			if test.wantErr != "" {
 				assert.EqualError(t, err, test.wantErr)
 			} else {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 				assert.Equal(t, test.result, config.CipherSuites)
 			}
 		})
@@ -798,7 +798,7 @@ func TestSystemCertPool(t *testing.T) {
 			}
 			c, err := serverConfig.LoadTLSConfig(context.Background())
 			if test.wantErr != nil {
-				assert.ErrorContains(t, err, test.wantErr.Error())
+				require.ErrorContains(t, err, test.wantErr.Error())
 			} else {
 				assert.NotNil(t, c.RootCAs)
 			}

confmap/confmap_test.go

@@ -109,7 +109,7 @@ func TestExpandNilStructPointersHookFunc(t *testing.T) {
 	conf := NewFromStringMap(stringMap)
 	cfg := &TestConfig{}
 	assert.Nil(t, cfg.Struct)
-	assert.NoError(t, conf.Unmarshal(cfg))
+	require.NoError(t, conf.Unmarshal(cfg))
 	assert.Nil(t, cfg.Boolean)
 	// assert.False(t, *cfg.Boolean)
 	assert.Nil(t, cfg.Struct)
@@ -134,7 +134,7 @@ func TestExpandNilStructPointersHookFuncDefaultNotNilConfigNil(t *testing.T) {
 		Struct:    s1,
 		MapStruct: map[string]*Struct{"struct": s2},
 	}
-	assert.NoError(t, conf.Unmarshal(cfg))
+	require.NoError(t, conf.Unmarshal(cfg))
 	assert.NotNil(t, cfg.Boolean)
 	assert.True(t, *cfg.Boolean)
 	assert.NotNil(t, cfg.Struct)
@@ -149,7 +149,7 @@ func TestUnmarshalWithIgnoreUnused(t *testing.T) {
 		"string":  "this is a string",
 	}
 	conf := NewFromStringMap(stringMap)
-	assert.Error(t, conf.Unmarshal(&TestIDConfig{}))
+	require.Error(t, conf.Unmarshal(&TestIDConfig{}))
 	assert.NoError(t, conf.Unmarshal(&TestIDConfig{}, WithIgnoreUnused()))
 }
 
@@ -208,7 +208,7 @@ func TestMapKeyStringToMapKeyTextUnmarshalerHookFunc(t *testing.T) {
 	conf := NewFromStringMap(stringMap)
 
 	cfg := &TestIDConfig{}
-	assert.NoError(t, conf.Unmarshal(cfg))
+	require.NoError(t, conf.Unmarshal(cfg))
 	assert.True(t, cfg.Boolean)
 	assert.Equal(t, map[TestID]string{"string": "this is a string"}, cfg.Map)
 }
@@ -243,7 +243,7 @@ func TestUintUnmarshalerSuccess(t *testing.T) {
 			cfg := &UintConfig{}
 			err := conf.Unmarshal(cfg)
 
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.Equal(t, cfg.UintTest, uint32(tt.testValue))
 		})
 	}
@@ -264,7 +264,7 @@ func TestUint64Unmarshaler(t *testing.T) {
 	cfg := &Uint64Config{}
 	err := conf.Unmarshal(cfg)
 
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, cfg.UintTest, testValue)
 }
 
@@ -277,7 +277,7 @@ func TestUintUnmarshalerFailure(t *testing.T) {
 	cfg := &UintConfig{}
 	err := conf.Unmarshal(cfg)
 
-	assert.Error(t, err)
+	require.Error(t, err)
 	assert.Contains(t, err.Error(), fmt.Sprintf("decoding failed due to the following error(s):\n\ncannot parse 'uint_test', %d overflows uint", testValue))
 }
 
@@ -316,7 +316,7 @@ func TestMarshal(t *testing.T) {
 			"string": "this is a string",
 		},
 	}
-	assert.NoError(t, conf.Marshal(cfg))
+	require.NoError(t, conf.Marshal(cfg))
 	assert.Equal(t, true, conf.Get("bool"))
 	assert.Equal(t, map[string]any{"string_": "this is a string"}, conf.Get("map"))
 }
@@ -345,7 +345,7 @@ func TestMarshaler(t *testing.T) {
 			Name: "StructName",
 		},
 	}
-	assert.NoError(t, conf.Marshal(cfg))
+	require.NoError(t, conf.Marshal(cfg))
 	assert.Equal(t, "field", conf.Get("additional"))
 
 	conf = New()
@@ -355,9 +355,9 @@ func TestMarshaler(t *testing.T) {
 	nmCfg := &NestedMarshaler{
 		TestConfig: cfg,
 	}
-	assert.NoError(t, conf.Marshal(nmCfg))
+	require.NoError(t, conf.Marshal(nmCfg))
 	sub, err := conf.Sub("testconfig")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.True(t, sub.IsSet("additional"))
 	assert.Equal(t, "field", sub.Get("additional"))
 	varBool := false
@@ -483,7 +483,7 @@ func TestUnmarshaler(t *testing.T) {
 	})
 
 	tc := &testConfig{}
-	assert.NoError(t, cfgMap.Unmarshal(tc))
+	require.NoError(t, cfgMap.Unmarshal(tc))
 	assert.Equal(t, "make sure this is only called directly", tc.Another)
 	assert.Equal(t, "make sure this is called", tc.Next.String)
 	assert.Equal(t, "make sure this is also called", tc.EmbeddedConfig.Some)
@@ -501,7 +501,7 @@ func TestEmbeddedUnmarshaler(t *testing.T) {
 	})
 
 	tc := &testConfigWithoutUnmarshaler{}
-	assert.NoError(t, cfgMap.Unmarshal(tc))
+	require.NoError(t, cfgMap.Unmarshal(tc))
 	assert.Equal(t, "make sure this", tc.Another)
 	assert.Equal(t, "make sure this is called", tc.Next.String)
 	assert.Equal(t, "make sure this is also called", tc.EmbeddedConfig.Some)
@@ -545,7 +545,7 @@ func TestUnmarshalerKeepAlreadyInitialized(t *testing.T) {
 	tc := &testConfig{Next: &nextConfig{
 		private: "keep already configured members",
 	}}
-	assert.NoError(t, cfgMap.Unmarshal(tc))
+	require.NoError(t, cfgMap.Unmarshal(tc))
 	assert.Equal(t, "make sure this is only called directly", tc.Another)
 	assert.Equal(t, "make sure this is called", tc.Next.String)
 	assert.Equal(t, "keep already configured members", tc.Next.private)
@@ -562,7 +562,7 @@ func TestDirectUnmarshaler(t *testing.T) {
 	tc := &testConfig{Next: &nextConfig{
 		private: "keep already configured members",
 	}}
-	assert.NoError(t, tc.Unmarshal(cfgMap))
+	require.NoError(t, tc.Unmarshal(cfgMap))
 	assert.Equal(t, "make sure this is only called directly is only called directly", tc.Another)
 	assert.Equal(t, "make sure this is called", tc.Next.String)
 	assert.Equal(t, "keep already configured members", tc.Next.private)
@@ -588,7 +588,7 @@ func TestUnmarshalerErr(t *testing.T) {
 	})
 
 	tc := &testErrConfig{}
-	assert.EqualError(t, cfgMap.Unmarshal(tc), "decoding failed due to the following error(s):\n\nerror decoding 'err': never works")
+	require.EqualError(t, cfgMap.Unmarshal(tc), "decoding failed due to the following error(s):\n\nerror decoding 'err': never works")
 	assert.Empty(t, tc.Err.Foo)
 }
 
@@ -736,7 +736,7 @@ func TestNestedUnmarshalerImplementations(t *testing.T) {
 
 	// Use a wrapper struct until we deprecate component.UnmarshalConfig
 	w := &Wrapper{}
-	assert.NoError(t, conf.Unmarshal(w))
+	require.NoError(t, conf.Unmarshal(w))
 
 	a := w.A
 	assert.Equal(t, []string{"conf.Unmarshal", "A.Unmarshal"}, a.Modifiers)
@@ -754,14 +754,14 @@ func TestUnmarshalDouble(t *testing.T) {
 		Str string `mapstructure:"str"`
 	}
 	s := &Struct{}
-	assert.NoError(t, conf.Unmarshal(s))
+	require.NoError(t, conf.Unmarshal(s))
 	assert.Equal(t, "test", s.Str)
 
 	type Struct2 struct {
 		Str string `mapstructure:"str"`
 	}
 	s2 := &Struct2{}
-	assert.NoError(t, conf.Unmarshal(s2))
+	require.NoError(t, conf.Unmarshal(s2))
 	assert.Equal(t, "test", s2.Str)
 }
 
@@ -859,14 +859,14 @@ func TestExpandedValue(t *testing.T) {
 	}
 
 	cfgStr := ConfigStr{}
-	assert.NoError(t, cm.Unmarshal(&cfgStr))
+	require.NoError(t, cm.Unmarshal(&cfgStr))
 	assert.Equal(t, "original", cfgStr.Key)
 
 	type ConfigInt struct {
 		Key int `mapstructure:"key"`
 	}
 	cfgInt := ConfigInt{}
-	assert.NoError(t, cm.Unmarshal(&cfgInt))
+	require.NoError(t, cm.Unmarshal(&cfgInt))
 	assert.Equal(t, 0xdeadbeef, cfgInt.Key)
 
 	type ConfigBool struct {
@@ -891,7 +891,7 @@ func TestSubExpandedValue(t *testing.T) {
 	assert.Equal(t, map[string]any{"subsubkey": "value"}, cm.Get("key::subkey"))
 
 	sub, err := cm.Sub("key::subkey")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, map[string]any{"subsubkey": "value"}, sub.ToStringMap())
 
 	// This should return value, but currently `Get` does not support keys within expanded values.

confmap/confmaptest/configtest_test.go

@@ -42,9 +42,9 @@ func TestValidateProviderScheme(t *testing.T) {
 	assert.NoError(t, ValidateProviderScheme(&schemeProvider{scheme: "s3"}))
 	assert.NoError(t, ValidateProviderScheme(&schemeProvider{scheme: "a.l-l+"}))
 	// Too short.
-	assert.Error(t, ValidateProviderScheme(&schemeProvider{scheme: "a"}))
+	require.Error(t, ValidateProviderScheme(&schemeProvider{scheme: "a"}))
 	// Invalid first character.
-	assert.Error(t, ValidateProviderScheme(&schemeProvider{scheme: "3s"}))
+	require.Error(t, ValidateProviderScheme(&schemeProvider{scheme: "3s"}))
 	// Invalid underscore character.
 	assert.Error(t, ValidateProviderScheme(&schemeProvider{scheme: "all_"}))
 }

confmap/provider/envprovider/provider_test.go

@@ -42,7 +42,7 @@ func TestEmptyName(t *testing.T) {
 func TestUnsupportedScheme(t *testing.T) {
 	env := createProvider()
 	_, err := env.Retrieve(context.Background(), "https://", nil)
-	assert.Error(t, err)
+	require.Error(t, err)
 	assert.NoError(t, env.Shutdown(context.Background()))
 }
 
@@ -66,7 +66,7 @@ func TestEnv(t *testing.T) {
 	ret, err := env.Retrieve(context.Background(), envSchemePrefix+envName, nil)
 	require.NoError(t, err)
 	retMap, err := ret.AsConf()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	expectedMap := confmap.NewFromStringMap(map[string]any{
 		"processors::batch":         nil,
 		"exporters::otlp::endpoint": "localhost:4317",
@@ -86,14 +86,14 @@ func TestEnvWithLogger(t *testing.T) {
 	ret, err := env.Retrieve(context.Background(), envSchemePrefix+envName, nil)
 	require.NoError(t, err)
 	retMap, err := ret.AsConf()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	expectedMap := confmap.NewFromStringMap(map[string]any{
 		"processors::batch":         nil,
 		"exporters::otlp::endpoint": "localhost:4317",
 	})
 	assert.Equal(t, expectedMap.ToStringMap(), retMap.ToStringMap())
 
-	assert.NoError(t, env.Shutdown(context.Background()))
+	require.NoError(t, env.Shutdown(context.Background()))
 	assert.Equal(t, 0, ol.Len())
 }
 
@@ -106,11 +106,11 @@ func TestUnsetEnvWithLoggerWarn(t *testing.T) {
 	ret, err := env.Retrieve(context.Background(), envSchemePrefix+envName, nil)
 	require.NoError(t, err)
 	retMap, err := ret.AsConf()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	expectedMap := confmap.NewFromStringMap(map[string]any{})
 	assert.Equal(t, expectedMap.ToStringMap(), retMap.ToStringMap())
 
-	assert.NoError(t, env.Shutdown(context.Background()))
+	require.NoError(t, env.Shutdown(context.Background()))
 
 	assert.Equal(t, 1, ol.Len())
 	logLine := ol.All()[0]
@@ -126,7 +126,7 @@ func TestEnvVarNameRestriction(t *testing.T) {
 	env := createProvider()
 	ret, err := env.Retrieve(context.Background(), envSchemePrefix+envName, nil)
 	assert.Equal(t, err, fmt.Errorf("environment variable \"default%%config\" has invalid name: must match regex %s", envvar.ValidationRegexp))
-	assert.NoError(t, env.Shutdown(context.Background()))
+	require.NoError(t, env.Shutdown(context.Background()))
 	assert.Nil(t, ret)
 }
 
@@ -141,11 +141,11 @@ func TestEmptyEnvWithLoggerWarn(t *testing.T) {
 	ret, err := env.Retrieve(context.Background(), envSchemePrefix+envName, nil)
 	require.NoError(t, err)
 	retMap, err := ret.AsConf()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	expectedMap := confmap.NewFromStringMap(map[string]any{})
 	assert.Equal(t, expectedMap.ToStringMap(), retMap.ToStringMap())
 
-	assert.NoError(t, env.Shutdown(context.Background()))
+	require.NoError(t, env.Shutdown(context.Background()))
 
 	assert.Equal(t, 1, ol.Len())
 	logLine := ol.All()[0]

confmap/provider/fileprovider/provider_test.go

@@ -32,16 +32,16 @@ func TestEmptyName(t *testing.T) {
 func TestUnsupportedScheme(t *testing.T) {
 	fp := createProvider()
 	_, err := fp.Retrieve(context.Background(), "https://", nil)
-	assert.Error(t, err)
+	require.Error(t, err)
 	assert.NoError(t, fp.Shutdown(context.Background()))
 }
 
 func TestNonExistent(t *testing.T) {
 	fp := createProvider()
 	_, err := fp.Retrieve(context.Background(), fileSchemePrefix+filepath.Join("testdata", "non-existent.yaml"), nil)
-	assert.Error(t, err)
+	require.Error(t, err)
 	_, err = fp.Retrieve(context.Background(), fileSchemePrefix+absolutePath(t, filepath.Join("testdata", "non-existent.yaml")), nil)
-	assert.Error(t, err)
+	require.Error(t, err)
 	require.NoError(t, fp.Shutdown(context.Background()))
 }
 
@@ -67,7 +67,7 @@ func TestRelativePath(t *testing.T) {
 	ret, err := fp.Retrieve(context.Background(), fileSchemePrefix+filepath.Join("testdata", "default-config.yaml"), nil)
 	require.NoError(t, err)
 	retMap, err := ret.AsConf()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	expectedMap := confmap.NewFromStringMap(map[string]any{
 		"processors::batch":         nil,
 		"exporters::otlp::endpoint": "localhost:4317",
@@ -81,7 +81,7 @@ func TestAbsolutePath(t *testing.T) {
 	ret, err := fp.Retrieve(context.Background(), fileSchemePrefix+absolutePath(t, filepath.Join("testdata", "default-config.yaml")), nil)
 	require.NoError(t, err)
 	retMap, err := ret.AsConf()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	expectedMap := confmap.NewFromStringMap(map[string]any{
 		"processors::batch":         nil,
 		"exporters::otlp::endpoint": "localhost:4317",

confmap/provider/internal/configurablehttpprovider/provider_test.go

@@ -133,15 +133,15 @@ func TestFunctionalityDownloadFileHTTP(t *testing.T) {
 
 func TestFunctionalityDownloadFileHTTPS(t *testing.T) {
 	certPath, keyPath, err := generateCertificate("localhost")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	invalidCert, err := os.CreateTemp("", "cert*.crt")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	_, err = invalidCert.Write([]byte{0, 1, 2})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	cert, err := tls.LoadX509KeyPair(certPath, keyPath)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	ts := httptest.NewUnstartedServer(http.HandlerFunc(answerGet))
 	ts.TLS = &tls.Config{Certificates: []tls.Certificate{cert}}
 	ts.StartTLS()
@@ -232,12 +232,12 @@ func TestFunctionalityDownloadFileHTTPS(t *testing.T) {
 func TestUnsupportedScheme(t *testing.T) {
 	fp := New(HTTPScheme, confmaptest.NewNopProviderSettings())
 	_, err := fp.Retrieve(context.Background(), "https://...", nil)
-	assert.Error(t, err)
+	require.Error(t, err)
-	assert.NoError(t, fp.Shutdown(context.Background()))
+	require.NoError(t, fp.Shutdown(context.Background()))
 
 	fp = New(HTTPSScheme, confmaptest.NewNopProviderSettings())
 	_, err = fp.Retrieve(context.Background(), "http://...", nil)
-	assert.Error(t, err)
+	require.Error(t, err)
 	assert.NoError(t, fp.Shutdown(context.Background()))
 }
 
@@ -257,7 +257,7 @@ func TestRetrieveFromShutdownServer(t *testing.T) {
 	ts := httptest.NewServer(http.HandlerFunc(func(http.ResponseWriter, *http.Request) {}))
 	ts.Close()
 	_, err := fp.Retrieve(context.Background(), ts.URL, nil)
-	assert.Error(t, err)
+	require.Error(t, err)
 	require.NoError(t, fp.Shutdown(context.Background()))
 }
 
@@ -268,7 +268,7 @@ func TestNonExistent(t *testing.T) {
 	}))
 	defer ts.Close()
 	_, err := fp.Retrieve(context.Background(), ts.URL, nil)
-	assert.Error(t, err)
+	require.Error(t, err)
 	require.NoError(t, fp.Shutdown(context.Background()))
 }
 

confmap/provider/yamlprovider/provider_test.go

@@ -21,7 +21,7 @@ func TestValidateProviderScheme(t *testing.T) {
 func TestEmpty(t *testing.T) {
 	sp := createProvider()
 	_, err := sp.Retrieve(context.Background(), "", nil)
-	assert.Error(t, err)
+	require.Error(t, err)
 	assert.NoError(t, sp.Shutdown(context.Background()))
 }
 
@@ -39,9 +39,9 @@ func TestInvalidYAML(t *testing.T) {
 func TestOneValue(t *testing.T) {
 	sp := createProvider()
 	ret, err := sp.Retrieve(context.Background(), "yaml:processors::batch::timeout: 2s", nil)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	retMap, err := ret.AsConf()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, map[string]any{
 		"processors": map[string]any{
 			"batch": map[string]any{
@@ -55,9 +55,9 @@ func TestOneValue(t *testing.T) {
 func TestNamedComponent(t *testing.T) {
 	sp := createProvider()
 	ret, err := sp.Retrieve(context.Background(), "yaml:processors::batch/foo::timeout: 3s", nil)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	retMap, err := ret.AsConf()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, map[string]any{
 		"processors": map[string]any{
 			"batch/foo": map[string]any{
@@ -71,9 +71,9 @@ func TestNamedComponent(t *testing.T) {
 func TestMapEntry(t *testing.T) {
 	sp := createProvider()
 	ret, err := sp.Retrieve(context.Background(), "yaml:processors: {batch/foo::timeout: 3s, batch::timeout: 2s}", nil)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	retMap, err := ret.AsConf()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, map[string]any{
 		"processors": map[string]any{
 			"batch/foo": map[string]any{
@@ -90,9 +90,9 @@ func TestMapEntry(t *testing.T) {
 func TestArrayEntry(t *testing.T) {
 	sp := createProvider()
 	ret, err := sp.Retrieve(context.Background(), "yaml:service::extensions: [zpages, zpages/foo]", nil)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	retMap, err := ret.AsConf()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, map[string]any{
 		"service": map[string]any{
 			"extensions": []any{
@@ -107,9 +107,9 @@ func TestArrayEntry(t *testing.T) {
 func TestNewLine(t *testing.T) {
 	sp := createProvider()
 	ret, err := sp.Retrieve(context.Background(), "yaml:processors::batch/foo::timeout: 3s\nprocessors::batch::timeout: 2s", nil)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	retMap, err := ret.AsConf()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, map[string]any{
 		"processors": map[string]any{
 			"batch/foo": map[string]any{
@@ -126,9 +126,9 @@ func TestNewLine(t *testing.T) {
 func TestDotSeparator(t *testing.T) {
 	sp := createProvider()
 	ret, err := sp.Retrieve(context.Background(), "yaml:processors.batch.timeout: 4s", nil)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	retMap, err := ret.AsConf()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, map[string]any{"processors.batch.timeout": "4s"}, retMap.ToStringMap())
 	assert.NoError(t, sp.Shutdown(context.Background()))
 }

confmap/provider_test.go

@@ -60,7 +60,7 @@ func TestNewRetrievedFromYAMLInvalidYAMLBytes(t *testing.T) {
 	require.NoError(t, err)
 
 	_, err = ret.AsConf()
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	str, err := ret.AsString()
 	require.NoError(t, err)
@@ -76,7 +76,7 @@ func TestNewRetrievedFromYAMLInvalidAsMap(t *testing.T) {
 	require.NoError(t, err)
 
 	_, err = ret.AsConf()
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	str, err := ret.AsString()
 	require.NoError(t, err)

confmap/resolver_test.go

@@ -327,27 +327,27 @@ func TestResolver(t *testing.T) {
 		ConverterFactories: nil})
 	require.NoError(t, err)
 	_, errN := resolver.Resolve(context.Background())
-	assert.NoError(t, errN)
+	require.NoError(t, errN)
 	assert.Equal(t, int32(0), numCalls.Load())
 
 	errW := <-resolver.Watch()
-	assert.NoError(t, errW)
+	require.NoError(t, errW)
 
 	// Repeat Resolve/Watch.
 
 	_, errN = resolver.Resolve(context.Background())
-	assert.NoError(t, errN)
+	require.NoError(t, errN)
 	assert.Equal(t, int32(1), numCalls.Load())
 
 	errW = <-resolver.Watch()
-	assert.NoError(t, errW)
+	require.NoError(t, errW)
 
 	_, errN = resolver.Resolve(context.Background())
-	assert.NoError(t, errN)
+	require.NoError(t, errN)
 	assert.Equal(t, int32(2), numCalls.Load())
 
 	errC := resolver.Shutdown(context.Background())
-	assert.NoError(t, errC)
+	require.NoError(t, errC)
 	assert.Equal(t, int32(3), numCalls.Load())
 }
 
@@ -382,7 +382,7 @@ func TestResolverShutdownClosesWatch(t *testing.T) {
 		ConverterFactories: nil})
 	require.NoError(t, err)
 	_, errN := resolver.Resolve(context.Background())
-	assert.NoError(t, errN)
+	require.NoError(t, errN)
 
 	var watcherWG sync.WaitGroup
 	watcherWG.Add(1)
@@ -394,7 +394,7 @@ func TestResolverShutdownClosesWatch(t *testing.T) {
 		watcherWG.Done()
 	}()
 
-	assert.NoError(t, resolver.Shutdown(context.Background()))
+	require.NoError(t, resolver.Shutdown(context.Background()))
 	watcherWG.Wait()
 }
 

connector/connector_test.go

@@ -8,6 +8,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 
 	"go.opentelemetry.io/collector/component"
 	"go.opentelemetry.io/collector/connector/internal"
@@ -59,15 +60,15 @@ func TestNewFactoryWithSameTypes(t *testing.T) {
 
 	assert.Equal(t, component.StabilityLevelAlpha, factory.TracesToTracesStability())
 	_, err := factory.CreateTracesToTraces(context.Background(), Settings{ID: testID}, &defaultCfg, consumertest.NewNop())
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	assert.Equal(t, component.StabilityLevelBeta, factory.MetricsToMetricsStability())
 	_, err = factory.CreateMetricsToMetrics(context.Background(), Settings{ID: testID}, &defaultCfg, consumertest.NewNop())
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	assert.Equal(t, component.StabilityLevelUnmaintained, factory.LogsToLogsStability())
 	_, err = factory.CreateLogsToLogs(context.Background(), Settings{ID: testID}, &defaultCfg, consumertest.NewNop())
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	_, err = factory.CreateTracesToMetrics(context.Background(), Settings{ID: testID}, &defaultCfg, consumertest.NewNop())
 	assert.Equal(t, err, internal.ErrDataTypes(testID, component.DataTypeTraces, component.DataTypeMetrics))
@@ -106,23 +107,23 @@ func TestNewFactoryWithTranslateTypes(t *testing.T) {
 
 	assert.Equal(t, component.StabilityLevelDevelopment, factory.TracesToMetricsStability())
 	_, err = factory.CreateTracesToMetrics(context.Background(), Settings{ID: testID}, &defaultCfg, consumertest.NewNop())
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	assert.Equal(t, component.StabilityLevelAlpha, factory.TracesToLogsStability())
 	_, err = factory.CreateTracesToLogs(context.Background(), Settings{ID: testID}, &defaultCfg, consumertest.NewNop())
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	assert.Equal(t, component.StabilityLevelBeta, factory.MetricsToTracesStability())
 	_, err = factory.CreateMetricsToTraces(context.Background(), Settings{ID: testID}, &defaultCfg, consumertest.NewNop())
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	assert.Equal(t, component.StabilityLevelStable, factory.MetricsToLogsStability())
 	_, err = factory.CreateMetricsToLogs(context.Background(), Settings{ID: testID}, &defaultCfg, consumertest.NewNop())
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	assert.Equal(t, component.StabilityLevelDeprecated, factory.LogsToTracesStability())
 	_, err = factory.CreateLogsToTraces(context.Background(), Settings{ID: testID}, &defaultCfg, consumertest.NewNop())
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	assert.Equal(t, component.StabilityLevelUnmaintained, factory.LogsToMetricsStability())
 	_, err = factory.CreateLogsToMetrics(context.Background(), Settings{ID: testID}, &defaultCfg, consumertest.NewNop())
@@ -146,30 +147,30 @@ func TestNewFactoryWithAllTypes(t *testing.T) {
 
 	assert.Equal(t, component.StabilityLevelAlpha, factory.TracesToTracesStability())
 	_, err := factory.CreateTracesToTraces(context.Background(), Settings{}, &defaultCfg, consumertest.NewNop())
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, component.StabilityLevelDevelopment, factory.TracesToMetricsStability())
 	_, err = factory.CreateTracesToMetrics(context.Background(), Settings{}, &defaultCfg, consumertest.NewNop())
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, component.StabilityLevelAlpha, factory.TracesToLogsStability())
 	_, err = factory.CreateTracesToLogs(context.Background(), Settings{}, &defaultCfg, consumertest.NewNop())
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	assert.Equal(t, component.StabilityLevelBeta, factory.MetricsToTracesStability())
 	_, err = factory.CreateMetricsToTraces(context.Background(), Settings{}, &defaultCfg, consumertest.NewNop())
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, component.StabilityLevelBeta, factory.MetricsToMetricsStability())
 	_, err = factory.CreateMetricsToMetrics(context.Background(), Settings{}, &defaultCfg, consumertest.NewNop())
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, component.StabilityLevelStable, factory.MetricsToLogsStability())
 	_, err = factory.CreateMetricsToLogs(context.Background(), Settings{}, &defaultCfg, consumertest.NewNop())
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	assert.Equal(t, component.StabilityLevelDeprecated, factory.LogsToTracesStability())
 	_, err = factory.CreateLogsToTraces(context.Background(), Settings{}, &defaultCfg, consumertest.NewNop())
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, component.StabilityLevelUnmaintained, factory.LogsToMetricsStability())
 	_, err = factory.CreateLogsToMetrics(context.Background(), Settings{}, &defaultCfg, consumertest.NewNop())
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, component.StabilityLevelUnmaintained, factory.LogsToLogsStability())
 	_, err = factory.CreateLogsToLogs(context.Background(), Settings{}, &defaultCfg, consumertest.NewNop())
 	assert.NoError(t, err)
@@ -206,7 +207,7 @@ func TestMakeFactoryMap(t *testing.T) {
 				assert.Error(t, err)
 				return
 			}
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.Equal(t, tt.out, out)
 		})
 	}

connector/connectorprofiles/connector_test.go

@@ -8,6 +8,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 
 	"go.opentelemetry.io/collector/component"
 	"go.opentelemetry.io/collector/component/componentprofiles"
@@ -54,7 +55,7 @@ func TestNewFactoryWithSameTypes(t *testing.T) {
 
 	assert.Equal(t, component.StabilityLevelAlpha, factory.ProfilesToProfilesStability())
 	_, err := factory.CreateProfilesToProfiles(context.Background(), connector.Settings{ID: testID}, &defaultCfg, consumertest.NewNop())
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	_, err = factory.CreateProfilesToTraces(context.Background(), connector.Settings{ID: testID}, &defaultCfg, consumertest.NewNop())
 	assert.Equal(t, err, internal.ErrDataTypes(testID, componentprofiles.DataTypeProfiles, component.DataTypeTraces))
@@ -83,23 +84,23 @@ func TestNewFactoryWithTranslateTypes(t *testing.T) {
 
 	assert.Equal(t, component.StabilityLevelBeta, factory.TracesToProfilesStability())
 	_, err = factory.CreateTracesToProfiles(context.Background(), connector.Settings{ID: testID}, &defaultCfg, consumertest.NewNop())
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	assert.Equal(t, component.StabilityLevelDevelopment, factory.MetricsToProfilesStability())
 	_, err = factory.CreateMetricsToProfiles(context.Background(), connector.Settings{ID: testID}, &defaultCfg, consumertest.NewNop())
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	assert.Equal(t, component.StabilityLevelAlpha, factory.LogsToProfilesStability())
 	_, err = factory.CreateLogsToProfiles(context.Background(), connector.Settings{ID: testID}, &defaultCfg, consumertest.NewNop())
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	assert.Equal(t, component.StabilityLevelBeta, factory.ProfilesToTracesStability())
 	_, err = factory.CreateProfilesToTraces(context.Background(), connector.Settings{ID: testID}, &defaultCfg, consumertest.NewNop())
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	assert.Equal(t, component.StabilityLevelDevelopment, factory.ProfilesToMetricsStability())
 	_, err = factory.CreateProfilesToMetrics(context.Background(), connector.Settings{ID: testID}, &defaultCfg, consumertest.NewNop())
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	assert.Equal(t, component.StabilityLevelAlpha, factory.ProfilesToLogsStability())
 	_, err = factory.CreateProfilesToLogs(context.Background(), connector.Settings{ID: testID}, &defaultCfg, consumertest.NewNop())

connector/connectorprofiles/profiles_router_test.go

@@ -10,6 +10,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 
 	"go.opentelemetry.io/collector/component"
 	"go.opentelemetry.io/collector/consumer"
@@ -149,7 +150,7 @@ func TestProfilessRouterConsumer(t *testing.T) {
 
 	none, err := r.Consumer()
 	assert.Nil(t, none)
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	fake, err := r.Consumer(component.MustNewID("fake"))
 	assert.Nil(t, fake)

connector/forwardconnector/forward_test.go

@@ -7,6 +7,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 
 	"go.opentelemetry.io/collector/component/componenttest"
 	"go.opentelemetry.io/collector/connector/connectortest"
@@ -27,17 +28,17 @@ func TestForward(t *testing.T) {
 
 	tracesSink := new(consumertest.TracesSink)
 	tracesToTraces, err := f.CreateTracesToTraces(ctx, set, cfg, tracesSink)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.NotNil(t, tracesToTraces)
 
 	metricsSink := new(consumertest.MetricsSink)
 	metricsToMetrics, err := f.CreateMetricsToMetrics(ctx, set, cfg, metricsSink)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.NotNil(t, metricsToMetrics)
 
 	logsSink := new(consumertest.LogsSink)
 	logsToLogs, err := f.CreateLogsToLogs(ctx, set, cfg, logsSink)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.NotNil(t, logsToLogs)
 
 	assert.NoError(t, tracesToTraces.Start(ctx, host))

connector/logs_router_test.go

@@ -10,6 +10,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 
 	"go.opentelemetry.io/collector/component"
 	"go.opentelemetry.io/collector/consumer"
@@ -148,7 +149,7 @@ func TestLogsRouterConsumers(t *testing.T) {
 
 	none, err := r.Consumer()
 	assert.Nil(t, none)
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	fake, err := r.Consumer(component.MustNewID("fake"))
 	assert.Nil(t, fake)

connector/metrics_router_test.go

@@ -10,6 +10,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 
 	"go.opentelemetry.io/collector/component"
 	"go.opentelemetry.io/collector/consumer"
@@ -148,7 +149,7 @@ func TestMetricsRouterConsumers(t *testing.T) {
 
 	none, err := r.Consumer()
 	assert.Nil(t, none)
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	fake, err := r.Consumer(component.MustNewID("fake"))
 	assert.Nil(t, fake)

connector/traces_router_test.go

@@ -10,6 +10,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 
 	"go.opentelemetry.io/collector/component"
 	"go.opentelemetry.io/collector/consumer"
@@ -148,7 +149,7 @@ func TestTracesRouterConsumer(t *testing.T) {
 
 	none, err := r.Consumer()
 	assert.Nil(t, none)
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	fake, err := r.Consumer(component.MustNewID("fake"))
 	assert.Nil(t, fake)

consumer/consumererror/signalerrors_test.go

@@ -21,7 +21,7 @@ func TestTraces(t *testing.T) {
 	var target Traces
 	assert.False(t, errors.As(nil, &target))
 	assert.False(t, errors.As(err, &target))
-	assert.ErrorAs(t, traceErr, &target)
+	require.ErrorAs(t, traceErr, &target)
 	assert.Equal(t, td, target.Data())
 }
 
@@ -45,7 +45,7 @@ func TestLogs(t *testing.T) {
 	var target Logs
 	assert.False(t, errors.As(nil, &target))
 	assert.False(t, errors.As(err, &target))
-	assert.ErrorAs(t, logsErr, &target)
+	require.ErrorAs(t, logsErr, &target)
 	assert.Equal(t, td, target.Data())
 }
 
@@ -69,7 +69,7 @@ func TestMetrics(t *testing.T) {
 	var target Metrics
 	assert.False(t, errors.As(nil, &target))
 	assert.False(t, errors.As(err, &target))
-	assert.ErrorAs(t, metricErr, &target)
+	require.ErrorAs(t, metricErr, &target)
 	assert.Equal(t, td, target.Data())
 }
 

consumer/consumerprofiles/profiles_test.go

@@ -9,6 +9,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 
 	"go.opentelemetry.io/collector/consumer"
 	"go.opentelemetry.io/collector/pdata/pprofile"
@@ -46,6 +47,6 @@ func TestConsumeProfiles(t *testing.T) {
 func TestConsumeProfiles_ReturnError(t *testing.T) {
 	want := errors.New("my_error")
 	cp, err := NewProfiles(func(context.Context, pprofile.Profiles) error { return want })
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, want, cp.ConsumeProfiles(context.Background(), pprofile.NewProfiles()))
 }

consumer/logs_test.go

@@ -9,6 +9,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 
 	"go.opentelemetry.io/collector/pdata/plog"
 )
@@ -45,6 +46,6 @@ func TestConsumeLogs(t *testing.T) {
 func TestConsumeLogs_ReturnError(t *testing.T) {
 	want := errors.New("my_error")
 	cp, err := NewLogs(func(context.Context, plog.Logs) error { return want })
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, want, cp.ConsumeLogs(context.Background(), plog.NewLogs()))
 }

consumer/metrics_test.go

@@ -9,6 +9,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 
 	"go.opentelemetry.io/collector/pdata/pmetric"
 )
@@ -45,6 +46,6 @@ func TestConsumeMetrics(t *testing.T) {
 func TestConsumeMetrics_ReturnError(t *testing.T) {
 	want := errors.New("my_error")
 	cp, err := NewMetrics(func(context.Context, pmetric.Metrics) error { return want })
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, want, cp.ConsumeMetrics(context.Background(), pmetric.NewMetrics()))
 }

consumer/traces_test.go

@@ -9,6 +9,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 
 	"go.opentelemetry.io/collector/pdata/ptrace"
 )
@@ -45,6 +46,6 @@ func TestConsumeTraces(t *testing.T) {
 func TestConsumeTraces_ReturnError(t *testing.T) {
 	want := errors.New("my_error")
 	cp, err := NewTraces(func(context.Context, ptrace.Traces) error { return want })
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, want, cp.ConsumeTraces(context.Background(), ptrace.NewTraces()))
 }

exporter/debugexporter/config_test.go

@@ -18,7 +18,7 @@ import (
 func TestUnmarshalDefaultConfig(t *testing.T) {
 	factory := NewFactory()
 	cfg := factory.CreateDefaultConfig()
-	assert.NoError(t, confmap.New().Unmarshal(&cfg))
+	require.NoError(t, confmap.New().Unmarshal(&cfg))
 	assert.Equal(t, factory.CreateDefaultConfig(), cfg)
 }
 
@@ -52,7 +52,7 @@ func TestUnmarshalConfig(t *testing.T) {
 			if tt.expectedErr != "" {
 				assert.ErrorContains(t, err, tt.expectedErr)
 			} else {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 				assert.Equal(t, tt.cfg, cfg)
 			}
 		})
@@ -82,7 +82,7 @@ func Test_UnmarshalMarshalled(t *testing.T) {
 
 			conf := confmap.New()
 			err := conf.Marshal(tc.inCfg)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 
 			raw := conf.ToStringMap()
 
@@ -93,11 +93,11 @@ func Test_UnmarshalMarshalled(t *testing.T) {
 			err = conf.Unmarshal(outCfg)
 
 			if tc.expectedErr == "" {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 				assert.Equal(t, tc.expectedConfig, outCfg)
 				return
 			}
-			assert.Error(t, err)
+			require.Error(t, err)
 			assert.EqualError(t, err, tc.expectedErr)
 		})
 	}

exporter/debugexporter/factory_test.go

@@ -8,6 +8,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 
 	"go.opentelemetry.io/collector/component/componenttest"
 	"go.opentelemetry.io/collector/exporter/exportertest"
@@ -25,7 +26,7 @@ func TestCreateMetricsExporter(t *testing.T) {
 	cfg := factory.CreateDefaultConfig()
 
 	me, err := factory.CreateMetricsExporter(context.Background(), exportertest.NewNopSettings(), cfg)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.NotNil(t, me)
 }
 
@@ -34,7 +35,7 @@ func TestCreateTracesExporter(t *testing.T) {
 	cfg := factory.CreateDefaultConfig()
 
 	te, err := factory.CreateTracesExporter(context.Background(), exportertest.NewNopSettings(), cfg)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.NotNil(t, te)
 }
 
@@ -43,6 +44,6 @@ func TestCreateLogsExporter(t *testing.T) {
 	cfg := factory.CreateDefaultConfig()
 
 	te, err := factory.CreateLogsExporter(context.Background(), exportertest.NewNopSettings(), cfg)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.NotNil(t, te)
 }

exporter/debugexporter/internal/normal/logs_test.go

@@ -8,6 +8,7 @@ import (
 	"time"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 
 	"go.opentelemetry.io/collector/pdata/pcommon"
 	"go.opentelemetry.io/collector/pdata/plog"
@@ -111,7 +112,7 @@ log message mykey2=myvalue2 mykey1=myvalue1
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			output, err := NewNormalLogsMarshaler().MarshalLogs(tt.input)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.Equal(t, tt.expected, string(output))
 		})
 	}

exporter/debugexporter/internal/normal/metrics_test.go

@@ -7,6 +7,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 
 	"go.opentelemetry.io/collector/pdata/pmetric"
 )
@@ -113,7 +114,7 @@ func TestMarshalMetrics(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			output, err := NewNormalMetricsMarshaler().MarshalMetrics(tt.input)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.Equal(t, tt.expected, string(output))
 		})
 	}

exporter/debugexporter/internal/normal/traces_test.go

@@ -7,6 +7,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 
 	"go.opentelemetry.io/collector/pdata/ptrace"
 )
@@ -41,7 +42,7 @@ func TestMarshalTraces(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			output, err := NewNormalTracesMarshaler().MarshalTraces(tt.input)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.Equal(t, tt.expected, string(output))
 		})
 	}

exporter/exporter_test.go

@@ -8,6 +8,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 
 	"go.opentelemetry.io/collector/component"
 	"go.opentelemetry.io/collector/consumer/consumertest"
@@ -22,9 +23,9 @@ func TestNewFactory(t *testing.T) {
 	assert.EqualValues(t, testType, factory.Type())
 	assert.EqualValues(t, &defaultCfg, factory.CreateDefaultConfig())
 	_, err := factory.CreateTracesExporter(context.Background(), Settings{}, &defaultCfg)
-	assert.Error(t, err)
+	require.Error(t, err)
 	_, err = factory.CreateMetricsExporter(context.Background(), Settings{}, &defaultCfg)
-	assert.Error(t, err)
+	require.Error(t, err)
 	_, err = factory.CreateLogsExporter(context.Background(), Settings{}, &defaultCfg)
 	assert.Error(t, err)
 }
@@ -43,11 +44,11 @@ func TestNewFactoryWithOptions(t *testing.T) {
 
 	assert.Equal(t, component.StabilityLevelDevelopment, factory.TracesExporterStability())
 	_, err := factory.CreateTracesExporter(context.Background(), Settings{}, &defaultCfg)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	assert.Equal(t, component.StabilityLevelAlpha, factory.MetricsExporterStability())
 	_, err = factory.CreateMetricsExporter(context.Background(), Settings{}, &defaultCfg)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	assert.Equal(t, component.StabilityLevelDeprecated, factory.LogsExporterStability())
 	_, err = factory.CreateLogsExporter(context.Background(), Settings{}, &defaultCfg)
@@ -85,7 +86,7 @@ func TestMakeFactoryMap(t *testing.T) {
 				assert.Error(t, err)
 				return
 			}
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.Equal(t, tt.out, out)
 		})
 	}

exporter/exporterbatcher/config_test.go

@@ -7,21 +7,22 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestConfig_Validate(t *testing.T) {
 	cfg := NewDefaultConfig()
-	assert.NoError(t, cfg.Validate())
+	require.NoError(t, cfg.Validate())
 
 	cfg.MinSizeItems = -1
-	assert.EqualError(t, cfg.Validate(), "min_size_items must be greater than or equal to zero")
+	require.EqualError(t, cfg.Validate(), "min_size_items must be greater than or equal to zero")
 
 	cfg = NewDefaultConfig()
 	cfg.FlushTimeout = 0
-	assert.EqualError(t, cfg.Validate(), "timeout must be greater than zero")
+	require.EqualError(t, cfg.Validate(), "timeout must be greater than zero")
 
 	cfg.MaxSizeItems = -1
-	assert.EqualError(t, cfg.Validate(), "max_size_items must be greater than or equal to zero")
+	require.EqualError(t, cfg.Validate(), "max_size_items must be greater than or equal to zero")
 
 	cfg = NewDefaultConfig()
 	cfg.MaxSizeItems = 20000

exporter/exporterhelper/batch_sender_test.go

@@ -341,7 +341,7 @@ func TestBatchSender_ConcurrencyLimitReached(t *testing.T) {
 			}, 100*time.Millisecond, 10*time.Millisecond)
 
 			// the 3rd request should be flushed by itself due to flush interval
-			assert.NoError(t, be.send(context.Background(), &fakeRequest{items: 2, sink: sink}))
+			require.NoError(t, be.send(context.Background(), &fakeRequest{items: 2, sink: sink}))
 			assert.Eventually(t, func() bool {
 				return sink.requestsCount.Load() == 2 && sink.itemsCount.Load() == 6
 			}, 100*time.Millisecond, 10*time.Millisecond)
@@ -608,7 +608,7 @@ func TestBatchSenderWithTimeout(t *testing.T) {
 	}
 	wg.Wait()
 
-	assert.NoError(t, be.Shutdown(context.Background()))
+	require.NoError(t, be.Shutdown(context.Background()))
 
 	// The sink should not change
 	assert.EqualValues(t, 1, sink.requestsCount.Load())

exporter/exporterhelper/logs_batch_test.go

@@ -8,6 +8,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 
 	"go.opentelemetry.io/collector/exporter/exporterbatcher"
 	"go.opentelemetry.io/collector/pdata/plog"
@@ -18,7 +19,7 @@ func TestMergeLogs(t *testing.T) {
 	lr1 := &logsRequest{ld: testdata.GenerateLogs(2)}
 	lr2 := &logsRequest{ld: testdata.GenerateLogs(3)}
 	res, err := mergeLogs(context.Background(), lr1, lr2)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, 5, res.(*logsRequest).ld.LogRecordCount())
 }
 
@@ -132,7 +133,7 @@ func TestMergeSplitLogs(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			res, err := mergeSplitLogs(context.Background(), tt.cfg, tt.lr1, tt.lr2)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.Equal(t, len(tt.expected), len(res))
 			for i, r := range res {
 				assert.Equal(t, tt.expected[i], r.(*logsRequest))

exporter/exporterhelper/logs_test.go

@@ -86,7 +86,7 @@ func TestLogsExporter_Default(t *testing.T) {
 	ld := plog.NewLogs()
 	le, err := NewLogsExporter(context.Background(), exportertest.NewNopSettings(), &fakeLogsExporterConfig, newPushLogsData(nil))
 	assert.NotNil(t, le)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	assert.Equal(t, consumer.Capabilities{MutatesData: false}, le.Capabilities())
 	assert.NoError(t, le.Start(context.Background(), componenttest.NewNopHost()))
@@ -99,7 +99,7 @@ func TestLogsRequestExporter_Default(t *testing.T) {
 	le, err := NewLogsRequestExporter(context.Background(), exportertest.NewNopSettings(),
 		(&fakeRequestConverter{}).requestFromLogsFunc)
 	assert.NotNil(t, le)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	assert.Equal(t, consumer.Capabilities{MutatesData: false}, le.Capabilities())
 	assert.NoError(t, le.Start(context.Background(), componenttest.NewNopHost()))
@@ -198,10 +198,10 @@ func TestLogsExporter_pLogModifiedDownStream_WithRecordMetrics(t *testing.T) {
 
 	le, err := NewLogsExporter(context.Background(), exporter.Settings{ID: fakeLogsExporterName, TelemetrySettings: tt.TelemetrySettings(), BuildInfo: component.NewDefaultBuildInfo()}, &fakeLogsExporterConfig, newPushLogsDataModifiedDownstream(nil), WithCapabilities(consumer.Capabilities{MutatesData: true}))
 	assert.NotNil(t, le)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	ld := testdata.GenerateLogs(2)
 
-	assert.NoError(t, le.ConsumeLogs(context.Background(), ld))
+	require.NoError(t, le.ConsumeLogs(context.Background(), ld))
 	assert.Equal(t, 0, ld.LogRecordCount())
 	require.NoError(t, tt.CheckExporterLogs(int64(2), 0))
 }
@@ -357,7 +357,7 @@ func TestLogsExporter_WithShutdown_ReturnError(t *testing.T) {
 
 	le, err := NewLogsExporter(context.Background(), exportertest.NewNopSettings(), &fakeLogsExporterConfig, newPushLogsData(nil), WithShutdown(shutdownErr))
 	assert.NotNil(t, le)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	assert.Equal(t, want, le.Shutdown(context.Background()))
 }
@@ -369,7 +369,7 @@ func TestLogsRequestExporter_WithShutdown_ReturnError(t *testing.T) {
 	le, err := NewLogsRequestExporter(context.Background(), exportertest.NewNopSettings(),
 		(&fakeRequestConverter{}).requestFromLogsFunc, WithShutdown(shutdownErr))
 	assert.NotNil(t, le)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	assert.Equal(t, want, le.Shutdown(context.Background()))
 }

exporter/exporterhelper/metrics_batch_test.go

@@ -8,6 +8,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 
 	"go.opentelemetry.io/collector/exporter/exporterbatcher"
 	"go.opentelemetry.io/collector/pdata/pmetric"
@@ -18,7 +19,7 @@ func TestMergeMetrics(t *testing.T) {
 	mr1 := &metricsRequest{md: testdata.GenerateMetrics(2)}
 	mr2 := &metricsRequest{md: testdata.GenerateMetrics(3)}
 	res, err := mergeMetrics(context.Background(), mr1, mr2)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, 5, res.(*metricsRequest).md.MetricCount())
 }
 
@@ -133,7 +134,7 @@ func TestMergeSplitMetrics(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			res, err := mergeSplitMetrics(context.Background(), tt.cfg, tt.mr1, tt.mr2)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.Equal(t, len(tt.expected), len(res))
 			for i := range res {
 				assert.Equal(t, tt.expected[i], res[i].(*metricsRequest))

exporter/exporterhelper/metrics_test.go

@@ -86,7 +86,7 @@ func TestMetricsRequestExporter_NilMetricsConverter(t *testing.T) {
 func TestMetricsExporter_Default(t *testing.T) {
 	md := pmetric.NewMetrics()
 	me, err := NewMetricsExporter(context.Background(), exportertest.NewNopSettings(), &fakeMetricsExporterConfig, newPushMetricsData(nil))
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.NotNil(t, me)
 
 	assert.Equal(t, consumer.Capabilities{MutatesData: false}, me.Capabilities())
@@ -99,7 +99,7 @@ func TestMetricsRequestExporter_Default(t *testing.T) {
 	md := pmetric.NewMetrics()
 	me, err := NewMetricsRequestExporter(context.Background(), exportertest.NewNopSettings(),
 		(&fakeRequestConverter{}).requestFromMetricsFunc)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.NotNil(t, me)
 
 	assert.Equal(t, consumer.Capabilities{MutatesData: false}, me.Capabilities())
@@ -111,7 +111,7 @@ func TestMetricsRequestExporter_Default(t *testing.T) {
 func TestMetricsExporter_WithCapabilities(t *testing.T) {
 	capabilities := consumer.Capabilities{MutatesData: true}
 	me, err := NewMetricsExporter(context.Background(), exportertest.NewNopSettings(), &fakeMetricsExporterConfig, newPushMetricsData(nil), WithCapabilities(capabilities))
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.NotNil(t, me)
 
 	assert.Equal(t, capabilities, me.Capabilities())
@@ -121,7 +121,7 @@ func TestMetricsRequestExporter_WithCapabilities(t *testing.T) {
 	capabilities := consumer.Capabilities{MutatesData: true}
 	me, err := NewMetricsRequestExporter(context.Background(), exportertest.NewNopSettings(),
 		(&fakeRequestConverter{}).requestFromMetricsFunc, WithCapabilities(capabilities))
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.NotNil(t, me)
 
 	assert.Equal(t, capabilities, me.Capabilities())
@@ -202,7 +202,7 @@ func TestMetricsExporter_pMetricModifiedDownStream_WithRecordMetrics(t *testing.
 	require.NotNil(t, me)
 	md := testdata.GenerateMetrics(2)
 
-	assert.NoError(t, me.ConsumeMetrics(context.Background(), md))
+	require.NoError(t, me.ConsumeMetrics(context.Background(), md))
 	assert.Equal(t, 0, md.MetricCount())
 	require.NoError(t, tt.CheckExporterMetrics(int64(4), 0))
 }

exporter/exporterhelper/obsexporter_test.go

@@ -185,9 +185,9 @@ func TestCheckExporterTracesViews(t *testing.T) {
 	require.NotNil(t, ctx)
 	obsrep.endTracesOp(ctx, 7, nil)
 
-	assert.NoError(t, tt.CheckExporterTraces(7, 0))
+	require.NoError(t, tt.CheckExporterTraces(7, 0))
-	assert.Error(t, tt.CheckExporterTraces(7, 7))
+	require.Error(t, tt.CheckExporterTraces(7, 7))
-	assert.Error(t, tt.CheckExporterTraces(0, 0))
+	require.Error(t, tt.CheckExporterTraces(0, 0))
 	assert.Error(t, tt.CheckExporterTraces(0, 7))
 }
 
@@ -205,9 +205,9 @@ func TestCheckExporterMetricsViews(t *testing.T) {
 	require.NotNil(t, ctx)
 	obsrep.endMetricsOp(ctx, 7, nil)
 
-	assert.NoError(t, tt.CheckExporterMetrics(7, 0))
+	require.NoError(t, tt.CheckExporterMetrics(7, 0))
-	assert.Error(t, tt.CheckExporterMetrics(7, 7))
+	require.Error(t, tt.CheckExporterMetrics(7, 7))
-	assert.Error(t, tt.CheckExporterMetrics(0, 0))
+	require.Error(t, tt.CheckExporterMetrics(0, 0))
 	assert.Error(t, tt.CheckExporterMetrics(0, 7))
 }
 
@@ -225,9 +225,9 @@ func TestCheckExporterLogsViews(t *testing.T) {
 	require.NotNil(t, ctx)
 	obsrep.endLogsOp(ctx, 7, nil)
 
-	assert.NoError(t, tt.CheckExporterLogs(7, 0))
+	require.NoError(t, tt.CheckExporterLogs(7, 0))
-	assert.Error(t, tt.CheckExporterLogs(7, 7))
+	require.Error(t, tt.CheckExporterLogs(7, 7))
-	assert.Error(t, tt.CheckExporterLogs(0, 0))
+	require.Error(t, tt.CheckExporterLogs(0, 0))
 	assert.Error(t, tt.CheckExporterLogs(0, 7))
 }
 

exporter/exporterhelper/queue_sender_test.go

@@ -51,7 +51,7 @@ func TestQueuedRetry_StopWhileWaiting(t *testing.T) {
 
 	require.LessOrEqual(t, 1, be.queueSender.(*queueSender).queue.Size())
 
-	assert.NoError(t, be.Shutdown(context.Background()))
+	require.NoError(t, be.Shutdown(context.Background()))
 
 	secondMockR.checkNumRequests(t, 1)
 	ocs.checkSendItemsCount(t, 3)
@@ -242,7 +242,7 @@ func TestNoCancellationContext(t *testing.T) {
 	require.Equal(t, deadline, d)
 
 	nctx := context.WithoutCancel(ctx)
-	assert.NoError(t, nctx.Err())
+	require.NoError(t, nctx.Err())
 	d, ok = nctx.Deadline()
 	assert.False(t, ok)
 	assert.True(t, d.IsZero())
@@ -250,15 +250,15 @@ func TestNoCancellationContext(t *testing.T) {
 
 func TestQueueConfig_Validate(t *testing.T) {
 	qCfg := NewDefaultQueueConfig()
-	assert.NoError(t, qCfg.Validate())
+	require.NoError(t, qCfg.Validate())
 
 	qCfg.QueueSize = 0
-	assert.EqualError(t, qCfg.Validate(), "queue size must be positive")
+	require.EqualError(t, qCfg.Validate(), "queue size must be positive")
 
 	qCfg = NewDefaultQueueConfig()
 	qCfg.NumConsumers = 0
 
-	assert.EqualError(t, qCfg.Validate(), "number of queue consumers must be positive")
+	require.EqualError(t, qCfg.Validate(), "number of queue consumers must be positive")
 
 	// Confirm Validate doesn't return error with invalid config when feature is disabled
 	qCfg.Enabled = false
@@ -436,7 +436,7 @@ func TestQueueSenderNoStartShutdown(t *testing.T) {
 		exporterID:             exporterID,
 		exporterCreateSettings: exportertest.NewNopSettings(),
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	qs := newQueueSender(queue, set, 1, "", obsrep)
 	assert.NoError(t, qs.Shutdown(context.Background()))
 }

exporter/exporterhelper/timeout_sender_test.go

@@ -8,17 +8,18 @@ import (
 	"time"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestNewDefaultTimeoutConfig(t *testing.T) {
 	cfg := NewDefaultTimeoutConfig()
-	assert.NoError(t, cfg.Validate())
+	require.NoError(t, cfg.Validate())
 	assert.Equal(t, TimeoutConfig{Timeout: 5 * time.Second}, cfg)
 }
 
 func TestInvalidTimeout(t *testing.T) {
 	cfg := NewDefaultTimeoutConfig()
-	assert.NoError(t, cfg.Validate())
+	require.NoError(t, cfg.Validate())
 	cfg.Timeout = -1
 	assert.Error(t, cfg.Validate())
 }

exporter/exporterhelper/traces_batch_test.go

@@ -8,6 +8,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 
 	"go.opentelemetry.io/collector/exporter/exporterbatcher"
 	"go.opentelemetry.io/collector/pdata/ptrace"
@@ -18,7 +19,7 @@ func TestMergeTraces(t *testing.T) {
 	tr1 := &tracesRequest{td: testdata.GenerateTraces(2)}
 	tr2 := &tracesRequest{td: testdata.GenerateTraces(3)}
 	res, err := mergeTraces(context.Background(), tr1, tr2)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, 5, res.(*tracesRequest).td.SpanCount())
 }
 
@@ -133,7 +134,7 @@ func TestMergeSplitTraces(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			res, err := mergeSplitTraces(context.Background(), tt.cfg, tt.tr1, tt.tr2)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.Equal(t, len(tt.expected), len(res))
 			for i := range res {
 				assert.Equal(t, tt.expected[i], res[i].(*tracesRequest))

exporter/exporterhelper/traces_test.go

@@ -82,7 +82,7 @@ func TestTracesExporter_Default(t *testing.T) {
 	td := ptrace.NewTraces()
 	te, err := NewTracesExporter(context.Background(), exportertest.NewNopSettings(), &fakeTracesExporterConfig, newTraceDataPusher(nil))
 	assert.NotNil(t, te)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	assert.Equal(t, consumer.Capabilities{MutatesData: false}, te.Capabilities())
 	assert.NoError(t, te.Start(context.Background(), componenttest.NewNopHost()))
@@ -95,7 +95,7 @@ func TestTracesRequestExporter_Default(t *testing.T) {
 	te, err := NewTracesRequestExporter(context.Background(), exportertest.NewNopSettings(),
 		(&fakeRequestConverter{}).requestFromTracesFunc)
 	assert.NotNil(t, te)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	assert.Equal(t, consumer.Capabilities{MutatesData: false}, te.Capabilities())
 	assert.NoError(t, te.Start(context.Background(), componenttest.NewNopHost()))
@@ -107,7 +107,7 @@ func TestTracesExporter_WithCapabilities(t *testing.T) {
 	capabilities := consumer.Capabilities{MutatesData: true}
 	te, err := NewTracesExporter(context.Background(), exportertest.NewNopSettings(), &fakeTracesExporterConfig, newTraceDataPusher(nil), WithCapabilities(capabilities))
 	assert.NotNil(t, te)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	assert.Equal(t, capabilities, te.Capabilities())
 }
@@ -117,7 +117,7 @@ func TestTracesRequestExporter_WithCapabilities(t *testing.T) {
 	te, err := NewTracesRequestExporter(context.Background(), exportertest.NewNopSettings(),
 		(&fakeRequestConverter{}).requestFromTracesFunc, WithCapabilities(capabilities))
 	assert.NotNil(t, te)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	assert.Equal(t, capabilities, te.Capabilities())
 }
@@ -196,10 +196,10 @@ func TestTracesExporter_pLogModifiedDownStream_WithRecordMetrics(t *testing.T) {
 
 	te, err := NewTracesExporter(context.Background(), exporter.Settings{ID: fakeTracesExporterName, TelemetrySettings: tt.TelemetrySettings(), BuildInfo: component.NewDefaultBuildInfo()}, &fakeTracesExporterConfig, newTraceDataPusherModifiedDownstream(nil), WithCapabilities(consumer.Capabilities{MutatesData: true}))
 	assert.NotNil(t, te)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	td := testdata.GenerateTraces(2)
 
-	assert.NoError(t, te.ConsumeTraces(context.Background(), td))
+	require.NoError(t, te.ConsumeTraces(context.Background(), td))
 	assert.Equal(t, 0, td.SpanCount())
 	require.NoError(t, tt.CheckExporterTraces(int64(2), 0))
 }

exporter/exporterqueue/config_test.go

@@ -7,18 +7,19 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestQueueConfig_Validate(t *testing.T) {
 	qCfg := NewDefaultConfig()
-	assert.NoError(t, qCfg.Validate())
+	require.NoError(t, qCfg.Validate())
 
 	qCfg.NumConsumers = 0
-	assert.EqualError(t, qCfg.Validate(), "number of consumers must be positive")
+	require.EqualError(t, qCfg.Validate(), "number of consumers must be positive")
 
 	qCfg = NewDefaultConfig()
 	qCfg.QueueSize = 0
-	assert.EqualError(t, qCfg.Validate(), "queue size must be positive")
+	require.EqualError(t, qCfg.Validate(), "queue size must be positive")
 
 	// Confirm Validate doesn't return error with invalid config when feature is disabled
 	qCfg.Enabled = false

exporter/exportertest/mock_consumer_test.go

@@ -9,6 +9,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 
 	"go.opentelemetry.io/collector/consumer"
 	"go.opentelemetry.io/collector/pdata/plog"
@@ -46,13 +47,13 @@ func TestIDFromMetrics(t *testing.T) {
 	validData := createMetric(id)
 	metricID, err := idFromMetrics(validData)
 	assert.Equal(t, metricID, id)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	// Test case 2: Missing uniqueIDAttrName attribute
 	invalidData := pmetric.NewMetrics() // Create an invalid pmetric.Metrics object with missing attribute
 	invalidData.ResourceMetrics().AppendEmpty().ScopeMetrics().AppendEmpty().Metrics().AppendEmpty().SetEmptyHistogram().DataPoints().AppendEmpty().Attributes()
 	_, err = idFromMetrics(invalidData)
-	assert.Error(t, err)
+	require.Error(t, err)
 	assert.Equal(t, err.Error(), fmt.Sprintf("invalid data element, attribute %q is missing", uniqueIDAttrName))
 
 	// Test case 3: Wrong attribute type
@@ -61,7 +62,7 @@ func TestIDFromMetrics(t *testing.T) {
 	wrongAttribute.ResourceMetrics().AppendEmpty().ScopeMetrics().AppendEmpty().Metrics().AppendEmpty().
 		SetEmptyHistogram().DataPoints().AppendEmpty().Attributes().PutInt(uniqueIDAttrName, intID)
 	_, err = idFromMetrics(wrongAttribute)
-	assert.Error(t, err)
+	require.Error(t, err)
 	assert.Equal(t, err.Error(), fmt.Sprintf("invalid data element, attribute %q is wrong type Int", uniqueIDAttrName))
 }
 
@@ -71,13 +72,13 @@ func TestIDFromTraces(t *testing.T) {
 	validData := createTrace(id)
 	traceID, err := idFromTraces(validData)
 	assert.Equal(t, traceID, id)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	// Test case 2: Missing uniqueIDAttrName attribute
 	invalidData := ptrace.NewTraces()
 	invalidData.ResourceSpans().AppendEmpty().ScopeSpans().AppendEmpty().Spans().AppendEmpty().Attributes()
 	_, err = idFromTraces(invalidData)
-	assert.Error(t, err)
+	require.Error(t, err)
 	assert.Equal(t, err.Error(), fmt.Sprintf("invalid data element, attribute %q is missing", uniqueIDAttrName))
 
 	// Test case 3: Wrong attribute type
@@ -86,7 +87,7 @@ func TestIDFromTraces(t *testing.T) {
 	wrongAttribute.ResourceSpans().AppendEmpty().ScopeSpans().AppendEmpty().Spans().AppendEmpty().Attributes().
 		PutInt(uniqueIDAttrName, intID)
 	_, err = idFromTraces(wrongAttribute)
-	assert.Error(t, err)
+	require.Error(t, err)
 	assert.Equal(t, err.Error(), fmt.Sprintf("invalid data element, attribute %q is wrong type Int", uniqueIDAttrName))
 }
 
@@ -96,13 +97,13 @@ func TestIDFromLogs(t *testing.T) {
 	validData := createLog(id)
 	logID, err := idFromLogs(validData)
 	assert.Equal(t, logID, id)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	// Test case 2: Missing uniqueIDAttrName attribute
 	invalidData := plog.NewLogs()
 	invalidData.ResourceLogs().AppendEmpty().ScopeLogs().AppendEmpty().LogRecords().AppendEmpty().Attributes()
 	_, err = idFromLogs(invalidData)
-	assert.Error(t, err)
+	require.Error(t, err)
 	assert.Equal(t, err.Error(), fmt.Sprintf("invalid data element, attribute %q is missing", uniqueIDAttrName))
 
 	// Test case 3: Wrong attribute type
@@ -111,7 +112,7 @@ func TestIDFromLogs(t *testing.T) {
 	wrongAttribute.ResourceLogs().AppendEmpty().ScopeLogs().AppendEmpty().LogRecords().AppendEmpty().Attributes().
 		PutInt(uniqueIDAttrName, intID)
 	_, err = idFromLogs(wrongAttribute)
-	assert.Error(t, err)
+	require.Error(t, err)
 	assert.Equal(t, err.Error(), fmt.Sprintf("invalid data element, attribute %q is wrong type Int", uniqueIDAttrName))
 }
 

exporter/internal/common/factory_test.go

@@ -8,6 +8,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 
 	"go.opentelemetry.io/collector/component"
 	"go.opentelemetry.io/collector/exporter/exportertest"
@@ -19,18 +20,18 @@ func createDefaultConfig() component.Config {
 
 func TestCreateMetricsExporter(t *testing.T) {
 	me, err := CreateMetricsExporter(context.Background(), exportertest.NewNopSettings(), createDefaultConfig(), &Common{})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.NotNil(t, me)
 }
 
 func TestCreateTracesExporter(t *testing.T) {
 	te, err := CreateTracesExporter(context.Background(), exportertest.NewNopSettings(), createDefaultConfig(), &Common{})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.NotNil(t, te)
 }
 
 func TestCreateLogsExporter(t *testing.T) {
 	te, err := CreateLogsExporter(context.Background(), exportertest.NewNopSettings(), createDefaultConfig(), &Common{})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.NotNil(t, te)
 }

exporter/internal/otlptext/logs_test.go

@@ -65,7 +65,7 @@ func TestLogsText(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			got, err := NewTextLogsMarshaler().MarshalLogs(tt.in)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			out, err := os.ReadFile(filepath.Join("testdata", "logs", tt.out))
 			require.NoError(t, err)
 			expected := strings.ReplaceAll(string(out), "\r", "")

exporter/internal/otlptext/metrics_test.go

@@ -46,7 +46,7 @@ func TestMetricsText(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			got, err := NewTextMetricsMarshaler().MarshalMetrics(tt.in)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			out, err := os.ReadFile(filepath.Join("testdata", "metrics", tt.out))
 			require.NoError(t, err)
 			expected := strings.ReplaceAll(string(out), "\r", "")

exporter/internal/otlptext/traces_test.go

@@ -37,7 +37,7 @@ func TestTracesText(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			got, err := NewTextTracesMarshaler().MarshalTraces(tt.in)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			out, err := os.ReadFile(filepath.Join("testdata", "traces", tt.out))
 			require.NoError(t, err)
 			expected := strings.ReplaceAll(string(out), "\r", "")

exporter/internal/queue/bounded_memory_queue_test.go

@@ -23,7 +23,7 @@ import (
 func TestBoundedQueue(t *testing.T) {
 	q := NewBoundedMemoryQueue[string](MemoryQueueSettings[string]{Sizer: &RequestSizer[string]{}, Capacity: 1})
 
-	assert.NoError(t, q.Offer(context.Background(), "a"))
+	require.NoError(t, q.Offer(context.Background(), "a"))
 
 	numConsumed := 0
 	assert.True(t, q.Consume(func(_ context.Context, item string) error {
@@ -35,11 +35,11 @@ func TestBoundedQueue(t *testing.T) {
 	assert.Equal(t, 0, q.Size())
 
 	// produce two more items. The first one should be accepted, but not consumed.
-	assert.NoError(t, q.Offer(context.Background(), "b"))
+	require.NoError(t, q.Offer(context.Background(), "b"))
 	assert.Equal(t, 1, q.Size())
 
 	// the second should be rejected since the queue is full
-	assert.ErrorIs(t, q.Offer(context.Background(), "c"), ErrQueueIsFull)
+	require.ErrorIs(t, q.Offer(context.Background(), "c"), ErrQueueIsFull)
 	assert.Equal(t, 1, q.Size())
 
 	assert.True(t, q.Consume(func(_ context.Context, item string) error {
@@ -50,7 +50,7 @@ func TestBoundedQueue(t *testing.T) {
 	assert.Equal(t, 2, numConsumed)
 
 	for _, toAddItem := range []string{"d", "e", "f"} {
-		assert.NoError(t, q.Offer(context.Background(), toAddItem))
+		require.NoError(t, q.Offer(context.Background(), toAddItem))
 		assert.True(t, q.Consume(func(_ context.Context, item string) error {
 			assert.Equal(t, toAddItem, item)
 			numConsumed++
@@ -58,7 +58,7 @@ func TestBoundedQueue(t *testing.T) {
 		}))
 	}
 	assert.Equal(t, 5, numConsumed)
-	assert.NoError(t, q.Shutdown(context.Background()))
+	require.NoError(t, q.Shutdown(context.Background()))
 	assert.False(t, q.Consume(func(_ context.Context, item string) error {
 		panic(item)
 	}))
@@ -75,7 +75,7 @@ func TestShutdownWhileNotEmpty(t *testing.T) {
 
 	assert.NoError(t, q.Start(context.Background(), componenttest.NewNopHost()))
 	for i := 0; i < 10; i++ {
-		assert.NoError(t, q.Offer(context.Background(), strconv.FormatInt(int64(i), 10)))
+		require.NoError(t, q.Offer(context.Background(), strconv.FormatInt(int64(i), 10)))
 	}
 	assert.NoError(t, q.Shutdown(context.Background()))
 
@@ -150,9 +150,9 @@ func TestZeroSizeNoConsumers(t *testing.T) {
 	q := NewBoundedMemoryQueue[string](MemoryQueueSettings[string]{Sizer: &RequestSizer[string]{}, Capacity: 0})
 
 	err := q.Start(context.Background(), componenttest.NewNopHost())
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
-	assert.ErrorIs(t, q.Offer(context.Background(), "a"), ErrQueueIsFull) // in process
+	require.ErrorIs(t, q.Offer(context.Background(), "a"), ErrQueueIsFull) // in process
 
 	assert.NoError(t, q.Shutdown(context.Background()))
 }

exporter/internal/queue/persistent_queue_test.go

@@ -148,16 +148,16 @@ func TestPersistentQueue_FullCapacity(t *testing.T) {
 			req := newTracesRequest(1, 10)
 
 			// First request is picked by the consumer. Wait until the consumer is blocked on done.
-			assert.NoError(t, pq.Offer(context.Background(), req))
+			require.NoError(t, pq.Offer(context.Background(), req))
 			start <- struct{}{}
 			close(start)
 
 			for i := 0; i < 10; i++ {
 				result := pq.Offer(context.Background(), newTracesRequest(1, 10))
 				if i < 5 {
-					assert.NoError(t, result)
+					require.NoError(t, result)
 				} else {
-					assert.ErrorIs(t, result, ErrQueueIsFull)
+					require.ErrorIs(t, result, ErrQueueIsFull)
 				}
 			}
 			assert.Equal(t, 5*tt.sizeMultiplier, pq.Size())
@@ -219,7 +219,7 @@ func TestPersistentQueue_ConsumersProducers(t *testing.T) {
 				})
 
 			for i := 0; i < c.numMessagesProduced; i++ {
-				assert.NoError(t, pq.Offer(context.Background(), req))
+				require.NoError(t, pq.Offer(context.Background(), req))
 			}
 
 			assert.Eventually(t, func() bool {
@@ -309,10 +309,10 @@ func TestToStorageClient(t *testing.T) {
 
 			// verify
 			if tt.expectedError != nil {
-				assert.ErrorIs(t, err, tt.expectedError)
+				require.ErrorIs(t, err, tt.expectedError)
 				assert.Nil(t, client)
 			} else {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 				assert.NotNil(t, client)
 			}
 		})
@@ -327,7 +327,7 @@ func TestInvalidStorageExtensionType(t *testing.T) {
 	extConfig := factory.CreateDefaultConfig()
 	settings := extensiontest.NewNopSettings()
 	extension, err := factory.CreateExtension(context.Background(), settings, extConfig)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	var extensions = map[component.ID]component.Component{
 		storageID: extension,
 	}
@@ -338,7 +338,7 @@ func TestInvalidStorageExtensionType(t *testing.T) {
 	client, err := toStorageClient(context.Background(), storageID, host, ownerID, component.DataTypeTraces)
 
 	// we should get an error about the extension type
-	assert.ErrorIs(t, err, errWrongExtensionType)
+	require.ErrorIs(t, err, errWrongExtensionType)
 	assert.Nil(t, client)
 }
 
@@ -439,7 +439,7 @@ func TestPersistentQueue_CorruptedData(t *testing.T) {
 			}
 
 			// Cannot close until we corrupt the data because the
-			assert.NoError(t, ps.Shutdown(context.Background()))
+			require.NoError(t, ps.Shutdown(context.Background()))
 
 			// Reload
 			newPs := createTestPersistentQueueWithRequestsCapacity(t, ext, 1000)
@@ -525,7 +525,7 @@ func TestPersistentQueueStartWithNonDispatched(t *testing.T) {
 		require.Equal(t, 5, ps.Size())
 		return experr.NewShutdownErr(nil)
 	}))
-	assert.NoError(t, ps.Shutdown(context.Background()))
+	require.NoError(t, ps.Shutdown(context.Background()))
 
 	// Reload with extra capacity to make sure we re-enqueue in-progress items.
 	newPs := createTestPersistentQueueWithRequestsCapacity(t, ext, 6)
@@ -608,7 +608,7 @@ func TestPersistentQueue_PutCloseReadClose(t *testing.T) {
 	assert.Equal(t, 2, ps.Size())
 	// TODO: Remove this, after the initialization writes the readIndex.
 	_, _, _ = ps.getNextItem(context.Background())
-	assert.NoError(t, ps.Shutdown(context.Background()))
+	require.NoError(t, ps.Shutdown(context.Background()))
 
 	newPs := createTestPersistentQueueWithRequestsCapacity(t, ext, 1000)
 	require.Equal(t, 2, newPs.Size())
@@ -733,12 +733,12 @@ func TestPersistentQueue_ShutdownWhileConsuming(t *testing.T) {
 	assert.Equal(t, 0, ps.Size())
 	assert.False(t, ps.client.(*mockStorageClient).isClosed())
 
-	assert.NoError(t, ps.Offer(context.Background(), newTracesRequest(5, 10)))
+	require.NoError(t, ps.Offer(context.Background(), newTracesRequest(5, 10)))
 
 	_, onProcessingFinished, ok := ps.getNextItem(context.Background())
 	require.True(t, ok)
 	assert.False(t, ps.client.(*mockStorageClient).isClosed())
-	assert.NoError(t, ps.Shutdown(context.Background()))
+	require.NoError(t, ps.Shutdown(context.Background()))
 	assert.False(t, ps.client.(*mockStorageClient).isClosed())
 	onProcessingFinished(nil)
 	assert.True(t, ps.client.(*mockStorageClient).isClosed())
@@ -852,7 +852,7 @@ func TestPersistentQueue_ItemsCapacityUsageRestoredOnShutdown(t *testing.T) {
 	assert.NoError(t, pq.Offer(context.Background(), newTracesRequest(2, 10)))
 	assert.Equal(t, 100, pq.Size())
 
-	assert.ErrorIs(t, pq.Offer(context.Background(), newTracesRequest(5, 5)), ErrQueueIsFull)
+	require.ErrorIs(t, pq.Offer(context.Background(), newTracesRequest(5, 5)), ErrQueueIsFull)
 	assert.Equal(t, 100, pq.Size())
 
 	assert.True(t, pq.Consume(func(_ context.Context, traces tracesRequest) error {
@@ -861,14 +861,14 @@ func TestPersistentQueue_ItemsCapacityUsageRestoredOnShutdown(t *testing.T) {
 	}))
 	assert.Equal(t, 60, pq.Size())
 
-	assert.NoError(t, pq.Shutdown(context.Background()))
+	require.NoError(t, pq.Shutdown(context.Background()))
 
 	newPQ := createTestPersistentQueueWithItemsCapacity(t, ext, 100)
 
 	// The queue should be restored to the previous size.
 	assert.Equal(t, 60, newPQ.Size())
 
-	assert.NoError(t, newPQ.Offer(context.Background(), newTracesRequest(2, 5)))
+	require.NoError(t, newPQ.Offer(context.Background(), newTracesRequest(2, 5)))
 
 	// Check the combined queue size.
 	assert.Equal(t, 70, newPQ.Size())
@@ -906,14 +906,14 @@ func TestPersistentQueue_ItemsCapacityUsageIsNotPreserved(t *testing.T) {
 	}))
 	assert.Equal(t, 2, pq.Size())
 
-	assert.NoError(t, pq.Shutdown(context.Background()))
+	require.NoError(t, pq.Shutdown(context.Background()))
 
 	newPQ := createTestPersistentQueueWithItemsCapacity(t, ext, 100)
 
 	// The queue items size cannot be restored, fall back to request-based size
 	assert.Equal(t, 2, newPQ.Size())
 
-	assert.NoError(t, newPQ.Offer(context.Background(), newTracesRequest(2, 5)))
+	require.NoError(t, newPQ.Offer(context.Background(), newTracesRequest(2, 5)))
 
 	// Only new items are correctly reflected
 	assert.Equal(t, 12, newPQ.Size())
@@ -933,7 +933,7 @@ func TestPersistentQueue_ItemsCapacityUsageIsNotPreserved(t *testing.T) {
 	assert.Equal(t, 0, newPQ.Size())
 
 	// Adding another batch should update the size accordingly
-	assert.NoError(t, newPQ.Offer(context.Background(), newTracesRequest(5, 5)))
+	require.NoError(t, newPQ.Offer(context.Background(), newTracesRequest(5, 5)))
 	assert.Equal(t, 25, newPQ.Size())
 
 	assert.True(t, newPQ.Consume(func(_ context.Context, traces tracesRequest) error {
@@ -966,7 +966,7 @@ func TestPersistentQueue_RequestCapacityLessAfterRestart(t *testing.T) {
 	}))
 	assert.Equal(t, 3, pq.Size())
 
-	assert.NoError(t, pq.Shutdown(context.Background()))
+	require.NoError(t, pq.Shutdown(context.Background()))
 
 	// The queue is restarted with the less capacity than needed to restore the queued items, but with the same
 	// underlying storage. No need to drop requests that are over capacity since they are already in the storage.
@@ -976,7 +976,7 @@ func TestPersistentQueue_RequestCapacityLessAfterRestart(t *testing.T) {
 	assert.Equal(t, 3, newPQ.Size())
 
 	// Queue is full
-	assert.Error(t, newPQ.Offer(context.Background(), newTracesRequest(2, 5)))
+	require.Error(t, newPQ.Offer(context.Background(), newTracesRequest(2, 5)))
 
 	assert.True(t, newPQ.Consume(func(_ context.Context, traces tracesRequest) error {
 		assert.Equal(t, 20, traces.traces.SpanCount())
@@ -985,7 +985,7 @@ func TestPersistentQueue_RequestCapacityLessAfterRestart(t *testing.T) {
 	assert.Equal(t, 2, newPQ.Size())
 
 	// Still full
-	assert.Error(t, newPQ.Offer(context.Background(), newTracesRequest(2, 5)))
+	require.Error(t, newPQ.Offer(context.Background(), newTracesRequest(2, 5)))
 
 	assert.True(t, newPQ.Consume(func(_ context.Context, traces tracesRequest) error {
 		assert.Equal(t, 25, traces.traces.SpanCount())
@@ -1008,7 +1008,7 @@ func TestPersistentQueue_RestoredUsedSizeIsCorrectedOnDrain(t *testing.T) {
 	assert.Equal(t, 0, pq.Size())
 
 	for i := 0; i < 6; i++ {
-		assert.NoError(t, pq.Offer(context.Background(), newTracesRequest(2, 5)))
+		require.NoError(t, pq.Offer(context.Background(), newTracesRequest(2, 5)))
 	}
 	assert.Equal(t, 60, pq.Size())
 

exporter/internal/queue/sized_channel_test.go

@@ -8,23 +8,24 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestSizedCapacityChannel(t *testing.T) {
 	q := newSizedChannel[int](7, nil, 0)
-	assert.NoError(t, q.push(1, 1, nil))
+	require.NoError(t, q.push(1, 1, nil))
 	assert.Equal(t, 1, q.Size())
 	assert.Equal(t, 7, q.Capacity())
 
 	// failed callback should not allow the element to be added
-	assert.Error(t, q.push(2, 2, func() error { return errors.New("failed") }))
+	require.Error(t, q.push(2, 2, func() error { return errors.New("failed") }))
 	assert.Equal(t, 1, q.Size())
 
-	assert.NoError(t, q.push(3, 3, nil))
+	require.NoError(t, q.push(3, 3, nil))
 	assert.Equal(t, 4, q.Size())
 
 	// should not be able to send to the full queue
-	assert.Error(t, q.push(4, 4, nil))
+	require.Error(t, q.push(4, 4, nil))
 	assert.Equal(t, 4, q.Size())
 
 	el, ok := q.pop(func(el int) int64 { return int64(el) })
@@ -45,10 +46,10 @@ func TestSizedCapacityChannel(t *testing.T) {
 
 func TestSizedCapacityChannel_Offer_sizedNotFullButChannelFull(t *testing.T) {
 	q := newSizedChannel[int](1, nil, 0)
-	assert.NoError(t, q.push(1, 1, nil))
+	require.NoError(t, q.push(1, 1, nil))
 
 	q.used.Store(0)
 	err := q.push(1, 1, nil)
-	assert.Error(t, err)
+	require.Error(t, err)
 	assert.Equal(t, ErrQueueIsFull, err)
 }

exporter/loggingexporter/config_test.go

@@ -19,7 +19,7 @@ import (
 func TestUnmarshalDefaultConfig(t *testing.T) {
 	factory := NewFactory()
 	cfg := factory.CreateDefaultConfig()
-	assert.NoError(t, confmap.New().Unmarshal(&cfg))
+	require.NoError(t, confmap.New().Unmarshal(&cfg))
 	assert.Equal(t, factory.CreateDefaultConfig(), cfg)
 }
 
@@ -78,7 +78,7 @@ func TestUnmarshalConfig(t *testing.T) {
 			if tt.expectedErr != "" {
 				assert.ErrorContains(t, err, tt.expectedErr)
 			} else {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 				assert.Equal(t, tt.cfg, cfg)
 			}
 		})
@@ -126,7 +126,7 @@ func Test_UnmarshalMarshalled(t *testing.T) {
 
 			conf := confmap.New()
 			err := conf.Marshal(tc.inCfg)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 
 			raw := conf.ToStringMap()
 
@@ -137,11 +137,11 @@ func Test_UnmarshalMarshalled(t *testing.T) {
 			err = conf.Unmarshal(outCfg)
 
 			if tc.expectedErr == "" {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 				assert.Equal(t, tc.expectedConfig, outCfg)
 				return
 			}
-			assert.Error(t, err)
+			require.Error(t, err)
 			assert.EqualError(t, err, tc.expectedErr)
 		})
 	}

exporter/loggingexporter/factory_test.go

@@ -8,6 +8,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 
 	"go.opentelemetry.io/collector/component/componenttest"
 	"go.opentelemetry.io/collector/exporter/exportertest"
@@ -25,7 +26,7 @@ func TestCreateMetricsExporter(t *testing.T) {
 	cfg := factory.CreateDefaultConfig()
 
 	me, err := factory.CreateMetricsExporter(context.Background(), exportertest.NewNopSettings(), cfg)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.NotNil(t, me)
 }
 
@@ -34,7 +35,7 @@ func TestCreateTracesExporter(t *testing.T) {
 	cfg := factory.CreateDefaultConfig()
 
 	te, err := factory.CreateTracesExporter(context.Background(), exportertest.NewNopSettings(), cfg)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.NotNil(t, te)
 }
 
@@ -43,6 +44,6 @@ func TestCreateLogsExporter(t *testing.T) {
 	cfg := factory.CreateDefaultConfig()
 
 	te, err := factory.CreateLogsExporter(context.Background(), exportertest.NewNopSettings(), cfg)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.NotNil(t, te)
 }

exporter/otlpexporter/config_test.go

@@ -26,7 +26,7 @@ import (
 func TestUnmarshalDefaultConfig(t *testing.T) {
 	factory := NewFactory()
 	cfg := factory.CreateDefaultConfig()
-	assert.NoError(t, confmap.New().Unmarshal(&cfg))
+	require.NoError(t, confmap.New().Unmarshal(&cfg))
 	assert.Equal(t, factory.CreateDefaultConfig(), cfg)
 }
 
@@ -35,7 +35,7 @@ func TestUnmarshalConfig(t *testing.T) {
 	require.NoError(t, err)
 	factory := NewFactory()
 	cfg := factory.CreateDefaultConfig()
-	assert.NoError(t, cm.Unmarshal(&cfg))
+	require.NoError(t, cm.Unmarshal(&cfg))
 	assert.Equal(t,
 		&Config{
 			TimeoutConfig: exporterhelper.TimeoutConfig{

exporter/otlpexporter/factory_test.go

@@ -27,7 +27,7 @@ func TestCreateDefaultConfig(t *testing.T) {
 	factory := NewFactory()
 	cfg := factory.CreateDefaultConfig()
 	assert.NotNil(t, cfg, "failed to create default config")
-	assert.NoError(t, componenttest.CheckConfigStruct(cfg))
+	require.NoError(t, componenttest.CheckConfigStruct(cfg))
 	ocfg, ok := factory.CreateDefaultConfig().(*Config)
 	assert.True(t, ok)
 	assert.Equal(t, configretry.NewDefaultBackOffConfig(), ocfg.RetryConfig)
@@ -168,13 +168,13 @@ func TestCreateTracesExporter(t *testing.T) {
 			factory := NewFactory()
 			set := exportertest.NewNopSettings()
 			consumer, err := factory.CreateTracesExporter(context.Background(), set, tt.config)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.NotNil(t, consumer)
 			err = consumer.Start(context.Background(), componenttest.NewNopHost())
 			if tt.mustFailOnStart {
-				assert.Error(t, err)
+				require.Error(t, err)
 			} else {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 			}
 			// Shutdown is called even when Start fails
 			err = consumer.Shutdown(context.Background())

exporter/otlpexporter/otlp_test.go

@@ -263,14 +263,14 @@ func TestSendTraces(t *testing.T) {
 	}()
 
 	host := componenttest.NewNopHost()
-	assert.NoError(t, exp.Start(context.Background(), host))
+	require.NoError(t, exp.Start(context.Background(), host))
 
 	// Ensure that initially there is no data in the receiver.
 	assert.EqualValues(t, 0, rcv.requestCount.Load())
 
 	// Send empty trace.
 	td := ptrace.NewTraces()
-	assert.NoError(t, exp.ConsumeTraces(context.Background(), td))
+	require.NoError(t, exp.ConsumeTraces(context.Background(), td))
 
 	// Wait until it is received.
 	assert.Eventually(t, func() bool {
@@ -284,7 +284,7 @@ func TestSendTraces(t *testing.T) {
 	td = testdata.GenerateTraces(2)
 
 	err = exp.ConsumeTraces(context.Background(), td)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	// Wait until it is received.
 	assert.Eventually(t, func() bool {
@@ -317,7 +317,7 @@ func TestSendTraces(t *testing.T) {
 	td = testdata.GenerateTraces(2)
 
 	err = exp.ConsumeTraces(context.Background(), td)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Len(t, observed.FilterLevelExact(zap.WarnLevel).All(), 1)
 	assert.Contains(t, observed.FilterLevelExact(zap.WarnLevel).All()[0].Message, "Partial success")
 }
@@ -375,14 +375,14 @@ func TestSendTracesWhenEndpointHasHttpScheme(t *testing.T) {
 			}()
 
 			host := componenttest.NewNopHost()
-			assert.NoError(t, exp.Start(context.Background(), host))
+			require.NoError(t, exp.Start(context.Background(), host))
 
 			// Ensure that initially there is no data in the receiver.
 			assert.EqualValues(t, 0, rcv.requestCount.Load())
 
 			// Send empty trace.
 			td := ptrace.NewTraces()
-			assert.NoError(t, exp.ConsumeTraces(context.Background(), td))
+			require.NoError(t, exp.ConsumeTraces(context.Background(), td))
 
 			// Wait until it is received.
 			assert.Eventually(t, func() bool {
@@ -435,14 +435,14 @@ func TestSendMetrics(t *testing.T) {
 
 	host := componenttest.NewNopHost()
 
-	assert.NoError(t, exp.Start(context.Background(), host))
+	require.NoError(t, exp.Start(context.Background(), host))
 
 	// Ensure that initially there is no data in the receiver.
 	assert.EqualValues(t, 0, rcv.requestCount.Load())
 
 	// Send empty metric.
 	md := pmetric.NewMetrics()
-	assert.NoError(t, exp.ConsumeMetrics(context.Background(), md))
+	require.NoError(t, exp.ConsumeMetrics(context.Background(), md))
 
 	// Wait until it is received.
 	assert.Eventually(t, func() bool {
@@ -456,7 +456,7 @@ func TestSendMetrics(t *testing.T) {
 	md = testdata.GenerateMetrics(2)
 
 	err = exp.ConsumeMetrics(context.Background(), md)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	// Wait until it is received.
 	assert.Eventually(t, func() bool {
@@ -482,7 +482,7 @@ func TestSendMetrics(t *testing.T) {
 	md = testdata.GenerateMetrics(2)
 
 	err = exp.ConsumeMetrics(context.Background(), md)
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	rcv.setExportError(nil)
 
@@ -498,7 +498,7 @@ func TestSendMetrics(t *testing.T) {
 
 	// Send two metrics.
 	md = testdata.GenerateMetrics(2)
-	assert.NoError(t, exp.ConsumeMetrics(context.Background(), md))
+	require.NoError(t, exp.ConsumeMetrics(context.Background(), md))
 	assert.Len(t, observed.FilterLevelExact(zap.WarnLevel).All(), 1)
 	assert.Contains(t, observed.FilterLevelExact(zap.WarnLevel).All()[0].Message, "Partial success")
 }
@@ -533,24 +533,24 @@ func TestSendTraceDataServerDownAndUp(t *testing.T) {
 
 	host := componenttest.NewNopHost()
 
-	assert.NoError(t, exp.Start(context.Background(), host))
+	require.NoError(t, exp.Start(context.Background(), host))
 
 	// A trace with 2 spans.
 	td := testdata.GenerateTraces(2)
 	ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second)
-	assert.Error(t, exp.ConsumeTraces(ctx, td))
+	require.Error(t, exp.ConsumeTraces(ctx, td))
 	assert.EqualValues(t, context.DeadlineExceeded, ctx.Err())
 	cancel()
 
 	ctx, cancel = context.WithTimeout(context.Background(), 1*time.Second)
-	assert.Error(t, exp.ConsumeTraces(ctx, td))
+	require.Error(t, exp.ConsumeTraces(ctx, td))
 	assert.EqualValues(t, context.DeadlineExceeded, ctx.Err())
 	cancel()
 
 	startServerAndMakeRequest(t, exp, td, ln)
 
 	ctx, cancel = context.WithTimeout(context.Background(), 1*time.Second)
-	assert.Error(t, exp.ConsumeTraces(ctx, td))
+	require.Error(t, exp.ConsumeTraces(ctx, td))
 	assert.EqualValues(t, context.DeadlineExceeded, ctx.Err())
 	cancel()
 
@@ -561,7 +561,7 @@ func TestSendTraceDataServerDownAndUp(t *testing.T) {
 	startServerAndMakeRequest(t, exp, td, ln)
 
 	ctx, cancel = context.WithTimeout(context.Background(), 1*time.Second)
-	assert.Error(t, exp.ConsumeTraces(ctx, td))
+	require.Error(t, exp.ConsumeTraces(ctx, td))
 	assert.EqualValues(t, context.DeadlineExceeded, ctx.Err())
 	cancel()
 }
@@ -590,7 +590,7 @@ func TestSendTraceDataServerStartWhileRequest(t *testing.T) {
 
 	host := componenttest.NewNopHost()
 
-	assert.NoError(t, exp.Start(context.Background(), host))
+	require.NoError(t, exp.Start(context.Background(), host))
 
 	// A trace with 2 spans.
 	td := testdata.GenerateTraces(2)
@@ -610,7 +610,7 @@ func TestSendTraceDataServerStartWhileRequest(t *testing.T) {
 	case <-ctx.Done():
 		t.Fail()
 	case <-done:
-		assert.NoError(t, ctx.Err())
+		require.NoError(t, ctx.Err())
 	}
 	cancel()
 }
@@ -641,12 +641,12 @@ func TestSendTracesOnResourceExhaustion(t *testing.T) {
 	}()
 
 	host := componenttest.NewNopHost()
-	assert.NoError(t, exp.Start(context.Background(), host))
+	require.NoError(t, exp.Start(context.Background(), host))
 
 	assert.EqualValues(t, 0, rcv.requestCount.Load())
 
 	td := ptrace.NewTraces()
-	assert.NoError(t, exp.ConsumeTraces(context.Background(), td))
+	require.NoError(t, exp.ConsumeTraces(context.Background(), td))
 
 	assert.Never(t, func() bool {
 		return rcv.requestCount.Load() > 1
@@ -660,7 +660,7 @@ func TestSendTracesOnResourceExhaustion(t *testing.T) {
 	})
 	rcv.setExportError(st.Err())
 
-	assert.NoError(t, exp.ConsumeTraces(context.Background(), td))
+	require.NoError(t, exp.ConsumeTraces(context.Background(), td))
 
 	assert.Eventually(t, func() bool {
 		return rcv.requestCount.Load() > 1
@@ -679,7 +679,7 @@ func startServerAndMakeRequest(t *testing.T, exp exporter.Traces, td ptrace.Trac
 
 	// Resend the request, this should succeed.
 	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
-	assert.NoError(t, exp.ConsumeTraces(ctx, td))
+	require.NoError(t, exp.ConsumeTraces(ctx, td))
 	cancel()
 
 	// Wait until it is received.
@@ -729,14 +729,14 @@ func TestSendLogData(t *testing.T) {
 
 	host := componenttest.NewNopHost()
 
-	assert.NoError(t, exp.Start(context.Background(), host))
+	require.NoError(t, exp.Start(context.Background(), host))
 
 	// Ensure that initially there is no data in the receiver.
 	assert.EqualValues(t, 0, rcv.requestCount.Load())
 
 	// Send empty request.
 	ld := plog.NewLogs()
-	assert.NoError(t, exp.ConsumeLogs(context.Background(), ld))
+	require.NoError(t, exp.ConsumeLogs(context.Background(), ld))
 
 	// Wait until it is received.
 	assert.Eventually(t, func() bool {
@@ -750,7 +750,7 @@ func TestSendLogData(t *testing.T) {
 	ld = testdata.GenerateLogs(2)
 
 	err = exp.ConsumeLogs(context.Background(), ld)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	// Wait until it is received.
 	assert.Eventually(t, func() bool {
@@ -773,7 +773,7 @@ func TestSendLogData(t *testing.T) {
 	ld = testdata.GenerateLogs(2)
 
 	err = exp.ConsumeLogs(context.Background(), ld)
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	rcv.setExportError(nil)
 
@@ -791,7 +791,7 @@ func TestSendLogData(t *testing.T) {
 	ld = testdata.GenerateLogs(2)
 
 	err = exp.ConsumeLogs(context.Background(), ld)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Len(t, observed.FilterLevelExact(zap.WarnLevel).All(), 1)
 	assert.Contains(t, observed.FilterLevelExact(zap.WarnLevel).All()[0].Message, "Partial success")
 }

exporter/otlphttpexporter/config_test.go

@@ -24,7 +24,7 @@ import (
 func TestUnmarshalDefaultConfig(t *testing.T) {
 	factory := NewFactory()
 	cfg := factory.CreateDefaultConfig()
-	assert.NoError(t, confmap.New().Unmarshal(&cfg))
+	require.NoError(t, confmap.New().Unmarshal(&cfg))
 	assert.Equal(t, factory.CreateDefaultConfig(), cfg)
 	// Default/Empty config is invalid.
 	assert.Error(t, component.ValidateConfig(cfg))
@@ -35,7 +35,7 @@ func TestUnmarshalConfig(t *testing.T) {
 	require.NoError(t, err)
 	factory := NewFactory()
 	cfg := factory.CreateDefaultConfig()
-	assert.NoError(t, cm.Unmarshal(&cfg))
+	require.NoError(t, cm.Unmarshal(&cfg))
 	assert.Equal(t,
 		&Config{
 			RetryConfig: configretry.BackOffConfig{
@@ -122,7 +122,7 @@ func TestUnmarshalEncoding(t *testing.T) {
 			if tt.shouldError {
 				assert.Error(t, err)
 			} else {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 				assert.Equal(t, tt.expected, encoding)
 			}
 		})

exporter/otlphttpexporter/factory_test.go

@@ -25,7 +25,7 @@ func TestCreateDefaultConfig(t *testing.T) {
 	factory := NewFactory()
 	cfg := factory.CreateDefaultConfig()
 	assert.NotNil(t, cfg, "failed to create default config")
-	assert.NoError(t, componenttest.CheckConfigStruct(cfg))
+	require.NoError(t, componenttest.CheckConfigStruct(cfg))
 	ocfg, ok := factory.CreateDefaultConfig().(*Config)
 	assert.True(t, ok)
 	assert.Equal(t, "", ocfg.ClientConfig.Endpoint)
@@ -181,11 +181,11 @@ func TestCreateTracesExporter(t *testing.T) {
 				assert.Error(t, err)
 				return
 			}
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.NotNil(t, consumer)
 			err = consumer.Start(context.Background(), componenttest.NewNopHost())
 			if tt.mustFailOnStart {
-				assert.Error(t, err)
+				require.Error(t, err)
 			}
 
 			err = consumer.Shutdown(context.Background())

exporter/otlphttpexporter/otlp_test.go

@@ -231,7 +231,7 @@ func TestErrorResponses(t *testing.T) {
 			// generate traces
 			traces := ptrace.NewTraces()
 			err = exp.ConsumeTraces(context.Background(), traces)
-			assert.Error(t, err)
+			require.Error(t, err)
 
 			if test.isPermErr {
 				assert.True(t, consumererror.IsPermanent(err))
@@ -769,7 +769,7 @@ func TestPartialSuccess_longContentLengthHeader(t *testing.T) {
 				// No real error happens for long content length, so the partial
 				// success is handled as success with a warning.
 				err = handlePartialSuccessResponse(resp, handler)
-				assert.NoError(t, err)
+				require.NoError(t, err)
 				assert.Len(t, observed.FilterLevelExact(zap.WarnLevel).All(), 1)
 				assert.Contains(t, observed.FilterLevelExact(zap.WarnLevel).All()[0].Message, "Partial success")
 			})

extension/auth/authtest/mock_clientauth_test.go

@@ -9,6 +9,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 	"google.golang.org/grpc/credentials"
 )
 
@@ -20,7 +21,7 @@ func TestNilStartAndShutdown(t *testing.T) {
 	origCtx := context.Background()
 
 	err := m.Start(origCtx, nil)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	err = m.Shutdown(origCtx)
 	assert.NoError(t, err)
@@ -64,7 +65,7 @@ func TestMockRoundTripper(t *testing.T) {
 				return
 			}
 			assert.NotNil(t, tripper)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			// check if the resultant tripper is indeed the one provided
 			_, ok := tripper.(*customRoundTripper)
 			assert.True(t, ok)
@@ -119,7 +120,7 @@ func TestMockPerRPCCredential(t *testing.T) {
 				return
 			}
 			assert.NotNil(t, credential)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			// check if the resultant tripper is indeed the one provided
 			_, ok := credential.(*customPerRPCCredentials)
 			assert.True(t, ok)

extension/extension_test.go

@@ -8,6 +8,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 
 	"go.opentelemetry.io/collector/component"
 )
@@ -35,7 +36,7 @@ func TestNewFactory(t *testing.T) {
 
 	assert.Equal(t, component.StabilityLevelDevelopment, factory.ExtensionStability())
 	ext, err := factory.CreateExtension(context.Background(), Settings{}, &defaultCfg)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Same(t, nopExtensionInstance, ext)
 }
 
@@ -69,7 +70,7 @@ func TestMakeFactoryMap(t *testing.T) {
 				assert.Error(t, err)
 				return
 			}
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.Equal(t, tt.out, out)
 		})
 	}

extension/memorylimiterextension/factory_test.go

@@ -38,10 +38,10 @@ func TestCreateExtension(t *testing.T) {
 	pCfg.CheckInterval = 100 * time.Millisecond
 
 	tp, err := factory.CreateExtension(context.Background(), extensiontest.NewNopSettings(), cfg)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.NotNil(t, tp)
 	// test if we can shutdown a monitoring routine that has not started
-	assert.ErrorIs(t, tp.Shutdown(context.Background()), memorylimiter.ErrShutdownNotStarted)
+	require.ErrorIs(t, tp.Shutdown(context.Background()), memorylimiter.ErrShutdownNotStarted)
 	assert.NoError(t, tp.Start(context.Background(), componenttest.NewNopHost()))
 
 	assert.NoError(t, tp.Shutdown(context.Background()))

extension/memorylimiterextension/memorylimiter_test.go

@@ -10,6 +10,7 @@ import (
 	"time"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 	"go.uber.org/zap"
 
 	"go.opentelemetry.io/collector/component"
@@ -82,7 +83,7 @@ func TestMemoryPressureResponse(t *testing.T) {
 			if tt.expectError {
 				assert.True(t, mustRefuse)
 			} else {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 			}
 			assert.NoError(t, ml.Shutdown(ctx))
 		})

extension/zpagesextension/config_test.go

@@ -18,7 +18,7 @@ import (
 func TestUnmarshalDefaultConfig(t *testing.T) {
 	factory := NewFactory()
 	cfg := factory.CreateDefaultConfig()
-	assert.NoError(t, confmap.New().Unmarshal(&cfg))
+	require.NoError(t, confmap.New().Unmarshal(&cfg))
 	assert.Equal(t, factory.CreateDefaultConfig(), cfg)
 }
 
@@ -31,7 +31,7 @@ func TestUnmarshalConfig(t *testing.T) {
 	require.NoError(t, err)
 	factory := NewFactory()
 	cfg := factory.CreateDefaultConfig()
-	assert.NoError(t, cm.Unmarshal(&cfg))
+	require.NoError(t, cm.Unmarshal(&cfg))
 	assert.Equal(t,
 		&Config{
 			ServerConfig: confighttp.ServerConfig{

extension/zpagesextension/factory_test.go

@@ -25,7 +25,7 @@ func TestFactory_CreateDefaultConfig(t *testing.T) {
 	},
 		cfg)
 
-	assert.NoError(t, componenttest.CheckConfigStruct(cfg))
+	require.NoError(t, componenttest.CheckConfigStruct(cfg))
 	ext, err := createExtension(context.Background(), extensiontest.NewNopSettings(), cfg)
 	require.NoError(t, err)
 	require.NotNil(t, ext)

featuregate/registry_test.go

@@ -23,17 +23,17 @@ func TestRegistry(t *testing.T) {
 
 	const id = "foo"
 	g, err := r.Register(id, StageBeta, WithRegisterDescription("Test Gate"))
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	r.VisitAll(func(gate *Gate) {
 		assert.Equal(t, id, gate.ID())
 	})
 	assert.True(t, g.IsEnabled())
 
-	assert.NoError(t, r.Set(id, false))
+	require.NoError(t, r.Set(id, false))
 	assert.False(t, g.IsEnabled())
 
 	_, err = r.Register(id, StageBeta)
-	assert.ErrorIs(t, err, ErrAlreadyRegistered)
+	require.ErrorIs(t, err, ErrAlreadyRegistered)
 	assert.Panics(t, func() {
 		r.MustRegister(id, StageBeta)
 	})
@@ -41,20 +41,20 @@ func TestRegistry(t *testing.T) {
 
 func TestRegistryApplyError(t *testing.T) {
 	r := NewRegistry()
-	assert.Error(t, r.Set("foo", true))
+	require.Error(t, r.Set("foo", true))
 	r.MustRegister("bar", StageAlpha)
 
-	assert.Error(t, r.Set("foo", true))
+	require.Error(t, r.Set("foo", true))
 	_, err := r.Register("foo", StageStable)
-	assert.Error(t, err)
+	require.Error(t, err)
-	assert.Error(t, r.Set("foo", true))
+	require.Error(t, r.Set("foo", true))
 	r.MustRegister("foo", StageStable, WithRegisterToVersion("v1.0.0"))
-	assert.Error(t, r.Set("foo", false))
+	require.Error(t, r.Set("foo", false))
 
-	assert.Error(t, r.Set("deprecated", true))
+	require.Error(t, r.Set("deprecated", true))
 	_, err = r.Register("deprecated", StageDeprecated)
-	assert.Error(t, err)
+	require.Error(t, err)
-	assert.Error(t, r.Set("deprecated", true))
+	require.Error(t, r.Set("deprecated", true))
 	r.MustRegister("deprecated", StageDeprecated, WithRegisterToVersion("v1.0.0"))
 	assert.Error(t, r.Set("deprecated", true))
 }
@@ -63,7 +63,7 @@ func TestRegistryApply(t *testing.T) {
 	r := NewRegistry()
 	fooGate := r.MustRegister("foo", StageAlpha, WithRegisterDescription("Test Gate"))
 	assert.False(t, fooGate.IsEnabled())
-	assert.NoError(t, r.Set(fooGate.ID(), true))
+	require.NoError(t, r.Set(fooGate.ID(), true))
 	assert.True(t, fooGate.IsEnabled())
 }
 
@@ -195,7 +195,7 @@ func TestRegisterGateLifecycle(t *testing.T) {
 			r.MustRegister("existing.gate", StageBeta)
 			if tc.shouldErr {
 				_, err := r.Register(tc.id, tc.stage, tc.opts...)
-				assert.Error(t, err)
+				require.Error(t, err)
 				assert.Panics(t, func() {
 					r.MustRegister(tc.id, tc.stage, tc.opts...)
 				})

filter/config_test.go

@@ -46,7 +46,7 @@ func TestConfig(t *testing.T) {
 			assert.Equal(t, expCfg, actualCfg)
 
 			for _, cfg := range actualCfg {
-				assert.NoError(t, cfg.Validate())
+				require.NoError(t, cfg.Validate())
 			}
 			fs := CreateFilter(actualCfg)
 			assert.NotNil(t, fs)
@@ -68,7 +68,7 @@ func TestMatches(t *testing.T) {
 	}
 
 	for _, c := range cfg {
-		assert.NoError(t, c.Validate())
+		require.NoError(t, c.Validate())
 	}
 	fs := CreateFilter(cfg)
 

internal/cgroups/cgroups_test.go

@@ -32,6 +32,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestNewCGroups(t *testing.T) {
@@ -50,7 +51,7 @@ func TestNewCGroups(t *testing.T) {
 
 	cgroups, err := NewCGroups(cgroupsProcMountInfoPath, cgroupsProcCGroupPath)
 	assert.Equal(t, len(testTable), len(cgroups))
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	for _, tt := range testTable {
 		cgroup, exists := cgroups[tt.subsys]
@@ -113,7 +114,7 @@ func TestCGroupsMemoryQuota(t *testing.T) {
 	quota, defined, err := cgroups.MemoryQuota()
 	assert.Equal(t, int64(-1), quota, "nonexistent")
 	assert.False(t, defined, "nonexistent")
-	assert.NoError(t, err, "nonexistent")
+	require.NoError(t, err, "nonexistent")
 
 	for _, tt := range testTable {
 		cgroupPath := filepath.Join(testDataCGroupsPath, tt.name)
@@ -209,7 +210,7 @@ func TestCGroupsMemoryQuotaV2(t *testing.T) {
 	quota, defined, err := memoryQuotaV2("nonexistent", "nonexistent")
 	assert.Equal(t, int64(-1), quota, "nonexistent")
 	assert.False(t, defined, "nonexistent")
-	assert.NoError(t, err, "nonexistent")
+	require.NoError(t, err, "nonexistent")
 
 	cgroupBasePath := filepath.Join(testDataCGroupsPath, "v2")
 	for _, tt := range testTable {

internal/cgroups/mountpoint_test.go

@@ -31,6 +31,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestNewMountPointFromLine(t *testing.T) {
@@ -90,7 +91,7 @@ func TestNewMountPointFromLineErr(t *testing.T) {
 	for i, line := range linesWithInvalidIDs {
 		mountPoint, err := NewMountPointFromLine(line)
 		assert.Nil(t, mountPoint, "[%d] %q", i, line)
-		assert.Error(t, err, line)
+		require.Error(t, err, line)
 	}
 
 	linesWithInvalidFields := []string{
@@ -115,7 +116,7 @@ func TestMountPointTranslate(t *testing.T) {
 	cgroupMountPoint, err := NewMountPointFromLine(line)
 
 	assert.NotNil(t, cgroupMountPoint)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	testTable := []struct {
 		name            string
@@ -151,7 +152,7 @@ func TestMountPointTranslateError(t *testing.T) {
 	cgroupMountPoint, err := NewMountPointFromLine(line)
 
 	assert.NotNil(t, cgroupMountPoint)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	inaccessiblePaths := []string{
 		"/",

internal/e2e/opaque_test.go

@@ -7,6 +7,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 
 	"go.opentelemetry.io/collector/config/configopaque"
 	"go.opentelemetry.io/collector/confmap"
@@ -24,7 +25,7 @@ var example = TestStruct{
 
 func TestConfMapMarshalConfigOpaque(t *testing.T) {
 	conf := confmap.New()
-	assert.NoError(t, conf.Marshal(example))
+	require.NoError(t, conf.Marshal(example))
 	assert.Equal(t, "[REDACTED]", conf.Get("opaque"))
 	assert.Equal(t, "plain", conf.Get("plain"))
 }

internal/e2e/otlphttp_test.go

@@ -62,7 +62,7 @@ func TestTraceNoBackend(t *testing.T) {
 func TestTraceInvalidUrl(t *testing.T) {
 	exp := startTracesExporter(t, "http:/\\//this_is_an/*/invalid_url", "")
 	td := testdata.GenerateTraces(1)
-	assert.Error(t, exp.ConsumeTraces(context.Background(), td))
+	require.Error(t, exp.ConsumeTraces(context.Background(), td))
 
 	exp = startTracesExporter(t, "", "http:/\\//this_is_an/*/invalid_url")
 	td = testdata.GenerateTraces(1)
@@ -111,7 +111,7 @@ func TestTraceRoundTrip(t *testing.T) {
 			exp := startTracesExporter(t, tt.baseURL, tt.overrideURL)
 
 			td := testdata.GenerateTraces(1)
-			assert.NoError(t, exp.ConsumeTraces(context.Background(), td))
+			require.NoError(t, exp.ConsumeTraces(context.Background(), td))
 			require.Eventually(t, func() bool {
 				return sink.SpanCount() > 0
 			}, 1*time.Second, 10*time.Millisecond)
@@ -164,7 +164,7 @@ func TestMetricsRoundTrip(t *testing.T) {
 			exp := startMetricsExporter(t, tt.baseURL, tt.overrideURL)
 
 			md := testdata.GenerateMetrics(1)
-			assert.NoError(t, exp.ConsumeMetrics(context.Background(), md))
+			require.NoError(t, exp.ConsumeMetrics(context.Background(), md))
 			require.Eventually(t, func() bool {
 				return sink.DataPointCount() > 0
 			}, 1*time.Second, 10*time.Millisecond)
@@ -217,7 +217,7 @@ func TestLogsRoundTrip(t *testing.T) {
 			exp := startLogsExporter(t, tt.baseURL, tt.overrideURL)
 
 			md := testdata.GenerateLogs(1)
-			assert.NoError(t, exp.ConsumeLogs(context.Background(), md))
+			require.NoError(t, exp.ConsumeLogs(context.Background(), md))
 			require.Eventually(t, func() bool {
 				return sink.LogRecordCount() > 0
 			}, 1*time.Second, 10*time.Millisecond)

internal/fanoutconsumer/logs_test.go

@@ -9,6 +9,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 
 	"go.opentelemetry.io/collector/consumer"
 	"go.opentelemetry.io/collector/consumer/consumertest"
@@ -221,7 +222,7 @@ func TestLogsWhenErrors(t *testing.T) {
 	ld := testdata.GenerateLogs(1)
 
 	for i := 0; i < 2; i++ {
-		assert.Error(t, lfc.ConsumeLogs(context.Background(), ld))
+		require.Error(t, lfc.ConsumeLogs(context.Background(), ld))
 	}
 
 	assert.Equal(t, ld, p3.AllLogs()[0])

internal/fanoutconsumer/metrics_test.go

@@ -9,6 +9,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 
 	"go.opentelemetry.io/collector/consumer"
 	"go.opentelemetry.io/collector/consumer/consumertest"
@@ -221,7 +222,7 @@ func TestMetricsWhenErrors(t *testing.T) {
 	md := testdata.GenerateMetrics(1)
 
 	for i := 0; i < 2; i++ {
-		assert.Error(t, mfc.ConsumeMetrics(context.Background(), md))
+		require.Error(t, mfc.ConsumeMetrics(context.Background(), md))
 	}
 
 	assert.Equal(t, md, p3.AllMetrics()[0])

internal/fanoutconsumer/profiles_test.go

@@ -9,6 +9,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 
 	"go.opentelemetry.io/collector/consumer"
 	"go.opentelemetry.io/collector/consumer/consumerprofiles"
@@ -223,7 +224,7 @@ func TestProfilesWhenErrors(t *testing.T) {
 	td := testdata.GenerateProfiles(1)
 
 	for i := 0; i < 2; i++ {
-		assert.Error(t, tfc.ConsumeProfiles(context.Background(), td))
+		require.Error(t, tfc.ConsumeProfiles(context.Background(), td))
 	}
 
 	assert.Equal(t, td, p3.AllProfiles()[0])

internal/fanoutconsumer/traces_test.go

@@ -9,6 +9,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 
 	"go.opentelemetry.io/collector/consumer"
 	"go.opentelemetry.io/collector/consumer/consumertest"
@@ -222,7 +223,7 @@ func TestTracesWhenErrors(t *testing.T) {
 	td := testdata.GenerateTraces(1)
 
 	for i := 0; i < 2; i++ {
-		assert.Error(t, tfc.ConsumeTraces(context.Background(), td))
+		require.Error(t, tfc.ConsumeTraces(context.Background(), td))
 	}
 
 	assert.Equal(t, td, p3.AllTraces()[0])

internal/iruntime/mem_info_test.go

@@ -7,10 +7,11 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestReadMemInfo(t *testing.T) {
 	vmStat, err := readMemInfo()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Positive(t, vmStat)
 }

internal/sharedcomponent/sharedcomponent_test.go

@@ -38,7 +38,7 @@ func TestNewSharedComponentsCreateError(t *testing.T) {
 		func() (*baseComponent, error) { return nil, myErr },
 		newNopTelemetrySettings(),
 	)
-	assert.ErrorIs(t, err, myErr)
+	require.ErrorIs(t, err, myErr)
 	assert.Empty(t, comps.components)
 }
 
@@ -64,7 +64,7 @@ func TestSharedComponentsLoadOrStore(t *testing.T) {
 	assert.Same(t, got, gotSecond)
 
 	// Shutdown nop will remove
-	assert.NoError(t, got.Shutdown(context.Background()))
+	require.NoError(t, got.Shutdown(context.Background()))
 	assert.Empty(t, comps.components)
 	gotThird, err := comps.LoadOrStore(
 		id,
@@ -99,13 +99,13 @@ func TestSharedComponent(t *testing.T) {
 	assert.Equal(t, wantErr, got.Start(context.Background(), componenttest.NewNopHost()))
 	assert.Equal(t, 1, calledStart)
 	// Second time is not called anymore.
-	assert.NoError(t, got.Start(context.Background(), componenttest.NewNopHost()))
+	require.NoError(t, got.Start(context.Background(), componenttest.NewNopHost()))
 	assert.Equal(t, 1, calledStart)
 	// first time, shutdown is called.
 	assert.Equal(t, wantErr, got.Shutdown(context.Background()))
 	assert.Equal(t, 1, calledStop)
 	// Second time is not called anymore.
-	assert.NoError(t, got.Shutdown(context.Background()))
+	require.NoError(t, got.Shutdown(context.Background()))
 	assert.Equal(t, 1, calledStop)
 }
 

otelcol/buffered_core_test.go

@@ -102,6 +102,6 @@ func Test_bufferedCore_TakeLogs(t *testing.T) {
 	assert.Equal(t, expected, bc.TakeLogs())
 	assert.Nil(t, bc.logs)
 
-	assert.Error(t, bc.Write(e, fields))
+	require.Error(t, bc.Write(e, fields))
 	assert.Nil(t, bc.TakeLogs())
 }

otelcol/collector_test.go

@@ -165,7 +165,7 @@ func (e statusWatcherExtension) ComponentStatusChanged(source *componentstatus.I
 
 func TestComponentStatusWatcher(t *testing.T) {
 	factories, err := nopFactories()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	// Use a processor factory that creates "unhealthy" processor: one that
 	// always reports StatusRecoverableError after successful Start.

otelcol/internal/grpclog/logger_test.go

@@ -7,6 +7,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 	"go.uber.org/zap"
 	"go.uber.org/zap/zapcore"
 	"google.golang.org/grpc/grpclog"
@@ -65,7 +66,7 @@ func TestGRPCLogger(t *testing.T) {
 
 			// create new collector zap logger
 			logger, err := test.cfg.Build(hook)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 
 			// create GRPCLogger
 			glogger := SetLogger(logger, test.cfg.Level.Level())
@@ -77,7 +78,7 @@ func TestGRPCLogger(t *testing.T) {
 			assert.Equal(t, obsInfo, test.infoLogged)
 			assert.Equal(t, obsWarn, test.warnLogged)
 			// match the file name and line number of Warning() call above
-			assert.Contains(t, callerInfo, "internal/grpclog/logger_test.go:76")
+			assert.Contains(t, callerInfo, "internal/grpclog/logger_test.go:77")
 		})
 	}
 }

otelcol/otelcoltest/config_test.go

@@ -16,7 +16,7 @@ import (
 
 func TestLoadConfig(t *testing.T) {
 	factories, err := NopFactories()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	cfg, err := LoadConfig(filepath.Join("testdata", "config.yaml"), factories)
 	require.NoError(t, err)
@@ -61,7 +61,7 @@ func TestLoadConfig(t *testing.T) {
 
 func TestLoadConfigAndValidate(t *testing.T) {
 	factories, err := NopFactories()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	cfgValidate, errValidate := LoadConfigAndValidate(filepath.Join("testdata", "config.yaml"), factories)
 	require.NoError(t, errValidate)

otelcol/unmarshaler_test.go

@@ -19,7 +19,7 @@ import (
 
 func TestUnmarshalEmpty(t *testing.T) {
 	factories, err := nopFactories()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	_, err = unmarshal(confmap.New(), factories)
 	assert.NoError(t, err)
@@ -27,7 +27,7 @@ func TestUnmarshalEmpty(t *testing.T) {
 
 func TestUnmarshalEmptyAllSections(t *testing.T) {
 	factories, err := nopFactories()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	conf := confmap.NewFromStringMap(map[string]any{
 		"receivers":  nil,
@@ -38,7 +38,7 @@ func TestUnmarshalEmptyAllSections(t *testing.T) {
 		"service":    nil,
 	})
 	cfg, err := unmarshal(conf, factories)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	zapProdCfg := zap.NewProductionConfig()
 	assert.Equal(t, telemetry.LogsConfig{
@@ -61,7 +61,7 @@ func TestUnmarshalEmptyAllSections(t *testing.T) {
 
 func TestUnmarshalUnknownTopLevel(t *testing.T) {
 	factories, err := nopFactories()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	conf := confmap.NewFromStringMap(map[string]any{
 		"unknown_section": nil,

pdata/internal/data/profileid_test.go

@@ -7,6 +7,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestProfileID(t *testing.T) {
@@ -26,13 +27,13 @@ func TestProfileIDMarshal(t *testing.T) {
 	tid := ProfileID([16]byte{})
 	n, err := tid.MarshalTo(buf)
 	assert.EqualValues(t, 0, n)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	tid = [16]byte{0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78}
 	n, err = tid.MarshalTo(buf)
 	assert.EqualValues(t, 16, n)
 	assert.EqualValues(t, []byte{0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78}, buf[0:16])
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	_, err = tid.MarshalTo(buf[0:1])
 	assert.Error(t, err)
@@ -42,7 +43,7 @@ func TestProfileIDMarshalJSON(t *testing.T) {
 	tid := ProfileID([16]byte{})
 	json, err := tid.MarshalJSON()
 	assert.EqualValues(t, []byte(`""`), json)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	tid = [16]byte{0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78}
 	json, err = tid.MarshalJSON()
@@ -55,44 +56,44 @@ func TestProfileIDUnmarshal(t *testing.T) {
 
 	tid := ProfileID{}
 	err := tid.Unmarshal(buf[0:16])
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualValues(t, buf, tid)
 
 	err = tid.Unmarshal(buf[0:0])
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualValues(t, [16]byte{}, tid)
 
 	err = tid.Unmarshal(nil)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualValues(t, [16]byte{}, tid)
 }
 
 func TestProfileIDUnmarshalJSON(t *testing.T) {
 	tid := ProfileID([16]byte{})
 	err := tid.UnmarshalJSON([]byte(`""`))
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualValues(t, [16]byte{}, tid)
 
 	err = tid.UnmarshalJSON([]byte(`""""`))
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	tidBytes := [16]byte{0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78}
 	err = tid.UnmarshalJSON([]byte(`"12345678123456781234567812345678"`))
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualValues(t, tidBytes, tid)
 
 	err = tid.UnmarshalJSON([]byte(`12345678123456781234567812345678`))
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualValues(t, tidBytes, tid)
 
 	err = tid.UnmarshalJSON([]byte(`"nothex"`))
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	err = tid.UnmarshalJSON([]byte(`"1"`))
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	err = tid.UnmarshalJSON([]byte(`"123"`))
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	err = tid.UnmarshalJSON([]byte(`"`))
 	assert.Error(t, err)

pdata/internal/data/spanid_test.go

@@ -7,6 +7,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestSpanID(t *testing.T) {
@@ -26,11 +27,11 @@ func TestSpanIDMarshal(t *testing.T) {
 	sid := SpanID([8]byte{})
 	n, err := sid.MarshalTo(buf)
 	assert.EqualValues(t, 0, n)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	sid = [8]byte{1, 2, 3, 4, 5, 6, 7, 8}
 	n, err = sid.MarshalTo(buf)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualValues(t, 8, n)
 	assert.EqualValues(t, []byte{1, 2, 3, 4, 5, 6, 7, 8}, buf[0:8])
 
@@ -42,7 +43,7 @@ func TestSpanIDMarshalJSON(t *testing.T) {
 	sid := SpanID([8]byte{})
 	json, err := sid.MarshalJSON()
 	assert.EqualValues(t, []byte(`""`), json)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	sid = [8]byte{0x12, 0x23, 0xAD, 0x12, 0x23, 0xAD, 0x12, 0x23}
 	json, err = sid.MarshalJSON()
@@ -55,15 +56,15 @@ func TestSpanIDUnmarshal(t *testing.T) {
 
 	sid := SpanID{}
 	err := sid.Unmarshal(buf[0:8])
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualValues(t, [8]byte{0x12, 0x23, 0xAD, 0x12, 0x23, 0xAD, 0x12, 0x23}, sid)
 
 	err = sid.Unmarshal(buf[0:0])
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualValues(t, [8]byte{}, sid)
 
 	err = sid.Unmarshal(nil)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualValues(t, [8]byte{}, sid)
 
 	err = sid.Unmarshal(buf[0:3])
@@ -73,25 +74,25 @@ func TestSpanIDUnmarshal(t *testing.T) {
 func TestSpanIDUnmarshalJSON(t *testing.T) {
 	sid := SpanID{}
 	err := sid.UnmarshalJSON([]byte(`""`))
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualValues(t, [8]byte{}, sid)
 
 	err = sid.UnmarshalJSON([]byte(`"1234567812345678"`))
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualValues(t, [8]byte{0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78}, sid)
 
 	err = sid.UnmarshalJSON([]byte(`1234567812345678`))
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualValues(t, [8]byte{0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78}, sid)
 
 	err = sid.UnmarshalJSON([]byte(`"nothex"`))
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	err = sid.UnmarshalJSON([]byte(`"1"`))
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	err = sid.UnmarshalJSON([]byte(`"123"`))
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	err = sid.UnmarshalJSON([]byte(`"`))
 	assert.Error(t, err)

pdata/internal/data/traceid_test.go

@@ -7,6 +7,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestTraceID(t *testing.T) {
@@ -26,13 +27,13 @@ func TestTraceIDMarshal(t *testing.T) {
 	tid := TraceID([16]byte{})
 	n, err := tid.MarshalTo(buf)
 	assert.EqualValues(t, 0, n)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	tid = [16]byte{0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78}
 	n, err = tid.MarshalTo(buf)
 	assert.EqualValues(t, 16, n)
 	assert.EqualValues(t, []byte{0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78}, buf[0:16])
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	_, err = tid.MarshalTo(buf[0:1])
 	assert.Error(t, err)
@@ -42,7 +43,7 @@ func TestTraceIDMarshalJSON(t *testing.T) {
 	tid := TraceID([16]byte{})
 	json, err := tid.MarshalJSON()
 	assert.EqualValues(t, []byte(`""`), json)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	tid = [16]byte{0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78}
 	json, err = tid.MarshalJSON()
@@ -55,44 +56,44 @@ func TestTraceIDUnmarshal(t *testing.T) {
 
 	tid := TraceID{}
 	err := tid.Unmarshal(buf[0:16])
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualValues(t, buf, tid)
 
 	err = tid.Unmarshal(buf[0:0])
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualValues(t, [16]byte{}, tid)
 
 	err = tid.Unmarshal(nil)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualValues(t, [16]byte{}, tid)
 }
 
 func TestTraceIDUnmarshalJSON(t *testing.T) {
 	tid := TraceID([16]byte{})
 	err := tid.UnmarshalJSON([]byte(`""`))
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualValues(t, [16]byte{}, tid)
 
 	err = tid.UnmarshalJSON([]byte(`""""`))
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	tidBytes := [16]byte{0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78}
 	err = tid.UnmarshalJSON([]byte(`"12345678123456781234567812345678"`))
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualValues(t, tidBytes, tid)
 
 	err = tid.UnmarshalJSON([]byte(`12345678123456781234567812345678`))
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualValues(t, tidBytes, tid)
 
 	err = tid.UnmarshalJSON([]byte(`"nothex"`))
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	err = tid.UnmarshalJSON([]byte(`"1"`))
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	err = tid.UnmarshalJSON([]byte(`"123"`))
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	err = tid.UnmarshalJSON([]byte(`"`))
 	assert.Error(t, err)

pdata/internal/json/attribute_test.go

@@ -8,6 +8,7 @@ import (
 
 	jsoniter "github.com/json-iterator/go"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 
 	otlpcommon "go.opentelemetry.io/collector/pdata/internal/data/protogen/common/v1"
 )
@@ -151,7 +152,7 @@ func TestReadAttributeUnknownField(t *testing.T) {
 	defer jsoniter.ConfigFastest.ReturnIterator(iter)
 	value := ReadAttribute(iter)
 	//  unknown fields should not be an error
-	assert.NoError(t, iter.Error)
+	require.NoError(t, iter.Error)
 	assert.EqualValues(t, otlpcommon.KeyValue{}, value)
 }
 
@@ -162,7 +163,7 @@ func TestReadAttributeValueUnknownField(t *testing.T) {
 	defer jsoniter.ConfigFastest.ReturnIterator(iter)
 	value := ReadAttribute(iter)
 	//  unknown fields should not be an error
-	assert.NoError(t, iter.Error)
+	require.NoError(t, iter.Error)
 	assert.EqualValues(t, otlpcommon.KeyValue{Key: "test"}, value)
 }
 
@@ -172,7 +173,7 @@ func TestReadValueUnknownField(t *testing.T) {
 	defer jsoniter.ConfigFastest.ReturnIterator(iter)
 	value := &otlpcommon.AnyValue{}
 	ReadValue(iter, value)
-	assert.NoError(t, iter.Error)
+	require.NoError(t, iter.Error)
 	assert.EqualValues(t, &otlpcommon.AnyValue{}, value)
 }
 
@@ -192,7 +193,7 @@ func TestReadArrayUnknownField(t *testing.T) {
 	iter := jsoniter.ConfigFastest.BorrowIterator([]byte(jsonStr))
 	defer jsoniter.ConfigFastest.ReturnIterator(iter)
 	value := readArray(iter)
-	assert.NoError(t, iter.Error)
+	require.NoError(t, iter.Error)
 	assert.EqualValues(t, &otlpcommon.ArrayValue{}, value)
 }
 
@@ -201,7 +202,7 @@ func TestReadKvlistValueUnknownField(t *testing.T) {
 	iter := jsoniter.ConfigFastest.BorrowIterator([]byte(jsonStr))
 	defer jsoniter.ConfigFastest.ReturnIterator(iter)
 	value := readKvlistValue(iter)
-	assert.NoError(t, iter.Error)
+	require.NoError(t, iter.Error)
 	assert.EqualValues(t, &otlpcommon.KeyValueList{}, value)
 }
 
@@ -212,7 +213,7 @@ func TestReadArrayValueInvalidArrayValue(t *testing.T) {
 
 	value := &otlpcommon.AnyValue{}
 	ReadValue(iter, value)
-	assert.NoError(t, iter.Error)
+	require.NoError(t, iter.Error)
 	assert.EqualValues(t, &otlpcommon.AnyValue{
 		Value: &otlpcommon.AnyValue_ArrayValue{
 			ArrayValue: &otlpcommon.ArrayValue{},
@@ -227,7 +228,7 @@ func TestReadKvlistValueInvalidArrayValue(t *testing.T) {
 
 	value := &otlpcommon.AnyValue{}
 	ReadValue(iter, value)
-	assert.NoError(t, iter.Error)
+	require.NoError(t, iter.Error)
 	assert.EqualValues(t, &otlpcommon.AnyValue{
 		Value: &otlpcommon.AnyValue_KvlistValue{
 			KvlistValue: &otlpcommon.KeyValueList{},

pdata/internal/json/enum_test.go

@@ -8,6 +8,7 @@ import (
 
 	jsoniter "github.com/json-iterator/go"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestReadEnumValue(t *testing.T) {
@@ -67,7 +68,7 @@ func TestReadEnumValue(t *testing.T) {
 				assert.Error(t, iter.Error)
 				return
 			}
-			assert.NoError(t, iter.Error)
+			require.NoError(t, iter.Error)
 			assert.Equal(t, tt.want, val)
 		})
 	}

pdata/internal/json/number_test.go

@@ -8,6 +8,7 @@ import (
 
 	jsoniter "github.com/json-iterator/go"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestReadInt32(t *testing.T) {
@@ -57,7 +58,7 @@ func TestReadInt32(t *testing.T) {
 				assert.Error(t, iter.Error)
 				return
 			}
-			assert.NoError(t, iter.Error)
+			require.NoError(t, iter.Error)
 			assert.Equal(t, tt.want, val)
 		})
 	}
@@ -110,7 +111,7 @@ func TestReadUint32(t *testing.T) {
 				assert.Error(t, iter.Error)
 				return
 			}
-			assert.NoError(t, iter.Error)
+			require.NoError(t, iter.Error)
 			assert.Equal(t, tt.want, val)
 		})
 	}
@@ -163,7 +164,7 @@ func TestReadInt64(t *testing.T) {
 				assert.Error(t, iter.Error)
 				return
 			}
-			assert.NoError(t, iter.Error)
+			require.NoError(t, iter.Error)
 			assert.Equal(t, tt.want, val)
 		})
 	}
@@ -216,7 +217,7 @@ func TestReadUint64(t *testing.T) {
 				assert.Error(t, iter.Error)
 				return
 			}
-			assert.NoError(t, iter.Error)
+			require.NoError(t, iter.Error)
 			assert.Equal(t, tt.want, val)
 		})
 	}
@@ -269,7 +270,7 @@ func TestReadFloat64(t *testing.T) {
 				assert.Error(t, iter.Error)
 				return
 			}
-			assert.NoError(t, iter.Error)
+			require.NoError(t, iter.Error)
 			assert.InDelta(t, tt.want, val, 0.01)
 		})
 	}

pdata/internal/json/resource_test.go

@@ -8,6 +8,7 @@ import (
 
 	jsoniter "github.com/json-iterator/go"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 
 	otlpcommon "go.opentelemetry.io/collector/pdata/internal/data/protogen/common/v1"
 	otlpresource "go.opentelemetry.io/collector/pdata/internal/data/protogen/resource/v1"
@@ -60,7 +61,7 @@ func TestReadResource(t *testing.T) {
 			defer jsoniter.ConfigFastest.ReturnIterator(iter)
 			got := &otlpresource.Resource{}
 			ReadResource(iter, got)
-			assert.NoError(t, iter.Error)
+			require.NoError(t, iter.Error)
 			assert.Equal(t, tt.want, got)
 		})
 	}

pdata/internal/json/scope_test.go

@@ -8,6 +8,7 @@ import (
 
 	jsoniter "github.com/json-iterator/go"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 
 	otlpcommon "go.opentelemetry.io/collector/pdata/internal/data/protogen/common/v1"
 )
@@ -111,7 +112,7 @@ func TestReadScope(t *testing.T) {
 			defer jsoniter.ConfigFastest.ReturnIterator(iter)
 			got := &otlpcommon.InstrumentationScope{}
 			ReadScope(iter, got)
-			assert.NoError(t, iter.Error)
+			require.NoError(t, iter.Error)
 			assert.Equal(t, tt.want, got)
 		})
 	}

pdata/pcommon/map_test.go

@@ -7,6 +7,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 
 	"go.opentelemetry.io/collector/pdata/internal"
 	otlpcommon "go.opentelemetry.io/collector/pdata/internal/data/protogen/common/v1"
@@ -305,7 +306,7 @@ func TestMap_Range(t *testing.T) {
 		"k_empty":  nil,
 	}
 	am := NewMap()
-	assert.NoError(t, am.FromRaw(rawMap))
+	require.NoError(t, am.FromRaw(rawMap))
 	assert.Equal(t, 5, am.Len())
 
 	calls := 0
@@ -325,17 +326,17 @@ func TestMap_Range(t *testing.T) {
 
 func TestMap_FromRaw(t *testing.T) {
 	am := NewMap()
-	assert.NoError(t, am.FromRaw(map[string]any{}))
+	require.NoError(t, am.FromRaw(map[string]any{}))
 	assert.Equal(t, 0, am.Len())
 	am.PutEmpty("k")
 	assert.Equal(t, 1, am.Len())
 
-	assert.NoError(t, am.FromRaw(nil))
+	require.NoError(t, am.FromRaw(nil))
 	assert.Equal(t, 0, am.Len())
 	am.PutEmpty("k")
 	assert.Equal(t, 1, am.Len())
 
-	assert.NoError(t, am.FromRaw(map[string]any{
+	require.NoError(t, am.FromRaw(map[string]any{
 		"k_string": "123",
 		"k_int":    123,
 		"k_double": 1.23,

pdata/pcommon/value_test.go

@@ -224,11 +224,11 @@ func TestNilOrigSetValue(t *testing.T) {
 	assert.Equal(t, []byte{1, 2, 3}, av.Bytes().AsRaw())
 
 	av = NewValueEmpty()
-	assert.NoError(t, av.SetEmptyMap().FromRaw(map[string]any{"k": "v"}))
+	require.NoError(t, av.SetEmptyMap().FromRaw(map[string]any{"k": "v"}))
 	assert.Equal(t, map[string]any{"k": "v"}, av.Map().AsRaw())
 
 	av = NewValueEmpty()
-	assert.NoError(t, av.SetEmptySlice().FromRaw([]any{int64(1), "val"}))
+	require.NoError(t, av.SetEmptySlice().FromRaw([]any{int64(1), "val"}))
 	assert.Equal(t, []any{int64(1), "val"}, av.Slice().AsRaw())
 }
 
@@ -545,7 +545,7 @@ func TestNewValueFromRaw(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			actual := NewValueEmpty()
-			assert.NoError(t, actual.FromRaw(tt.input))
+			require.NoError(t, actual.FromRaw(tt.input))
 			assert.Equal(t, tt.expected, actual)
 		})
 	}