diff --git a/.golangci.yml b/.golangci.yml
index 5d117b872..a120acb4c 100644
--- a/.golangci.yml
+++ b/.golangci.yml
@@ -24,6 +24,9 @@ linters:
     - asciicheck  # Checks that all code identifiers does not have non-ASCII symbols in the name
     - nilnil # Checks that there is no simultaneous return of nil error and an nil value. ref: https://golangci-lint.run/usage/linters/#nilnil
     - cyclop # Checks function and package cyclomatic complexity. https://golangci-lint.run/usage/linters/#cyclop
+
+    # tests
+    - testifylint # Checks usage of github.com/stretchr/testify. https://golangci-lint.run/usage/linters/#testifylint
   settings:
     exhaustive:
       default-signifies-exhaustive: false
@@ -35,6 +38,17 @@ linters:
           disabled: true
     cyclop: # Lower cyclomatic complexity threshold after the max complexity is lowered
       max-complexity: 52
+    testifylint:
+      # Enable all checkers (https://github.com/Antonboom/testifylint#checkers).
+      # Default: false
+      enable-all: true
+      # Disable checkers by name
+      # (in addition to default
+      #   suite-thelper
+      # ).
+      # TODO: enable in follow-up
+      disable:
+        - require-error
   exclusions:
     generated: lax
     presets:
diff --git a/endpoint/crypto_test.go b/endpoint/crypto_test.go
index c03c00f19..fd910683d 100644
--- a/endpoint/crypto_test.go
+++ b/endpoint/crypto_test.go
@@ -69,7 +69,7 @@ func TestGenerateNonceSuccess(t *testing.T) {
 	// Test nonce length
 	decodedNonce, err := base64.StdEncoding.DecodeString(string(nonce))
 	require.NoError(t, err)
-	require.Equal(t, standardGcmNonceSize, len(decodedNonce))
+	require.Len(t, decodedNonce, standardGcmNonceSize)
 }
 
 func TestGenerateNonceError(t *testing.T) {
diff --git a/endpoint/domain_filter_test.go b/endpoint/domain_filter_test.go
index 5a4069a57..d252a8466 100644
--- a/endpoint/domain_filter_test.go
+++ b/endpoint/domain_filter_test.go
@@ -496,8 +496,8 @@ func TestPrepareFiltersStripsWhitespaceAndDotSuffix(t *testing.T) {
 
 func TestMatchFilterReturnsProperEmptyVal(t *testing.T) {
 	emptyFilters := []string{}
-	assert.Equal(t, true, matchFilter(emptyFilters, "somedomain.com", true))
-	assert.Equal(t, false, matchFilter(emptyFilters, "somedomain.com", false))
+	assert.True(t, matchFilter(emptyFilters, "somedomain.com", true))
+	assert.False(t, matchFilter(emptyFilters, "somedomain.com", false))
 }
 
 func TestDomainFilterIsConfigured(t *testing.T) {
@@ -813,8 +813,8 @@ func TestSimpleDomainFilterWithExclusion(t *testing.T) {
 					got = append(got, domain)
 				}
 			}
-			assert.Equal(t, len(got), len(tt.want))
-			assert.Equal(t, got, tt.want)
+			assert.Len(t, tt.want, len(got))
+			assert.Equal(t, tt.want, got)
 		})
 	}
 }
diff --git a/endpoint/endpoint_test.go b/endpoint/endpoint_test.go
index b1b7f519d..db2a0dbd1 100644
--- a/endpoint/endpoint_test.go
+++ b/endpoint/endpoint_test.go
@@ -201,13 +201,13 @@ func TestGetProviderSpecificProperty(t *testing.T) {
 
 	t.Run("key is not present in provider specific", func(t *testing.T) {
 		val, ok := e.GetProviderSpecificProperty("hello")
-		assert.Equal(t, false, ok)
+		assert.False(t, ok)
 		assert.Empty(t, val)
 	})
 
 	t.Run("key is present in provider specific", func(t *testing.T) {
 		val, ok := e.GetProviderSpecificProperty("name")
-		assert.Equal(t, true, ok)
+		assert.True(t, ok)
 		assert.NotEmpty(t, val)
 
 	})
diff --git a/endpoint/target_filter_test.go b/endpoint/target_filter_test.go
index 57690f7c1..01ffbf5cf 100644
--- a/endpoint/target_filter_test.go
+++ b/endpoint/target_filter_test.go
@@ -91,6 +91,6 @@ func TestTargetFilterMatchWithEmptyFilter(t *testing.T) {
 
 func TestMatchTargetFilterReturnsProperEmptyVal(t *testing.T) {
 	emptyFilters := []string{}
-	assert.Equal(t, true, matchFilter(emptyFilters, "sometarget.com", true))
-	assert.Equal(t, false, matchFilter(emptyFilters, "sometarget.com", false))
+	assert.True(t, matchFilter(emptyFilters, "sometarget.com", true))
+	assert.False(t, matchFilter(emptyFilters, "sometarget.com", false))
 }
diff --git a/internal/gen/docs/flags/main_test.go b/internal/gen/docs/flags/main_test.go
index 83b1ca3f3..684a35acd 100644
--- a/internal/gen/docs/flags/main_test.go
+++ b/internal/gen/docs/flags/main_test.go
@@ -74,7 +74,7 @@ func TestFlagsMdUpToDate(t *testing.T) {
 	actual, err := flags.generateMarkdownTable()
 	assert.NoError(t, err)
 	actual = actual + "\n"
-	assert.True(t, len(expected) == len(actual), "expected file '%s' to be up to date. execute 'make generate-flags-documentation", fileName)
+	assert.Len(t, actual, len(expected), "expected file '%s' to be up to date. execute 'make generate-flags-documentation", fileName)
 }
 
 func TestFlagsMdExtraFlagAdded(t *testing.T) {
diff --git a/internal/gen/docs/metrics/main_test.go b/internal/gen/docs/metrics/main_test.go
index 260ffad93..19e3b78af 100644
--- a/internal/gen/docs/metrics/main_test.go
+++ b/internal/gen/docs/metrics/main_test.go
@@ -25,6 +25,7 @@ import (
 
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 	"sigs.k8s.io/external-dns/pkg/metrics"
 )
 
@@ -63,7 +64,7 @@ func TestGenerateMarkdownTableWithSingleMetric(t *testing.T) {
 	))
 
 	got, err := generateMarkdownTable(reg, false)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	assert.Contains(t, got, "verified_aaaa_records")
 	assert.Contains(t, got, "This is just a test.")
diff --git a/pkg/apis/externaldns/types_test.go b/pkg/apis/externaldns/types_test.go
index 4f21e0f51..fe13da1a5 100644
--- a/pkg/apis/externaldns/types_test.go
+++ b/pkg/apis/externaldns/types_test.go
@@ -19,7 +19,6 @@ package externaldns
 import (
 	"os"
 	"regexp"
-	"strings"
 	"testing"
 	"time"
 
@@ -563,6 +562,6 @@ func TestPasswordsNotLogged(t *testing.T) {
 
 	s := cfg.String()
 
-	assert.False(t, strings.Contains(s, "pdns-api-key"))
-	assert.False(t, strings.Contains(s, "tsig-secret"))
+	assert.NotContains(t, s, "pdns-api-key")
+	assert.NotContains(t, s, "tsig-secret")
 }
diff --git a/pkg/apis/externaldns/validation/validation_test.go b/pkg/apis/externaldns/validation/validation_test.go
index 7f4f33c73..72dd45460 100644
--- a/pkg/apis/externaldns/validation/validation_test.go
+++ b/pkg/apis/externaldns/validation/validation_test.go
@@ -27,29 +27,29 @@ import (
 
 func TestValidateFlags(t *testing.T) {
 	cfg := newValidConfig(t)
-	assert.NoError(t, ValidateConfig(cfg))
+	require.NoError(t, ValidateConfig(cfg))
 
 	cfg = newValidConfig(t)
 	cfg.LogFormat = "test"
-	assert.Error(t, ValidateConfig(cfg))
+	require.Error(t, ValidateConfig(cfg))
 
 	cfg = newValidConfig(t)
 	cfg.LogFormat = ""
-	assert.Error(t, ValidateConfig(cfg))
+	require.Error(t, ValidateConfig(cfg))
 
 	for _, format := range []string{"text", "json"} {
 		cfg = newValidConfig(t)
 		cfg.LogFormat = format
-		assert.NoError(t, ValidateConfig(cfg))
+		require.NoError(t, ValidateConfig(cfg))
 	}
 
 	cfg = newValidConfig(t)
 	cfg.Sources = []string{}
-	assert.Error(t, ValidateConfig(cfg))
+	require.Error(t, ValidateConfig(cfg))
 
 	cfg = newValidConfig(t)
 	cfg.Provider = ""
-	assert.Error(t, ValidateConfig(cfg))
+	require.Error(t, ValidateConfig(cfg))
 }
 
 func newValidConfig(t *testing.T) *externaldns.Config {
@@ -84,7 +84,7 @@ func TestValidateBadRfc2136Config(t *testing.T) {
 
 	err := ValidateConfig(cfg)
 
-	assert.NotNil(t, err)
+	assert.Error(t, err)
 }
 
 func TestValidateBadRfc2136Batch(t *testing.T) {
@@ -98,7 +98,7 @@ func TestValidateBadRfc2136Batch(t *testing.T) {
 
 	err := ValidateConfig(cfg)
 
-	assert.NotNil(t, err)
+	assert.Error(t, err)
 }
 
 func TestValidateGoodRfc2136Config(t *testing.T) {
@@ -112,7 +112,7 @@ func TestValidateGoodRfc2136Config(t *testing.T) {
 
 	err := ValidateConfig(cfg)
 
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 }
 
 func TestValidateBadRfc2136GssTsigConfig(t *testing.T) {
@@ -201,7 +201,7 @@ func TestValidateBadRfc2136GssTsigConfig(t *testing.T) {
 	for _, cfg := range invalidRfc2136GssTsigConfigs {
 		err := ValidateConfig(cfg)
 
-		assert.NotNil(t, err)
+		assert.Error(t, err)
 	}
 }
 
@@ -224,6 +224,6 @@ func TestValidateGoodRfc2136GssTsigConfig(t *testing.T) {
 	for _, cfg := range validRfc2136GssTsigConfigs {
 		err := ValidateConfig(cfg)
 
-		assert.Nil(t, err)
+		assert.NoError(t, err)
 	}
 }
diff --git a/pkg/tlsutils/tlsconfig_test.go b/pkg/tlsutils/tlsconfig_test.go
index ed5c97806..dcb83814e 100644
--- a/pkg/tlsutils/tlsconfig_test.go
+++ b/pkg/tlsutils/tlsconfig_test.go
@@ -23,6 +23,8 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
 	"sigs.k8s.io/external-dns/internal/gen/docs/utils"
 )
 
@@ -98,10 +100,10 @@ func TestCreateTLSConfig(t *testing.T) {
 			"",
 			"server-name",
 			func(actual *tls.Config, err error) {
-				assert.Nil(t, err)
-				assert.Equal(t, actual.ServerName, "server-name")
+				require.NoError(t, err)
+				assert.Equal(t, "server-name", actual.ServerName)
 				assert.NotNil(t, actual.Certificates[0])
-				assert.Equal(t, actual.InsecureSkipVerify, false)
+				assert.False(t, actual.InsecureSkipVerify)
 				assert.Equal(t, actual.MinVersion, uint16(defaultMinVersion))
 			},
 		},
diff --git a/plan/plan_test.go b/plan/plan_test.go
index c25a17d8e..c99d55066 100644
--- a/plan/plan_test.go
+++ b/plan/plan_test.go
@@ -23,6 +23,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 	"github.com/stretchr/testify/suite"
 
 	"sigs.k8s.io/external-dns/endpoint"
@@ -272,13 +273,13 @@ func TestPlan_ChangesJson_DecodeEncode(t *testing.T) {
 		},
 	}
 	jsonBytes, err := json.Marshal(ch)
-	assert.NoError(t, err)
-	assert.Equal(t,
+	require.NoError(t, err)
+	assert.JSONEq(t,
 		`{"create":[{"dnsName":"foo"}],"updateOld":[{"dnsName":"bar"}],"updateNew":[{"dnsName":"baz"}],"delete":[{"dnsName":"qux"}]}`,
 		string(jsonBytes))
 	var changes Changes
 	err = json.NewDecoder(bytes.NewBuffer(jsonBytes)).Decode(&changes)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, ch, &changes)
 }
 
@@ -286,7 +287,7 @@ func TestPlan_ChangesJson_DecodeMixedCase(t *testing.T) {
 	input := `{"Create":[{"dnsName":"foo"}],"UpdateOld":[{"dnsName":"bar"}],"updateNew":[{"dnsName":"baz"}],"Delete":[{"dnsName":"qux"}]}`
 	var changes Changes
 	err := json.NewDecoder(strings.NewReader(input)).Decode(&changes)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Len(t, changes.Create, 1)
 }
 
@@ -412,7 +413,7 @@ func (suite *PlanTestSuite) TestSyncSecondRoundWithProviderSpecificNoChange() {
 	}
 
 	changes := p.Calculate().Changes
-	suite.Assert().False(changes.HasChanges())
+	suite.False(changes.HasChanges())
 }
 
 func (suite *PlanTestSuite) TestHasChanges() {
@@ -427,7 +428,7 @@ func (suite *PlanTestSuite) TestHasChanges() {
 	}
 
 	changes := p.Calculate().Changes
-	suite.Assert().True(changes.HasChanges())
+	suite.True(changes.HasChanges())
 }
 
 func (suite *PlanTestSuite) TestSyncSecondRoundWithProviderSpecificRemoval() {
diff --git a/provider/akamai/akamai_test.go b/provider/akamai/akamai_test.go
index 0e602097d..7d6ecdb37 100644
--- a/provider/akamai/akamai_test.go
+++ b/provider/akamai/akamai_test.go
@@ -22,9 +22,11 @@ import (
 	"testing"
 
 	log "github.com/sirupsen/logrus"
+	"github.com/stretchr/testify/require"
 
 	dns "github.com/akamai/AkamaiOPEN-edgegrid-golang/configdns-v2"
 	"github.com/stretchr/testify/assert"
+
 	"sigs.k8s.io/external-dns/endpoint"
 	"sigs.k8s.io/external-dns/plan"
 	"sigs.k8s.io/external-dns/provider"
@@ -154,13 +156,13 @@ func TestFetchZonesZoneIDFilter(t *testing.T) {
 	domfilter := endpoint.DomainFilter{}
 	idfilter := provider.NewZoneIDFilter([]string{"Test"})
 	c, err := createAkamaiStubProvider(stub, domfilter, idfilter)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	stub.setOutput("zone", []interface{}{"test1.testzone.com", "test2.testzone.com"})
 
 	x, _ := c.fetchZones()
 	y, _ := json.Marshal(x)
 	if assert.NotNil(t, y) {
-		assert.Equal(t, "{\"zones\":[{\"contractId\":\"contract\",\"zone\":\"test1.testzone.com\"},{\"contractId\":\"contract\",\"zone\":\"test2.testzone.com\"}]}", string(y))
+		assert.JSONEq(t, "{\"zones\":[{\"contractId\":\"contract\",\"zone\":\"test1.testzone.com\"},{\"contractId\":\"contract\",\"zone\":\"test2.testzone.com\"}]}", string(y))
 	}
 }
 
@@ -169,13 +171,13 @@ func TestFetchZonesEmpty(t *testing.T) {
 	domfilter := endpoint.NewDomainFilter([]string{"Nonexistent"})
 	idfilter := provider.NewZoneIDFilter([]string{"Nonexistent"})
 	c, err := createAkamaiStubProvider(stub, domfilter, idfilter)
-	assert.Nil(t, err)
+	require.NoError(t, err)
 	stub.setOutput("zone", []interface{}{})
 
 	x, _ := c.fetchZones()
 	y, _ := json.Marshal(x)
 	if assert.NotNil(t, y) {
-		assert.Equal(t, "{\"zones\":[]}", string(y))
+		assert.JSONEq(t, "{\"zones\":[]}", string(y))
 	}
 }
 
@@ -185,7 +187,7 @@ func TestAkamaiRecords(t *testing.T) {
 	domfilter := endpoint.DomainFilter{}
 	idfilter := provider.ZoneIDFilter{}
 	c, err := createAkamaiStubProvider(stub, domfilter, idfilter)
-	assert.Nil(t, err)
+	require.NoError(t, err)
 	stub.setOutput("zone", []interface{}{"test1.testzone.com"})
 	recordsets := make([]interface{}, 0)
 	recordsets = append(recordsets, dns.Recordset{
@@ -220,7 +222,7 @@ func TestAkamaiRecordsEmpty(t *testing.T) {
 	domfilter := endpoint.DomainFilter{}
 	idfilter := provider.NewZoneIDFilter([]string{"Nonexistent"})
 	c, err := createAkamaiStubProvider(stub, domfilter, idfilter)
-	assert.Nil(t, err)
+	require.NoError(t, err)
 	stub.setOutput("zone", []interface{}{"test1.testzone.com"})
 	recordsets := make([]interface{}, 0)
 	stub.setOutput("recordset", recordsets)
@@ -234,7 +236,7 @@ func TestAkamaiRecordsFilters(t *testing.T) {
 	domfilter := endpoint.NewDomainFilter([]string{"www.exclude.me"})
 	idfilter := provider.ZoneIDFilter{}
 	c, err := createAkamaiStubProvider(stub, domfilter, idfilter)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	stub.setOutput("zone", []interface{}{"www.exclude.me"})
 	recordsets := make([]interface{}, 0)
 	recordsets = append(recordsets, dns.Recordset{
@@ -264,7 +266,7 @@ func TestCreateRecords(t *testing.T) {
 	domfilter := endpoint.DomainFilter{}
 	idfilter := provider.ZoneIDFilter{}
 	c, err := createAkamaiStubProvider(stub, domfilter, idfilter)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 
 	zoneNameIDMapper := provider.ZoneIDName{"example.com": "example.com"}
 	endpoints := make([]*endpoint.Endpoint, 0)
@@ -272,7 +274,7 @@ func TestCreateRecords(t *testing.T) {
 	endpoints = append(endpoints, endpoint.NewEndpoint("www.example.com", endpoint.RecordTypeTXT, "heritage=external-dns,external-dns/owner=default"))
 
 	err = c.createRecordsets(zoneNameIDMapper, endpoints)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 }
 
 func TestCreateRecordsDomainFilter(t *testing.T) {
@@ -280,7 +282,7 @@ func TestCreateRecordsDomainFilter(t *testing.T) {
 	domfilter := endpoint.DomainFilter{}
 	idfilter := provider.ZoneIDFilter{}
 	c, err := createAkamaiStubProvider(stub, domfilter, idfilter)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 
 	zoneNameIDMapper := provider.ZoneIDName{"example.com": "example.com"}
 	endpoints := make([]*endpoint.Endpoint, 0)
@@ -289,7 +291,7 @@ func TestCreateRecordsDomainFilter(t *testing.T) {
 	exclude := append(endpoints, endpoint.NewEndpoint("www.exclude.me", endpoint.RecordTypeA, "10.0.0.2", "10.0.0.3"))
 
 	err = c.createRecordsets(zoneNameIDMapper, exclude)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 }
 
 // TestDeleteRecords validate delete
@@ -298,7 +300,7 @@ func TestDeleteRecords(t *testing.T) {
 	domfilter := endpoint.DomainFilter{}
 	idfilter := provider.ZoneIDFilter{}
 	c, err := createAkamaiStubProvider(stub, domfilter, idfilter)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 
 	zoneNameIDMapper := provider.ZoneIDName{"example.com": "example.com"}
 	endpoints := make([]*endpoint.Endpoint, 0)
@@ -306,7 +308,7 @@ func TestDeleteRecords(t *testing.T) {
 	endpoints = append(endpoints, endpoint.NewEndpoint("www.example.com", endpoint.RecordTypeTXT, "heritage=external-dns,external-dns/owner=default"))
 
 	err = c.deleteRecordsets(zoneNameIDMapper, endpoints)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 }
 
 func TestDeleteRecordsDomainFilter(t *testing.T) {
@@ -314,7 +316,7 @@ func TestDeleteRecordsDomainFilter(t *testing.T) {
 	domfilter := endpoint.NewDomainFilter([]string{"example.com"})
 	idfilter := provider.ZoneIDFilter{}
 	c, err := createAkamaiStubProvider(stub, domfilter, idfilter)
-	assert.Nil(t, err)
+	require.NoError(t, err)
 
 	zoneNameIDMapper := provider.ZoneIDName{"example.com": "example.com"}
 	endpoints := make([]*endpoint.Endpoint, 0)
@@ -323,7 +325,7 @@ func TestDeleteRecordsDomainFilter(t *testing.T) {
 	exclude := append(endpoints, endpoint.NewEndpoint("www.exclude.me", endpoint.RecordTypeA, "10.0.0.2", "10.0.0.3"))
 
 	err = c.deleteRecordsets(zoneNameIDMapper, exclude)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 }
 
 // Test record update func
@@ -332,7 +334,7 @@ func TestUpdateRecords(t *testing.T) {
 	domfilter := endpoint.DomainFilter{}
 	idfilter := provider.ZoneIDFilter{}
 	c, err := createAkamaiStubProvider(stub, domfilter, idfilter)
-	assert.Nil(t, err)
+	require.NoError(t, err)
 
 	zoneNameIDMapper := provider.ZoneIDName{"example.com": "example.com"}
 	endpoints := make([]*endpoint.Endpoint, 0)
@@ -340,7 +342,7 @@ func TestUpdateRecords(t *testing.T) {
 	endpoints = append(endpoints, endpoint.NewEndpoint("www.example.com", endpoint.RecordTypeTXT, "heritage=external-dns,external-dns/owner=default"))
 
 	err = c.updateNewRecordsets(zoneNameIDMapper, endpoints)
-	assert.Nil(t, err)
+	require.NoError(t, err)
 }
 
 func TestUpdateRecordsDomainFilter(t *testing.T) {
@@ -348,7 +350,7 @@ func TestUpdateRecordsDomainFilter(t *testing.T) {
 	domfilter := endpoint.NewDomainFilter([]string{"example.com"})
 	idfilter := provider.ZoneIDFilter{}
 	c, err := createAkamaiStubProvider(stub, domfilter, idfilter)
-	assert.Nil(t, err)
+	require.NoError(t, err)
 
 	zoneNameIDMapper := provider.ZoneIDName{"example.com": "example.com"}
 	endpoints := make([]*endpoint.Endpoint, 0)
@@ -357,7 +359,7 @@ func TestUpdateRecordsDomainFilter(t *testing.T) {
 	exclude := append(endpoints, endpoint.NewEndpoint("www.exclude.me", endpoint.RecordTypeA, "10.0.0.2", "10.0.0.3"))
 
 	err = c.updateNewRecordsets(zoneNameIDMapper, exclude)
-	assert.Nil(t, err)
+	require.NoError(t, err)
 }
 
 func TestAkamaiApplyChanges(t *testing.T) {
@@ -365,7 +367,7 @@ func TestAkamaiApplyChanges(t *testing.T) {
 	domfilter := endpoint.NewDomainFilter([]string{"example.com"})
 	idfilter := provider.ZoneIDFilter{}
 	c, err := createAkamaiStubProvider(stub, domfilter, idfilter)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 
 	stub.setOutput("zone", []interface{}{"example.com"})
 	changes := &plan.Changes{}
@@ -382,5 +384,5 @@ func TestAkamaiApplyChanges(t *testing.T) {
 	changes.UpdateOld = []*endpoint.Endpoint{{DNSName: "old.example.com", RecordType: "A", Targets: endpoint.Targets{"target-old"}, RecordTTL: 300}}
 	changes.UpdateNew = []*endpoint.Endpoint{{DNSName: "update.example.com", Targets: endpoint.Targets{"target-new"}, RecordType: "CNAME", RecordTTL: 300}}
 	apply := c.ApplyChanges(context.Background(), changes)
-	assert.Nil(t, apply)
+	assert.NoError(t, apply)
 }
diff --git a/provider/aws/aws_fixtures_test.go b/provider/aws/aws_fixtures_test.go
index eed93954c..cce22119e 100644
--- a/provider/aws/aws_fixtures_test.go
+++ b/provider/aws/aws_fixtures_test.go
@@ -24,6 +24,7 @@ import (
 
 	log "github.com/sirupsen/logrus"
 	"github.com/stretchr/testify/assert"
+
 	"sigs.k8s.io/external-dns/internal/testutils"
 )
 
@@ -43,7 +44,7 @@ func TestAWSRecordsV1(t *testing.T) {
 	ctx := context.Background()
 	z, err := provider.Zones(ctx)
 	assert.NoError(t, err)
-	assert.EqualValues(t, 3, len(z))
+	assert.Len(t, z, 3)
 }
 
 func TestAWSZonesFilterWithTags(t *testing.T) {
@@ -58,7 +59,7 @@ func TestAWSZonesFilterWithTags(t *testing.T) {
 	ctx := context.Background()
 	z, err := provider.Zones(ctx)
 	assert.NoError(t, err)
-	assert.EqualValues(t, 24, len(z))
+	assert.Len(t, z, 24)
 	assert.Equal(t, 17, stub.calls["listtagsforresource"])
 }
 
@@ -85,8 +86,8 @@ func TestAWSZonesFiltersWithTags(t *testing.T) {
 			)
 			z, err := provider.Zones(context.Background())
 			assert.NoError(t, err)
-			assert.EqualValues(t, tt.want, len(z))
-			assert.EqualValues(t, tt.calls, stub.calls["listtagsforresource"])
+			assert.Len(t, z, tt.want)
+			assert.Equal(t, tt.calls, stub.calls["listtagsforresource"])
 		})
 	}
 }
diff --git a/provider/aws/aws_test.go b/provider/aws/aws_test.go
index c1719d174..db13e4617 100644
--- a/provider/aws/aws_test.go
+++ b/provider/aws/aws_test.go
@@ -89,7 +89,7 @@ func (r *Route53APIStub) ListResourceRecordSets(ctx context.Context, input *rout
 
 	output := &route53.ListResourceRecordSetsOutput{} // TODO: Support optional input args.
 	require.NotNil(r.t, input.MaxItems)
-	assert.EqualValues(r.t, route53PageSize, *input.MaxItems)
+	assert.Equal(r.t, route53PageSize, *input.MaxItems)
 	if len(r.recordSets) == 0 {
 		output.ResourceRecordSets = []route53types.ResourceRecordSet{}
 	} else if _, ok := r.recordSets[*input.HostedZoneId]; !ok {
@@ -673,7 +673,7 @@ func TestAWSAdjustEndpoints(t *testing.T) {
 	}
 
 	records, err := provider.AdjustEndpoints(records)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	validateEndpoints(t, provider, records, []*endpoint.Endpoint{
 		endpoint.NewEndpoint("a-test.zone-1.ext-dns-test-2.teapot.zalan.do", endpoint.RecordTypeA, "8.8.8.8"),
@@ -1582,7 +1582,7 @@ func TestAWSBatchChangeSet(t *testing.T) {
 
 	batchCs := batchChangeSet(cs, defaultBatchChangeSize, defaultBatchChangeSizeBytes, defaultBatchChangeSizeValues)
 
-	require.Equal(t, 1, len(batchCs))
+	require.Len(t, batchCs, 1)
 
 	// sorting cs not needed as it should be returned as is
 	validateAWSChangeRecords(t, batchCs[0], cs)
@@ -1620,7 +1620,7 @@ func TestAWSBatchChangeSetExceeding(t *testing.T) {
 
 	batchCs := batchChangeSet(cs, testLimit, defaultBatchChangeSizeBytes, defaultBatchChangeSizeValues)
 
-	require.Equal(t, expectedBatchCount, len(batchCs))
+	require.Len(t, batchCs, expectedBatchCount)
 
 	// sorting cs needed to match batchCs
 	for i, batch := range batchCs {
@@ -1658,7 +1658,7 @@ func TestAWSBatchChangeSetExceedingNameChange(t *testing.T) {
 
 	batchCs := batchChangeSet(cs, testLimit, defaultBatchChangeSizeBytes, defaultBatchChangeSizeValues)
 
-	require.Equal(t, 0, len(batchCs))
+	require.Empty(t, batchCs)
 }
 
 func TestAWSBatchChangeSetExceedingBytesLimit(t *testing.T) {
@@ -1717,7 +1717,7 @@ func TestAWSBatchChangeSetExceedingBytesLimit(t *testing.T) {
 
 	batchCs := batchChangeSet(cs, defaultBatchChangeSize, testLimit, defaultBatchChangeSizeValues)
 
-	require.Equal(t, expectedBatchCount, len(batchCs))
+	require.Len(t, batchCs, expectedBatchCount)
 }
 
 func TestAWSBatchChangeSetExceedingBytesLimitUpsert(t *testing.T) {
@@ -1776,7 +1776,7 @@ func TestAWSBatchChangeSetExceedingBytesLimitUpsert(t *testing.T) {
 
 	batchCs := batchChangeSet(cs, defaultBatchChangeSize, testLimit, defaultBatchChangeSizeValues)
 
-	require.Equal(t, expectedBatchCount, len(batchCs))
+	require.Len(t, batchCs, expectedBatchCount)
 }
 
 func TestAWSBatchChangeSetExceedingValuesLimit(t *testing.T) {
@@ -1835,7 +1835,7 @@ func TestAWSBatchChangeSetExceedingValuesLimit(t *testing.T) {
 
 	batchCs := batchChangeSet(cs, defaultBatchChangeSize, defaultBatchChangeSizeBytes, testLimit)
 
-	require.Equal(t, expectedBatchCount, len(batchCs))
+	require.Len(t, batchCs, expectedBatchCount)
 }
 
 func TestAWSBatchChangeSetExceedingValuesLimitUpsert(t *testing.T) {
@@ -1894,7 +1894,7 @@ func TestAWSBatchChangeSetExceedingValuesLimitUpsert(t *testing.T) {
 
 	batchCs := batchChangeSet(cs, defaultBatchChangeSize, defaultBatchChangeSizeBytes, testLimit)
 
-	require.Equal(t, expectedBatchCount, len(batchCs))
+	require.Len(t, batchCs, expectedBatchCount)
 }
 
 func validateEndpoints(t *testing.T, provider *AWSProvider, endpoints []*endpoint.Endpoint, expected []*endpoint.Endpoint) {
@@ -2086,7 +2086,7 @@ func TestAWSCanonicalHostedZone(t *testing.T) {
 	}
 
 	zone := canonicalHostedZone("foo.example.org")
-	assert.Equal(t, "", zone, "no canonical zone should be returned for a non-aws hostname")
+	assert.Empty(t, zone, "no canonical zone should be returned for a non-aws hostname")
 }
 
 func TestAWSCanonicalHostedZoneNotExist(t *testing.T) {
diff --git a/provider/awssd/aws_sd_test.go b/provider/awssd/aws_sd_test.go
index dd851c455..d49760415 100644
--- a/provider/awssd/aws_sd_test.go
+++ b/provider/awssd/aws_sd_test.go
@@ -36,7 +36,7 @@ import (
 	"sigs.k8s.io/external-dns/plan"
 )
 
-// Compile time check for interface conformance
+// Compile time checks for interface conformance
 var _ AWSSDClient = &AWSSDClientStub{}
 
 var (
@@ -491,7 +491,7 @@ func TestAWSSDProvider_ApplyChanges_Update(t *testing.T) {
 
 	// make sure only one instance is de-registered
 	assert.Len(t, api.deregistered, 1)
-	assert.Equal(t, api.deregistered[0], "1.2.3.5", "wrong target de-registered")
+	assert.Equal(t, "1.2.3.5", api.deregistered[0], "wrong target de-registered")
 }
 
 func TestAWSSDProvider_ListNamespaces(t *testing.T) {
@@ -803,12 +803,12 @@ func TestAWSSDProvider_DeleteService(t *testing.T) {
 
 	// delete first service
 	err := provider.DeleteService(context.Background(), services["private"]["srv1"])
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Len(t, api.services["private"], 2)
 
 	// delete third service
 	err1 := provider.DeleteService(context.Background(), services["private"]["srv3"])
-	assert.NoError(t, err1)
+	require.NoError(t, err1)
 	assert.Len(t, api.services["private"], 1)
 
 	expectedServices := map[string]*sdtypes.Service{
@@ -1027,7 +1027,7 @@ func TestAWSSDProvider_DeregisterInstance(t *testing.T) {
 
 	provider.DeregisterInstance(context.Background(), services["private"]["srv1"], endpoint.NewEndpoint("srv1.private.com.", endpoint.RecordTypeA, "1.2.3.4"))
 
-	assert.Len(t, instances["srv1"], 0)
+	assert.Empty(t, instances["srv1"])
 }
 
 func TestAWSSDProvider_awsTags(t *testing.T) {
diff --git a/provider/azure/config_test.go b/provider/azure/config_test.go
index 8e7f9c6cd..43e378fb4 100644
--- a/provider/azure/config_test.go
+++ b/provider/azure/config_test.go
@@ -63,9 +63,9 @@ func TestOverrideConfiguration(t *testing.T) {
 	if err != nil {
 		t.Errorf("got unexpected err %v", err)
 	}
-	assert.Equal(t, cfg.SubscriptionID, "subscription-override")
-	assert.Equal(t, cfg.ResourceGroup, "rg-override")
-	assert.Equal(t, cfg.ActiveDirectoryAuthorityHost, "aad-endpoint-override")
+	assert.Equal(t, "subscription-override", cfg.SubscriptionID)
+	assert.Equal(t, "rg-override", cfg.ResourceGroup)
+	assert.Equal(t, "aad-endpoint-override", cfg.ActiveDirectoryAuthorityHost)
 }
 
 // Test for custom header policy
diff --git a/provider/civo/civo_test.go b/provider/civo/civo_test.go
index 6a05a7d8f..e476199f2 100644
--- a/provider/civo/civo_test.go
+++ b/provider/civo/civo_test.go
@@ -27,6 +27,7 @@ import (
 	"github.com/google/go-cmp/cmp"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+
 	"sigs.k8s.io/external-dns/endpoint"
 	"sigs.k8s.io/external-dns/plan"
 )
@@ -145,7 +146,7 @@ func TestCivoProviderWithoutRecords(t *testing.T) {
 	records, err := provider.Records(context.Background())
 	assert.NoError(t, err)
 
-	assert.Equal(t, len(records), 0)
+	assert.Empty(t, records)
 }
 
 func TestCivoProcessCreateActions(t *testing.T) {
@@ -182,9 +183,9 @@ func TestCivoProcessCreateActions(t *testing.T) {
 	err := processCreateActions(zoneByID, recordsByZoneID, createsByZone, &changes)
 	require.NoError(t, err)
 
-	assert.Equal(t, 2, len(changes.Creates))
-	assert.Equal(t, 0, len(changes.Updates))
-	assert.Equal(t, 0, len(changes.Deletes))
+	assert.Len(t, changes.Creates, 2)
+	assert.Empty(t, changes.Updates)
+	assert.Empty(t, changes.Deletes)
 
 	expectedCreates := []*CivoChangeCreate{
 		{
@@ -306,9 +307,9 @@ func TestCivoProcessUpdateActions(t *testing.T) {
 	err := processUpdateActions(zoneByID, recordsByZoneID, updatesByZone, &changes)
 	require.NoError(t, err)
 
-	assert.Equal(t, 2, len(changes.Creates))
-	assert.Equal(t, 0, len(changes.Updates))
-	assert.Equal(t, 2, len(changes.Deletes))
+	assert.Len(t, changes.Creates, 2)
+	assert.Empty(t, changes.Updates)
+	assert.Len(t, changes.Deletes, 2)
 
 	expectedUpdate := []*CivoChangeCreate{
 		{
@@ -435,9 +436,9 @@ func TestCivoProcessDeleteAction(t *testing.T) {
 	err := processDeleteActions(zoneByID, recordsByZoneID, deleteByDomain, &changes)
 	require.NoError(t, err)
 
-	assert.Equal(t, 0, len(changes.Creates))
-	assert.Equal(t, 0, len(changes.Updates))
-	assert.Equal(t, 2, len(changes.Deletes))
+	assert.Empty(t, changes.Creates)
+	assert.Empty(t, changes.Updates)
+	assert.Len(t, changes.Deletes, 2)
 
 	expectedDelete := []*CivoChangeDelete{
 		{
@@ -598,7 +599,7 @@ func TestCivoProviderFetchRecordsWithError(t *testing.T) {
 }
 
 func TestCivo_getStrippedRecordName(t *testing.T) {
-	assert.Equal(t, "", getStrippedRecordName(civogo.DNSDomain{
+	assert.Empty(t, getStrippedRecordName(civogo.DNSDomain{
 		Name: "foo.com",
 	}, endpoint.Endpoint{
 		DNSName: "foo.com",
diff --git a/provider/cloudflare/cloudflare_test.go b/provider/cloudflare/cloudflare_test.go
index 6bd934115..de5837b29 100644
--- a/provider/cloudflare/cloudflare_test.go
+++ b/provider/cloudflare/cloudflare_test.go
@@ -31,6 +31,7 @@ import (
 	"github.com/maxatome/go-testdeep/td"
 	log "github.com/sirupsen/logrus"
 	"github.com/stretchr/testify/assert"
+
 	"sigs.k8s.io/external-dns/endpoint"
 	"sigs.k8s.io/external-dns/internal/testutils"
 	"sigs.k8s.io/external-dns/plan"
@@ -895,7 +896,7 @@ func TestCloudflareZones(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	assert.Equal(t, 1, len(zones))
+	assert.Len(t, zones, 1)
 	assert.Equal(t, "bar.com", zones[0].Name)
 }
 
@@ -932,7 +933,7 @@ func TestCloudFlareZonesWithIDFilter(t *testing.T) {
 	}
 
 	// foo.com should *not* be returned as it doesn't match ZoneID filter
-	assert.Equal(t, 1, len(zones))
+	assert.Len(t, zones, 1)
 	assert.Equal(t, "bar.com", zones[0].Name)
 }
 
@@ -991,7 +992,7 @@ func TestCloudflareRecords(t *testing.T) {
 	if err != nil {
 		t.Errorf("should not fail, %s", err)
 	}
-	assert.Equal(t, 2, len(records))
+	assert.Len(t, records, 2)
 	client.dnsRecordsError = errors.New("failed to list dns records")
 	_, err = p.Records(ctx)
 	if err == nil {
@@ -1204,7 +1205,7 @@ func TestCloudflareDryRunApplyChanges(t *testing.T) {
 	if err != nil {
 		t.Errorf("should not fail, %s", err)
 	}
-	assert.Equal(t, 0, len(records), "should not have any records")
+	assert.Empty(t, records, "should not have any records")
 }
 
 func TestCloudflareApplyChangesError(t *testing.T) {
@@ -1245,13 +1246,13 @@ func TestCloudflareGetRecordID(t *testing.T) {
 		},
 	}
 
-	assert.Equal(t, "", p.getRecordID(recordsMap, cloudflare.DNSRecord{
+	assert.Empty(t, p.getRecordID(recordsMap, cloudflare.DNSRecord{
 		Name:    "foo.com",
 		Type:    endpoint.RecordTypeA,
 		Content: "foobar",
 	}))
 
-	assert.Equal(t, "", p.getRecordID(recordsMap, cloudflare.DNSRecord{
+	assert.Empty(t, p.getRecordID(recordsMap, cloudflare.DNSRecord{
 		Name:    "foo.com",
 		Type:    endpoint.RecordTypeCNAME,
 		Content: "fizfuz",
@@ -1262,7 +1263,7 @@ func TestCloudflareGetRecordID(t *testing.T) {
 		Type:    endpoint.RecordTypeCNAME,
 		Content: "foobar",
 	}))
-	assert.Equal(t, "", p.getRecordID(recordsMap, cloudflare.DNSRecord{
+	assert.Empty(t, p.getRecordID(recordsMap, cloudflare.DNSRecord{
 		Name:    "bar.de",
 		Type:    endpoint.RecordTypeA,
 		Content: "2.3.4.5",
@@ -1579,7 +1580,7 @@ func TestProviderPropertiesIdempotency(t *testing.T) {
 			if err != nil {
 				t.Errorf("should not fail, %s", err)
 			}
-			assert.Equal(t, 1, len(current))
+			assert.Len(t, current, 1)
 
 			desired := []*endpoint.Endpoint{}
 			for _, c := range current {
@@ -1608,15 +1609,15 @@ func TestProviderPropertiesIdempotency(t *testing.T) {
 			if plan.Changes == nil {
 				return
 			}
-			assert.Equal(t, 0, len(plan.Changes.Create), "should not have creates")
-			assert.Equal(t, 0, len(plan.Changes.Delete), "should not have deletes")
+			assert.Empty(t, plan.Changes.Create, "should not have creates")
+			assert.Empty(t, plan.Changes.Delete, "should not have deletes")
 
 			if test.ShouldBeUpdated {
-				assert.Equal(t, 1, len(plan.Changes.UpdateNew), "should not have new updates")
-				assert.Equal(t, 1, len(plan.Changes.UpdateOld), "should not have old updates")
+				assert.Len(t, plan.Changes.UpdateNew, 1, "should not have new updates")
+				assert.Len(t, plan.Changes.UpdateOld, 1, "should not have old updates")
 			} else {
-				assert.Equal(t, 0, len(plan.Changes.UpdateNew), "should not have new updates")
-				assert.Equal(t, 0, len(plan.Changes.UpdateOld), "should not have old updates")
+				assert.Empty(t, plan.Changes.UpdateNew, "should not have new updates")
+				assert.Empty(t, plan.Changes.UpdateOld, "should not have old updates")
 			}
 		})
 	}
@@ -1754,10 +1755,10 @@ func TestCustomTTLWithEnabledProxyNotChanged(t *testing.T) {
 
 	planned := plan.Calculate()
 
-	assert.Equal(t, 0, len(planned.Changes.Create), "no new changes should be here")
-	assert.Equal(t, 0, len(planned.Changes.UpdateNew), "no new changes should be here")
-	assert.Equal(t, 0, len(planned.Changes.UpdateOld), "no new changes should be here")
-	assert.Equal(t, 0, len(planned.Changes.Delete), "no new changes should be here")
+	assert.Empty(t, planned.Changes.Create, "no new changes should be here")
+	assert.Empty(t, planned.Changes.UpdateNew, "no new changes should be here")
+	assert.Empty(t, planned.Changes.UpdateOld, "no new changes should be here")
+	assert.Empty(t, planned.Changes.Delete, "no new changes should be here")
 }
 
 func TestCloudFlareProvider_Region(t *testing.T) {
@@ -2795,7 +2796,7 @@ func TestCloudflareDisabledCustomHostnameOperations(t *testing.T) {
 			t.Error(e)
 		}
 		if tc.testChanges {
-			assert.Equal(t, planned.Changes.HasChanges(), false, "no new changes should be here")
+			assert.False(t, planned.Changes.HasChanges(), "no new changes should be here")
 		}
 	}
 }
@@ -2983,7 +2984,7 @@ func TestCloudflareListCustomHostnamesWithPagionation(t *testing.T) {
 	if chErr != nil {
 		t.Errorf("should not fail - %v", chErr)
 	}
-	assert.Equal(t, len(chs), CustomHostnamesNumber)
+	assert.Len(t, chs, CustomHostnamesNumber)
 }
 
 func Test_getRegionKey(t *testing.T) {
@@ -3325,9 +3326,9 @@ func TestZoneHasPaidPlan(t *testing.T) {
 		zoneIDFilter: provider.NewZoneIDFilter([]string{""}),
 	}
 
-	assert.Equal(t, false, cfprovider.ZoneHasPaidPlan("subdomain.foo.com"))
-	assert.Equal(t, true, cfprovider.ZoneHasPaidPlan("subdomain.bar.com"))
-	assert.Equal(t, false, cfprovider.ZoneHasPaidPlan("invaliddomain"))
+	assert.False(t, cfprovider.ZoneHasPaidPlan("subdomain.foo.com"))
+	assert.True(t, cfprovider.ZoneHasPaidPlan("subdomain.bar.com"))
+	assert.False(t, cfprovider.ZoneHasPaidPlan("invaliddomain"))
 
 	client.zoneDetailsError = errors.New("zone lookup failed")
 	cfproviderWithZoneError := &CloudFlareProvider{
@@ -3335,5 +3336,5 @@ func TestZoneHasPaidPlan(t *testing.T) {
 		domainFilter: endpoint.NewDomainFilter([]string{"foo.com", "bar.com"}),
 		zoneIDFilter: provider.NewZoneIDFilter([]string{""}),
 	}
-	assert.Equal(t, false, cfproviderWithZoneError.ZoneHasPaidPlan("subdomain.foo.com"))
+	assert.False(t, cfproviderWithZoneError.ZoneHasPaidPlan("subdomain.foo.com"))
 }
diff --git a/provider/digitalocean/digital_ocean_test.go b/provider/digitalocean/digital_ocean_test.go
index 4fd6ec052..18f62aeb4 100644
--- a/provider/digitalocean/digital_ocean_test.go
+++ b/provider/digitalocean/digital_ocean_test.go
@@ -409,9 +409,9 @@ func TestDigitalOceanProcessCreateActions(t *testing.T) {
 	err := processCreateActions(recordsByDomain, createsByDomain, &changes)
 	require.NoError(t, err)
 
-	assert.Equal(t, 4, len(changes.Creates))
-	assert.Equal(t, 0, len(changes.Updates))
-	assert.Equal(t, 0, len(changes.Deletes))
+	assert.Len(t, changes.Creates, 4)
+	assert.Empty(t, changes.Updates)
+	assert.Empty(t, changes.Deletes)
 
 	expectedCreates := []*digitalOceanChangeCreate{
 		{
@@ -521,9 +521,9 @@ func TestDigitalOceanProcessUpdateActions(t *testing.T) {
 	err := processUpdateActions(recordsByDomain, updatesByDomain, &changes)
 	require.NoError(t, err)
 
-	assert.Equal(t, 4, len(changes.Creates))
-	assert.Equal(t, 0, len(changes.Updates))
-	assert.Equal(t, 6, len(changes.Deletes))
+	assert.Len(t, changes.Creates, 4)
+	assert.Empty(t, changes.Updates)
+	assert.Len(t, changes.Deletes, 6)
 
 	expectedCreates := []*digitalOceanChangeCreate{
 		{
@@ -640,9 +640,9 @@ func TestDigitalOceanProcessDeleteActions(t *testing.T) {
 	err := processDeleteActions(recordsByDomain, deletesByDomain, &changes)
 	require.NoError(t, err)
 
-	assert.Equal(t, 0, len(changes.Creates))
-	assert.Equal(t, 0, len(changes.Updates))
-	assert.Equal(t, 2, len(changes.Deletes))
+	assert.Empty(t, changes.Creates)
+	assert.Empty(t, changes.Updates)
+	assert.Len(t, changes.Deletes, 2)
 
 	expectedDeletes := []*digitalOceanChangeDelete{
 		{
@@ -722,14 +722,14 @@ func TestDigitalOceanGetMatchingDomainRecords(t *testing.T) {
 	}
 
 	ep1 := endpoint.NewEndpoint("foo.com", endpoint.RecordTypeCNAME)
-	assert.Equal(t, 1, len(getMatchingDomainRecords(records, "com", ep1)))
+	assert.Len(t, getMatchingDomainRecords(records, "com", ep1), 1)
 
 	ep2 := endpoint.NewEndpoint("foo.com", endpoint.RecordTypeA)
-	assert.Equal(t, 0, len(getMatchingDomainRecords(records, "com", ep2)))
+	assert.Empty(t, getMatchingDomainRecords(records, "com", ep2))
 
 	ep3 := endpoint.NewEndpoint("baz.org", endpoint.RecordTypeA)
 	r := getMatchingDomainRecords(records, "org", ep3)
-	assert.Equal(t, 2, len(r))
+	assert.Len(t, r, 2)
 	assert.ElementsMatch(t, r, []godo.DomainRecord{
 		{
 			ID:   2,
@@ -747,18 +747,18 @@ func TestDigitalOceanGetMatchingDomainRecords(t *testing.T) {
 
 	ep4 := endpoint.NewEndpoint("example.com", endpoint.RecordTypeA)
 	r2 := getMatchingDomainRecords(records, "example.com", ep4)
-	assert.Equal(t, 1, len(r2))
+	assert.Len(t, r2, 1)
 	assert.Equal(t, "9.10.11.12", r2[0].Data)
 
 	ep5 := endpoint.NewEndpoint("example.com", endpoint.RecordTypeMX)
 	r3 := getMatchingDomainRecords(records, "example.com", ep5)
-	assert.Equal(t, 2, len(r3))
+	assert.Len(t, r3, 2)
 	assert.Equal(t, "mx1.foo.com.", r3[0].Data)
 	assert.Equal(t, "mx2.foo.com.", r3[1].Data)
 
 	ep6 := endpoint.NewEndpoint("example.com", endpoint.RecordTypeTXT)
 	r4 := getMatchingDomainRecords(records, "example.com", ep6)
-	assert.Equal(t, 1, len(r4))
+	assert.Len(t, r4, 1)
 	assert.Equal(t, "MYTXT", r4[0].Data)
 }
 
@@ -796,7 +796,7 @@ func TestDigitalOceanAllRecords(t *testing.T) {
 	if err != nil {
 		t.Errorf("should not fail, %s", err)
 	}
-	require.Equal(t, 7, len(records))
+	require.Len(t, records, 7)
 
 	provider.Client = &mockDigitalOceanRecordsFail{}
 	_, err = provider.Records(ctx)
@@ -819,7 +819,7 @@ func TestDigitalOceanMergeRecordsByNameType(t *testing.T) {
 
 	merged := mergeEndpointsByNameType(xs)
 
-	assert.Equal(t, 5, len(merged))
+	assert.Len(t, merged, 5)
 	sort.SliceStable(merged, func(i, j int) bool {
 		if merged[i].DNSName != merged[j].DNSName {
 			return merged[i].DNSName < merged[j].DNSName
@@ -828,24 +828,24 @@ func TestDigitalOceanMergeRecordsByNameType(t *testing.T) {
 	})
 	assert.Equal(t, "bar.example.com", merged[0].DNSName)
 	assert.Equal(t, "A", merged[0].RecordType)
-	assert.Equal(t, 1, len(merged[0].Targets))
+	assert.Len(t, merged[0].Targets, 1)
 	assert.Equal(t, "1.2.3.4", merged[0].Targets[0])
 	assert.Equal(t, "MX", merged[1].RecordType)
-	assert.Equal(t, 2, len(merged[1].Targets))
+	assert.Len(t, merged[1].Targets, 2)
 	assert.ElementsMatch(t, []string{"10 bar.mx1.com", "10 bar.mx2.com"}, merged[1].Targets)
 
 	assert.Equal(t, "foo.example.com", merged[2].DNSName)
 	assert.Equal(t, "A", merged[2].RecordType)
-	assert.Equal(t, 2, len(merged[2].Targets))
+	assert.Len(t, merged[2].Targets, 2)
 	assert.ElementsMatch(t, []string{"1.2.3.4", "5.6.7.8"}, merged[2].Targets)
 
 	assert.Equal(t, "foo.example.com", merged[3].DNSName)
 	assert.Equal(t, "CNAME", merged[3].RecordType)
-	assert.Equal(t, 1, len(merged[3].Targets))
+	assert.Len(t, merged[3].Targets, 1)
 	assert.Equal(t, "somewhere.out.there.com", merged[3].Targets[0])
 
 	assert.Equal(t, "foo.example.com", merged[4].DNSName)
 	assert.Equal(t, "TXT", merged[4].RecordType)
-	assert.Equal(t, 2, len(merged[4].Targets))
+	assert.Len(t, merged[4].Targets, 2)
 	assert.ElementsMatch(t, []string{"txtone", "txttwo"}, merged[4].Targets)
 }
diff --git a/provider/dnsimple/dnsimple_test.go b/provider/dnsimple/dnsimple_test.go
index c2106482b..7f4092ee1 100644
--- a/provider/dnsimple/dnsimple_test.go
+++ b/provider/dnsimple/dnsimple_test.go
@@ -156,17 +156,17 @@ func testDnsimpleProviderZones(t *testing.T) {
 	ctx := context.Background()
 	mockProvider.accountID = "1"
 	result, err := mockProvider.Zones(ctx)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	validateDnsimpleZones(t, result, dnsimpleListZonesResponse.Data)
 
 	mockProvider.accountID = "2"
 	_, err = mockProvider.Zones(ctx)
-	assert.NotNil(t, err)
+	assert.Error(t, err)
 
 	mockProvider.accountID = "3"
 	os.Setenv("DNSIMPLE_ZONES", "example-from-env.com")
 	result, err = mockProvider.Zones(ctx)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	validateDnsimpleZones(t, result, dnsimpleListZonesFromEnvResponse.Data)
 
 	mockProvider.accountID = "2"
@@ -177,12 +177,12 @@ func testDnsimpleProviderRecords(t *testing.T) {
 	ctx := context.Background()
 	mockProvider.accountID = "1"
 	result, err := mockProvider.Records(ctx)
-	assert.Nil(t, err)
-	assert.Equal(t, len(dnsimpleListRecordsResponse.Data), len(result))
+	assert.NoError(t, err)
+	assert.Len(t, result, len(dnsimpleListRecordsResponse.Data))
 
 	mockProvider.accountID = "2"
 	_, err = mockProvider.Records(ctx)
-	assert.NotNil(t, err)
+	assert.Error(t, err)
 }
 
 func testDnsimpleProviderApplyChanges(t *testing.T) {
@@ -223,20 +223,20 @@ func testDnsimpleSuitableZone(t *testing.T) {
 	ctx := context.Background()
 	mockProvider.accountID = "1"
 	zones, err := mockProvider.Zones(ctx)
-	assert.Nil(t, err)
+	require.NoError(t, err)
 
 	zone := dnsimpleSuitableZone("example-beta.example.com", zones)
-	assert.Equal(t, zone.Name, "example.com")
+	assert.Equal(t, "example.com", zone.Name)
 
 	os.Setenv("DNSIMPLE_ZONES", "environment-example.com,example.environment-example.com")
 	mockProvider.accountID = "3"
 	zones, err = mockProvider.Zones(ctx)
-	assert.Nil(t, err)
+	require.NoError(t, err)
 
 	zone = dnsimpleSuitableZone("hello.example.environment-example.com", zones)
-	assert.Equal(t, zone.Name, "example.environment-example.com")
+	assert.Equal(t, "example.environment-example.com", zone.Name)
 
-	os.Unsetenv("DNSIMPLE_ZONES")
+	_ = os.Unsetenv("DNSIMPLE_ZONES")
 	mockProvider.accountID = "1"
 }
 
@@ -247,7 +247,7 @@ func TestNewDnsimpleProvider(t *testing.T) {
 		t.Errorf("Expected to fail new provider on bad token")
 	}
 
-	os.Unsetenv("DNSIMPLE_OAUTH")
+	_ = os.Unsetenv("DNSIMPLE_OAUTH")
 	_, err = NewDnsimpleProvider(endpoint.NewDomainFilter([]string{"example.com"}), provider.NewZoneIDFilter([]string{""}), true)
 	if err == nil {
 		t.Errorf("Expected to fail new provider on empty token")
@@ -260,7 +260,7 @@ func TestNewDnsimpleProvider(t *testing.T) {
 	if err != nil {
 		t.Errorf("Unexpected error thrown when testing NewDnsimpleProvider with the DNSIMPLE_ACCOUNT_ID environment variable set")
 	}
-	assert.Equal(t, dnsimpleTypedProvider.accountID, "12345678")
+	assert.Equal(t, "12345678", dnsimpleTypedProvider.accountID)
 	os.Unsetenv("DNSIMPLE_OAUTH")
 	os.Unsetenv("DNSIMPLE_ACCOUNT_ID")
 }
@@ -271,11 +271,11 @@ func testDnsimpleGetRecordID(t *testing.T) {
 
 	mockProvider.accountID = "1"
 	result, err = mockProvider.GetRecordID(context.Background(), "example.com", "example")
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.Equal(t, int64(2), result)
 
 	result, err = mockProvider.GetRecordID(context.Background(), "example.com", "example-beta")
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.Equal(t, int64(1), result)
 }
 
diff --git a/provider/exoscale/exoscale_test.go b/provider/exoscale/exoscale_test.go
index ed94c9c9b..234505ba4 100644
--- a/provider/exoscale/exoscale_test.go
+++ b/provider/exoscale/exoscale_test.go
@@ -121,7 +121,7 @@ func TestExoscaleGetRecords(t *testing.T) {
 
 	recs, err := provider.Records(context.Background())
 	if err == nil {
-		assert.Equal(t, 3, len(recs))
+		assert.Len(t, recs, 3)
 		assert.True(t, contains(recs, "v1.foo.com"))
 		assert.True(t, contains(recs, "v2.bar.com"))
 		assert.True(t, contains(recs, "v2.foo.com"))
@@ -190,15 +190,15 @@ func TestExoscaleApplyChanges(t *testing.T) {
 
 	provider.ApplyChanges(context.Background(), plan)
 
-	assert.Equal(t, 1, len(createExoscale))
+	assert.Len(t, createExoscale, 1)
 	assert.Equal(t, domainIDs[0], createExoscale[0].domainID)
 	assert.Equal(t, "v1", *createExoscale[0].record.Name)
 
-	assert.Equal(t, 1, len(deleteExoscale))
+	assert.Len(t, deleteExoscale, 1)
 	assert.Equal(t, domainIDs[0], deleteExoscale[0].domainID)
 	assert.Equal(t, *groups[domainIDs[0]][0].ID, deleteExoscale[0].recordID)
 
-	assert.Equal(t, 1, len(updateExoscale))
+	assert.Len(t, updateExoscale, 1)
 	assert.Equal(t, domainIDs[0], updateExoscale[0].domainID)
 	assert.Equal(t, *groups[domainIDs[0]][0].ID, *updateExoscale[0].record.ID)
 }
@@ -234,7 +234,7 @@ func TestExoscaleMerge_NoUpdateOnTTL0Changes(t *testing.T) {
 		},
 	}
 
-	assert.Equal(t, 0, len(merge(updateOld, updateNew)))
+	assert.Empty(t, merge(updateOld, updateNew))
 }
 
 func TestExoscaleMerge_UpdateOnTTLChanges(t *testing.T) {
@@ -269,7 +269,7 @@ func TestExoscaleMerge_UpdateOnTTLChanges(t *testing.T) {
 	}
 
 	merged := merge(updateOld, updateNew)
-	assert.Equal(t, 2, len(merged))
+	assert.Len(t, merged, 2)
 	assert.Equal(t, "name1", merged[0].DNSName)
 }
 
@@ -305,7 +305,7 @@ func TestExoscaleMerge_AlwaysUpdateTarget(t *testing.T) {
 	}
 
 	merged := merge(updateOld, updateNew)
-	assert.Equal(t, 1, len(merged))
+	assert.Len(t, merged, 1)
 	assert.Equal(t, "target1-changed", merged[0].Targets[0])
 }
 
@@ -341,5 +341,5 @@ func TestExoscaleMerge_NoUpdateIfTTLUnchanged(t *testing.T) {
 	}
 
 	merged := merge(updateOld, updateNew)
-	assert.Equal(t, 0, len(merged))
+	assert.Empty(t, merged)
 }
diff --git a/provider/gandi/gandi_test.go b/provider/gandi/gandi_test.go
index e3b4cca19..6442cc3cb 100644
--- a/provider/gandi/gandi_test.go
+++ b/provider/gandi/gandi_test.go
@@ -160,28 +160,28 @@ func TestNewGandiProvider(t *testing.T) {
 	if err != nil {
 		t.Errorf("failed : %s", err)
 	}
-	assert.Equal(t, true, provider.DryRun)
+	assert.True(t, provider.DryRun)
 
 	_ = os.Setenv("GANDI_PAT", "myGandiPAT")
 	provider, err = NewGandiProvider(context.Background(), endpoint.NewDomainFilter([]string{"example.com"}), true)
 	if err != nil {
 		t.Errorf("failed : %s", err)
 	}
-	assert.Equal(t, true, provider.DryRun)
+	assert.True(t, provider.DryRun)
 
 	_ = os.Unsetenv("GANDI_KEY")
 	provider, err = NewGandiProvider(context.Background(), endpoint.NewDomainFilter([]string{"example.com"}), true)
 	if err != nil {
 		t.Errorf("failed : %s", err)
 	}
-	assert.Equal(t, true, provider.DryRun)
+	assert.True(t, provider.DryRun)
 
 	_ = os.Setenv("GANDI_SHARING_ID", "aSharingId")
 	provider, err = NewGandiProvider(context.Background(), endpoint.NewDomainFilter([]string{"example.com"}), false)
 	if err != nil {
 		t.Errorf("failed : %s", err)
 	}
-	assert.Equal(t, false, provider.DryRun)
+	assert.False(t, provider.DryRun)
 
 	_ = os.Unsetenv("GANDI_PAT")
 	_, err = NewGandiProvider(context.Background(), endpoint.NewDomainFilter([]string{"example.com"}), true)
@@ -248,7 +248,7 @@ func TestGandiProvider_RecordsReturnsCorrectEndpoints(t *testing.T) {
 		},
 	}
 
-	assert.Equal(t, len(expectedEndpoints), len(actualEndpoints))
+	assert.Len(t, actualEndpoints, len(expectedEndpoints))
 	// we could use testutils.SameEndpoints (plural), but this makes it easier to identify which case is failing
 	for i := range actualEndpoints {
 		if !testutils.SameEndpoint(expectedEndpoints[i], actualEndpoints[i]) {
diff --git a/provider/godaddy/client_test.go b/provider/godaddy/client_test.go
index effc14372..dd8e94d08 100644
--- a/provider/godaddy/client_test.go
+++ b/provider/godaddy/client_test.go
@@ -58,12 +58,12 @@ func TestClient_DoWhenQuotaExceeded(t *testing.T) {
 	}
 
 	resp, err := client.Do(req)
-	assert.Nil(err, "A CODE_EXCEEDED response should not return an error")
+	assert.NoError(err, "A CODE_EXCEEDED response should not return an error")
 	assert.Equal(http.StatusTooManyRequests, resp.StatusCode, "Expected a 429 response")
 
 	respContents := GDErrorResponse{}
 	err = client.UnmarshalResponse(resp, &respContents)
-	if assert.NotNil(err) {
+	if assert.Error(err) {
 		var apiErr *APIError
 		errors.As(err, &apiErr)
 		assert.Equal("QUOTA_EXCEEDED", apiErr.Code)
diff --git a/provider/google/google_test.go b/provider/google/google_test.go
index 457243218..0364a4258 100644
--- a/provider/google/google_test.go
+++ b/provider/google/google_test.go
@@ -552,7 +552,7 @@ func TestGoogleBatchChangeSet(t *testing.T) {
 
 	batchCs := batchChange(cs, googleDefaultBatchChangeSize)
 
-	require.Equal(t, 1, len(batchCs))
+	require.Len(t, batchCs, 1)
 
 	sortChangesByName(cs)
 	validateChange(t, batchCs[0], cs)
@@ -577,7 +577,7 @@ func TestGoogleBatchChangeSetExceeding(t *testing.T) {
 
 	batchCs := batchChange(cs, testLimit)
 
-	require.Equal(t, expectedBatchCount, len(batchCs))
+	require.Len(t, batchCs, expectedBatchCount)
 
 	dnsChange := &dns.Change{}
 	for _, c := range batchCs {
@@ -585,8 +585,8 @@ func TestGoogleBatchChangeSetExceeding(t *testing.T) {
 		dnsChange.Deletions = append(dnsChange.Deletions, c.Deletions...)
 	}
 
-	require.Equal(t, len(cs.Additions), len(dnsChange.Additions))
-	require.Equal(t, len(cs.Deletions), len(dnsChange.Deletions))
+	require.Len(t, dnsChange.Additions, len(cs.Additions))
+	require.Len(t, dnsChange.Deletions, len(cs.Deletions))
 
 	sortChangesByName(cs)
 	sortChangesByName(dnsChange)
@@ -609,7 +609,7 @@ func TestGoogleBatchChangeSetExceedingNameChange(t *testing.T) {
 
 	batchCs := batchChange(cs, testLimit)
 
-	require.Equal(t, 0, len(batchCs))
+	require.Empty(t, batchCs)
 }
 
 func TestSoftErrListZonesConflict(t *testing.T) {
diff --git a/provider/ibmcloud/ibmcloud_test.go b/provider/ibmcloud/ibmcloud_test.go
index 599b1158a..18440e2f6 100644
--- a/provider/ibmcloud/ibmcloud_test.go
+++ b/provider/ibmcloud/ibmcloud_test.go
@@ -26,6 +26,7 @@ import (
 
 	"github.com/IBM/go-sdk-core/v5/core"
 	"github.com/IBM/networking-go-sdk/dnsrecordsv1"
+	"github.com/stretchr/testify/require"
 
 	"github.com/IBM/networking-go-sdk/dnssvcsv1"
 
@@ -303,7 +304,7 @@ func TestPrivate_ApplyChanges(t *testing.T) {
 			Targets:    endpoint.NewTargets("\"heritage=external-dns,external-dns/owner=tower-pdns\""),
 		},
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	endpointsUpdate, err := p.AdjustEndpoints([]*endpoint.Endpoint{
 		{
@@ -313,7 +314,7 @@ func TestPrivate_ApplyChanges(t *testing.T) {
 			Targets:    endpoint.NewTargets("1.2.3.4", "5.6.7.8"),
 		},
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	changes := plan.Changes{
 		Create: endpointsCreate,
@@ -407,13 +408,13 @@ func TestPublicConfig_Validate(t *testing.T) {
 	authenticator := &core.NoAuthAuthenticator{}
 	service, isPrivate, err := cfg.Validate(authenticator, domainFilterTest, provider.NewZoneIDFilter([]string{""}))
 	assert.NoError(t, err)
-	assert.Equal(t, false, isPrivate)
+	assert.False(t, isPrivate)
 	assert.Equal(t, crn, *service.publicRecordsService.Crn)
 	assert.Equal(t, "123", *service.publicRecordsService.ZoneIdentifier)
 
 	service, isPrivate, err = cfg.Validate(authenticator, endpoint.NewDomainFilter([]string{""}), zoneIDFilterTest)
 	assert.NoError(t, err)
-	assert.Equal(t, false, isPrivate)
+	assert.False(t, isPrivate)
 	assert.Equal(t, crn, *service.publicRecordsService.Crn)
 	assert.Equal(t, "123", *service.publicRecordsService.ZoneIdentifier)
 
@@ -430,7 +431,7 @@ func TestPrivateConfig_Validate(t *testing.T) {
 	}
 	_, isPrivate, err := cfg.Validate(authenticator, domainFilterTest, zoneIDFilterTest)
 	assert.NoError(t, err)
-	assert.Equal(t, true, isPrivate)
+	assert.True(t, isPrivate)
 }
 
 // mockIbmcloudClientInterface is an autogenerated mock type for the ibmcloudClient type
diff --git a/provider/inmemory/inmemory_test.go b/provider/inmemory/inmemory_test.go
index 275b53410..df648205a 100644
--- a/provider/inmemory/inmemory_test.go
+++ b/provider/inmemory/inmemory_test.go
@@ -568,9 +568,9 @@ func testNewInMemoryProvider(t *testing.T) {
 func testInMemoryCreateZone(t *testing.T) {
 	im := NewInMemoryProvider()
 	err := im.CreateZone("zone")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	err = im.CreateZone("zone")
-	assert.EqualError(t, err, ErrZoneAlreadyExists.Error())
+	require.EqualError(t, err, ErrZoneAlreadyExists.Error())
 }
 
 func makeZone(s ...string) map[endpoint.EndpointKey]*endpoint.Endpoint {
diff --git a/provider/linode/linode_test.go b/provider/linode/linode_test.go
index a62600330..347ac7911 100644
--- a/provider/linode/linode_test.go
+++ b/provider/linode/linode_test.go
@@ -160,7 +160,7 @@ func TestLinodeStripRecordName(t *testing.T) {
 		DNSName: "api.example.com",
 	}))
 
-	assert.Equal(t, "", getStrippedRecordName(linodego.Domain{
+	assert.Empty(t, getStrippedRecordName(linodego.Domain{
 		Domain: "example.com",
 	}, endpoint.Endpoint{
 		DNSName: "example.com",
@@ -217,7 +217,7 @@ func TestLinodeFetchZonesWithFilter(t *testing.T) {
 }
 
 func TestLinodeGetStrippedRecordName(t *testing.T) {
-	assert.Equal(t, "", getStrippedRecordName(linodego.Domain{
+	assert.Empty(t, getStrippedRecordName(linodego.Domain{
 		Domain: "foo.com",
 	}, endpoint.Endpoint{
 		DNSName: "foo.com",
diff --git a/provider/ns1/ns1_test.go b/provider/ns1/ns1_test.go
index 21e21fcbd..930fce1db 100644
--- a/provider/ns1/ns1_test.go
+++ b/provider/ns1/ns1_test.go
@@ -138,7 +138,7 @@ func TestNS1Records(t *testing.T) {
 
 	records, err := provider.Records(ctx)
 	require.NoError(t, err)
-	assert.Equal(t, 1, len(records))
+	assert.Len(t, records, 1)
 
 	provider.client = &MockNS1GetZoneFail{}
 	_, err = provider.Records(ctx)
diff --git a/provider/pdns/pdns_test.go b/provider/pdns/pdns_test.go
index c8a22165b..4f6176c15 100644
--- a/provider/pdns/pdns_test.go
+++ b/provider/pdns/pdns_test.go
@@ -25,7 +25,6 @@ import (
 	"testing"
 
 	pgo "github.com/ffledgling/pdns-go"
-	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/suite"
 
 	"sigs.k8s.io/external-dns/endpoint"
@@ -802,7 +801,7 @@ func (suite *NewPDNSProviderTestSuite) TestPDNSProviderCreate() {
 			Server:       "http://localhost:8081",
 			DomainFilter: endpoint.NewDomainFilter([]string{""}),
 		})
-	assert.Error(suite.T(), err, "--pdns-api-key should be specified")
+	suite.Error(err, "--pdns-api-key should be specified")
 
 	_, err = NewPDNSProvider(
 		context.Background(),
@@ -811,7 +810,7 @@ func (suite *NewPDNSProviderTestSuite) TestPDNSProviderCreate() {
 			APIKey:       "foo",
 			DomainFilter: endpoint.NewDomainFilter([]string{"example.com", "example.org"}),
 		})
-	assert.Nil(suite.T(), err, "--domain-filter should raise no error")
+	suite.NoError(err, "--domain-filter should raise no error")
 
 	_, err = NewPDNSProvider(
 		context.Background(),
@@ -821,7 +820,7 @@ func (suite *NewPDNSProviderTestSuite) TestPDNSProviderCreate() {
 			DomainFilter: endpoint.NewDomainFilter([]string{""}),
 			DryRun:       true,
 		})
-	assert.Error(suite.T(), err, "--dry-run should raise an error")
+	suite.Error(err, "--dry-run should raise an error")
 
 	// This is our "regular" code path, no error should be thrown
 	_, err = NewPDNSProvider(
@@ -831,7 +830,7 @@ func (suite *NewPDNSProviderTestSuite) TestPDNSProviderCreate() {
 			APIKey:       "foo",
 			DomainFilter: endpoint.NewDomainFilter([]string{""}),
 		})
-	assert.Nil(suite.T(), err, "Regular case should raise no error")
+	suite.NoError(err, "Regular case should raise no error")
 }
 
 func (suite *NewPDNSProviderTestSuite) TestPDNSProviderCreateTLS() {
@@ -842,32 +841,32 @@ func (suite *NewPDNSProviderTestSuite) TestPDNSProviderCreateTLS() {
 		return err
 	}
 
-	assert.Nil(suite.T(), newProvider(TLSConfig{SkipTLSVerify: true}), "Disabled TLS Config should raise no error")
+	suite.NoError(newProvider(TLSConfig{SkipTLSVerify: true}), "Disabled TLS Config should raise no error")
 
-	assert.Nil(suite.T(), newProvider(TLSConfig{
+	suite.NoError(newProvider(TLSConfig{
 		SkipTLSVerify:         true,
 		CAFilePath:            "../../internal/testresources/ca.pem",
 		ClientCertFilePath:    "../../internal/testresources/client-cert.pem",
 		ClientCertKeyFilePath: "../../internal/testresources/client-cert-key.pem",
 	}), "Disabled TLS Config with additional flags should raise no error")
 
-	assert.Nil(suite.T(), newProvider(TLSConfig{}), "Enabled TLS Config without --tls-ca should raise no error")
+	suite.NoError(newProvider(TLSConfig{}), "Enabled TLS Config without --tls-ca should raise no error")
 
-	assert.Nil(suite.T(), newProvider(TLSConfig{
+	suite.NoError(newProvider(TLSConfig{
 		CAFilePath: "../../internal/testresources/ca.pem",
 	}), "Enabled TLS Config with --tls-ca should raise no error")
 
-	assert.Error(suite.T(), newProvider(TLSConfig{
+	suite.Error(newProvider(TLSConfig{
 		CAFilePath:         "../../internal/testresources/ca.pem",
 		ClientCertFilePath: "../../internal/testresources/client-cert.pem",
 	}), "Enabled TLS Config with --tls-client-cert only should raise an error")
 
-	assert.Error(suite.T(), newProvider(TLSConfig{
+	suite.Error(newProvider(TLSConfig{
 		CAFilePath:            "../../internal/testresources/ca.pem",
 		ClientCertKeyFilePath: "../../internal/testresources/client-cert-key.pem",
 	}), "Enabled TLS Config with --tls-client-cert-key only should raise an error")
 
-	assert.Nil(suite.T(), newProvider(TLSConfig{
+	suite.NoError(newProvider(TLSConfig{
 		CAFilePath:            "../../internal/testresources/ca.pem",
 		ClientCertFilePath:    "../../internal/testresources/client-cert.pem",
 		ClientCertKeyFilePath: "../../internal/testresources/client-cert-key.pem",
@@ -886,16 +885,16 @@ func (suite *NewPDNSProviderTestSuite) TestPDNSRRSetToEndpoints() {
 	   - We correctly create corresponding endpoints
 	*/
 	eps, err := p.convertRRSetToEndpoints(RRSetMultipleRecords)
-	assert.Nil(suite.T(), err)
-	assert.Equal(suite.T(), endpointsMultipleRecords, eps)
+	suite.Require().NoError(err)
+	suite.Equal(endpointsMultipleRecords, eps)
 
 	/* Given an RRSet with two records, one of which is disabled, we test:
 	   - We can correctly convert the RRSet into a list of valid endpoints
 	   - We correctly discard/ignore the disabled record.
 	*/
 	eps, err = p.convertRRSetToEndpoints(RRSetDisabledRecord)
-	assert.Nil(suite.T(), err)
-	assert.Equal(suite.T(), endpointsDisabledRecord, eps)
+	suite.Require().NoError(err)
+	suite.Equal(endpointsDisabledRecord, eps)
 }
 
 func (suite *NewPDNSProviderTestSuite) TestPDNSRecords() {
@@ -911,8 +910,8 @@ func (suite *NewPDNSProviderTestSuite) TestPDNSRecords() {
 	/* We test that endpoints are returned correctly for a Zone when Records() is called
 	 */
 	eps, err := p.Records(ctx)
-	assert.Nil(suite.T(), err)
-	assert.Equal(suite.T(), endpointsMixedRecords, eps)
+	suite.Require().NoError(err)
+	suite.Equal(endpointsMixedRecords, eps)
 
 	// Test failures are handled correctly
 	// Create a new provider to run tests against
@@ -920,15 +919,15 @@ func (suite *NewPDNSProviderTestSuite) TestPDNSRecords() {
 		client: &PDNSAPIClientStubListZoneFailure{},
 	}
 	_, err = p.Records(ctx)
-	assert.NotNil(suite.T(), err)
-	assert.ErrorIs(suite.T(), err, provider.SoftError)
+	suite.Error(err)
+	suite.ErrorIs(err, provider.SoftError)
 
 	p = &PDNSProvider{
 		client: &PDNSAPIClientStubListZonesFailure{},
 	}
 	_, err = p.Records(ctx)
-	assert.NotNil(suite.T(), err)
-	assert.ErrorIs(suite.T(), err, provider.SoftError)
+	suite.Error(err)
+	suite.ErrorIs(err, provider.SoftError)
 }
 
 func (suite *NewPDNSProviderTestSuite) TestPDNSConvertEndpointsToZones() {
@@ -941,48 +940,48 @@ func (suite *NewPDNSProviderTestSuite) TestPDNSConvertEndpointsToZones() {
 
 	// Check inserting endpoints from a single zone
 	zlist, err := p.ConvertEndpointsToZones(endpointsSimpleRecord, PdnsReplace)
-	assert.Nil(suite.T(), err)
-	assert.Equal(suite.T(), []pgo.Zone{ZoneEmptyToSimplePatch}, zlist)
+	suite.NoError(err)
+	suite.Equal([]pgo.Zone{ZoneEmptyToSimplePatch}, zlist)
 
 	// Check deleting endpoints from a single zone
 	zlist, err = p.ConvertEndpointsToZones(endpointsSimpleRecord, PdnsDelete)
-	assert.Nil(suite.T(), err)
-	assert.Equal(suite.T(), []pgo.Zone{ZoneEmptyToSimpleDelete}, zlist)
+	suite.NoError(err)
+	suite.Equal([]pgo.Zone{ZoneEmptyToSimpleDelete}, zlist)
 
 	// Check endpoints from multiple zones #1
 	zlist, err = p.ConvertEndpointsToZones(endpointsMultipleZones, PdnsReplace)
-	assert.Nil(suite.T(), err)
-	assert.Equal(suite.T(), []pgo.Zone{ZoneEmptyToSimplePatch, ZoneEmptyToSimplePatch2}, zlist)
+	suite.NoError(err)
+	suite.Equal([]pgo.Zone{ZoneEmptyToSimplePatch, ZoneEmptyToSimplePatch2}, zlist)
 
 	// Check endpoints from multiple zones #2
 	zlist, err = p.ConvertEndpointsToZones(endpointsMultipleZones2, PdnsReplace)
-	assert.Nil(suite.T(), err)
-	assert.Equal(suite.T(), []pgo.Zone{ZoneEmptyToSimplePatch, ZoneEmptyToSimplePatch3}, zlist)
+	suite.NoError(err)
+	suite.Equal([]pgo.Zone{ZoneEmptyToSimplePatch, ZoneEmptyToSimplePatch3}, zlist)
 
 	// Check endpoints from multiple zones where some endpoints which don't exist
 	zlist, err = p.ConvertEndpointsToZones(endpointsMultipleZonesWithNoExist, PdnsReplace)
-	assert.Nil(suite.T(), err)
-	assert.Equal(suite.T(), []pgo.Zone{ZoneEmptyToSimplePatch}, zlist)
+	suite.NoError(err)
+	suite.Equal([]pgo.Zone{ZoneEmptyToSimplePatch}, zlist)
 
 	// Check endpoints from a zone that does not exist
 	zlist, err = p.ConvertEndpointsToZones(endpointsNonexistantZone, PdnsReplace)
-	assert.Nil(suite.T(), err)
-	assert.Equal(suite.T(), []pgo.Zone{}, zlist)
+	suite.NoError(err)
+	suite.Equal([]pgo.Zone{}, zlist)
 
 	// Check endpoints that match multiple zones (one longer than other), is assigned to the right zone
 	zlist, err = p.ConvertEndpointsToZones(endpointsLongRecord, PdnsReplace)
-	assert.Nil(suite.T(), err)
-	assert.Equal(suite.T(), []pgo.Zone{ZoneEmptyToLongPatch}, zlist)
+	suite.NoError(err)
+	suite.Equal([]pgo.Zone{ZoneEmptyToLongPatch}, zlist)
 
 	// Check endpoints of type CNAME always have their target records end with a dot.
 	zlist, err = p.ConvertEndpointsToZones(endpointsMixedRecords, PdnsReplace)
-	assert.Nil(suite.T(), err)
+	suite.NoError(err)
 
 	for _, z := range zlist {
 		for _, rs := range z.Rrsets {
 			if rs.Type_ == "CNAME" {
 				for _, r := range rs.Records {
-					assert.Equal(suite.T(), uint8(0x2e), r.Content[len(r.Content)-1])
+					suite.Equal(uint8(0x2e), r.Content[len(r.Content)-1])
 				}
 			}
 		}
@@ -990,13 +989,13 @@ func (suite *NewPDNSProviderTestSuite) TestPDNSConvertEndpointsToZones() {
 
 	// Check endpoints of type MX and SRV always have their values end with a trailing dot.
 	zlist, err = p.ConvertEndpointsToZones(endpointsMixedRecords, PdnsReplace)
-	assert.Nil(suite.T(), err)
+	suite.NoError(err)
 
 	for _, z := range zlist {
 		for _, rs := range z.Rrsets {
 			if rs.Type_ == "MX" || rs.Type_ == "SRV" {
 				for _, r := range rs.Records {
-					assert.Equal(suite.T(), uint8(0x2e), r.Content[len(r.Content)-1])
+					suite.Equal(uint8(0x2e), r.Content[len(r.Content)-1])
 				}
 			}
 		}
@@ -1004,8 +1003,8 @@ func (suite *NewPDNSProviderTestSuite) TestPDNSConvertEndpointsToZones() {
 
 	// Check endpoints of type CNAME are converted to ALIAS on the domain apex
 	zlist, err = p.ConvertEndpointsToZones(endpointsApexRecords, PdnsReplace)
-	assert.Nil(suite.T(), err)
-	assert.Equal(suite.T(), []pgo.Zone{ZoneEmptyToApexPatch}, zlist)
+	suite.NoError(err)
+	suite.Equal([]pgo.Zone{ZoneEmptyToApexPatch}, zlist)
 }
 
 func (suite *NewPDNSProviderTestSuite) TestPDNSConvertEndpointsToZonesPartitionZones() {
@@ -1016,41 +1015,41 @@ func (suite *NewPDNSProviderTestSuite) TestPDNSConvertEndpointsToZonesPartitionZ
 
 	// Check inserting endpoints from a single zone which is specified in DomainFilter
 	zlist, err := p.ConvertEndpointsToZones(endpointsSimpleRecord, PdnsReplace)
-	assert.Nil(suite.T(), err)
-	assert.Equal(suite.T(), []pgo.Zone{ZoneEmptyToSimplePatch}, zlist)
+	suite.Require().NoError(err)
+	suite.Equal([]pgo.Zone{ZoneEmptyToSimplePatch}, zlist)
 
 	// Check deleting endpoints from a single zone which is specified in DomainFilter
 	zlist, err = p.ConvertEndpointsToZones(endpointsSimpleRecord, PdnsDelete)
-	assert.Nil(suite.T(), err)
-	assert.Equal(suite.T(), []pgo.Zone{ZoneEmptyToSimpleDelete}, zlist)
+	suite.Require().NoError(err)
+	suite.Equal([]pgo.Zone{ZoneEmptyToSimpleDelete}, zlist)
 
 	// Check endpoints from multiple zones # which one is specified in DomainFilter and one is not
 	zlist, err = p.ConvertEndpointsToZones(endpointsMultipleZones, PdnsReplace)
-	assert.Nil(suite.T(), err)
-	assert.Equal(suite.T(), []pgo.Zone{ZoneEmptyToSimplePatch}, zlist)
+	suite.NoError(err)
+	suite.Equal([]pgo.Zone{ZoneEmptyToSimplePatch}, zlist)
 
 	// Check endpoints from multiple zones where some endpoints which don't exist and one that does
 	// and is part of DomainFilter
 	zlist, err = p.ConvertEndpointsToZones(endpointsMultipleZonesWithNoExist, PdnsReplace)
-	assert.Nil(suite.T(), err)
-	assert.Equal(suite.T(), []pgo.Zone{ZoneEmptyToSimplePatch}, zlist)
+	suite.NoError(err)
+	suite.Equal([]pgo.Zone{ZoneEmptyToSimplePatch}, zlist)
 
 	// Check endpoints from a zone that does not exist
 	zlist, err = p.ConvertEndpointsToZones(endpointsNonexistantZone, PdnsReplace)
-	assert.Nil(suite.T(), err)
-	assert.Equal(suite.T(), []pgo.Zone{}, zlist)
+	suite.NoError(err)
+	suite.Equal([]pgo.Zone{}, zlist)
 
 	// Check endpoints that match multiple zones (one longer than other), is assigned to the right zone when the longer
 	// zone is not part of the DomainFilter
 	zlist, err = p.ConvertEndpointsToZones(endpointsMultipleZonesWithLongRecordNotInDomainFilter, PdnsReplace)
-	assert.Nil(suite.T(), err)
-	assert.Equal(suite.T(), []pgo.Zone{ZoneEmptyToSimplePatchLongRecordIgnoredInDomainFilter}, zlist)
+	suite.NoError(err)
+	suite.Equal([]pgo.Zone{ZoneEmptyToSimplePatchLongRecordIgnoredInDomainFilter}, zlist)
 
 	// Check endpoints that match multiple zones (one longer than other and one is very similar)
 	// is assigned to the right zone when the similar zone is not part of the DomainFilter
 	zlist, err = p.ConvertEndpointsToZones(endpointsMultipleZonesWithSimilarRecordNotInDomainFilter, PdnsReplace)
-	assert.Nil(suite.T(), err)
-	assert.Equal(suite.T(), []pgo.Zone{ZoneEmptyToSimplePatch}, zlist)
+	suite.NoError(err)
+	suite.Equal([]pgo.Zone{ZoneEmptyToSimplePatch}, zlist)
 }
 
 func (suite *NewPDNSProviderTestSuite) TestPDNSmutateRecords() {
@@ -1064,16 +1063,16 @@ func (suite *NewPDNSProviderTestSuite) TestPDNSmutateRecords() {
 
 	// Check inserting endpoints from a single zone
 	err := p.mutateRecords(endpointsSimpleRecord, pdnsChangeType("REPLACE"))
-	assert.Nil(suite.T(), err)
-	assert.Equal(suite.T(), []pgo.Zone{ZoneEmptyToSimplePatch}, c.patchedZones)
+	suite.NoError(err)
+	suite.Equal([]pgo.Zone{ZoneEmptyToSimplePatch}, c.patchedZones)
 
 	// Reset the "patchedZones"
 	c.patchedZones = []pgo.Zone{}
 
 	// Check deleting endpoints from a single zone
 	err = p.mutateRecords(endpointsSimpleRecord, pdnsChangeType("DELETE"))
-	assert.Nil(suite.T(), err)
-	assert.Equal(suite.T(), []pgo.Zone{ZoneEmptyToSimpleDelete}, c.patchedZones)
+	suite.NoError(err)
+	suite.Equal([]pgo.Zone{ZoneEmptyToSimpleDelete}, c.patchedZones)
 
 	// Check we fail correctly when patching fails for whatever reason
 	p = &PDNSProvider{
@@ -1081,8 +1080,8 @@ func (suite *NewPDNSProviderTestSuite) TestPDNSmutateRecords() {
 	}
 	// Check inserting endpoints from a single zone
 	err = p.mutateRecords(endpointsSimpleRecord, pdnsChangeType("REPLACE"))
-	assert.NotNil(suite.T(), err)
-	assert.ErrorIs(suite.T(), err, provider.SoftError)
+	suite.Error(err)
+	suite.ErrorIs(err, provider.SoftError)
 }
 
 func (suite *NewPDNSProviderTestSuite) TestPDNSClientPartitionZones() {
@@ -1116,22 +1115,22 @@ func (suite *NewPDNSProviderTestSuite) TestPDNSClientPartitionZones() {
 
 	// Check filtered, residual zones when no domain filter specified
 	filteredZones, residualZones := DomainFilterEmptyClient.PartitionZones(zoneList)
-	assert.Equal(suite.T(), partitionResultFilteredEmptyFilter, filteredZones)
-	assert.Equal(suite.T(), partitionResultResidualEmptyFilter, residualZones)
+	suite.Equal(partitionResultFilteredEmptyFilter, filteredZones)
+	suite.Equal(partitionResultResidualEmptyFilter, residualZones)
 
 	// Check filtered, residual zones when a single domain filter specified
 	filteredZones, residualZones = DomainFilterSingleClient.PartitionZones(zoneList)
-	assert.Equal(suite.T(), partitionResultFilteredSingleFilter, filteredZones)
-	assert.Equal(suite.T(), partitionResultResidualSingleFilter, residualZones)
+	suite.Equal(partitionResultFilteredSingleFilter, filteredZones)
+	suite.Equal(partitionResultResidualSingleFilter, residualZones)
 
 	// Check filtered, residual zones when a multiple domain filter specified
 	filteredZones, residualZones = DomainFilterMultipleClient.PartitionZones(zoneList)
-	assert.Equal(suite.T(), partitionResultFilteredMultipleFilter, filteredZones)
-	assert.Equal(suite.T(), partitionResultResidualMultipleFilter, residualZones)
+	suite.Equal(partitionResultFilteredMultipleFilter, filteredZones)
+	suite.Equal(partitionResultResidualMultipleFilter, residualZones)
 
 	filteredZones, residualZones = RegexDomainFilterClient.PartitionZones(zoneList)
-	assert.Equal(suite.T(), partitionResultFilteredSingleFilter, filteredZones)
-	assert.Equal(suite.T(), partitionResultResidualSingleFilter, residualZones)
+	suite.Equal(partitionResultFilteredSingleFilter, filteredZones)
+	suite.Equal(partitionResultResidualSingleFilter, residualZones)
 }
 
 // Validate whether invalid endpoints are removed by AdjustEndpoints
@@ -1174,8 +1173,8 @@ func (suite *NewPDNSProviderTestSuite) TestPDNSAdjustEndpoints() {
 
 	for _, tt := range tests {
 		actual, err := p.AdjustEndpoints(tt.endpoints)
-		assert.Nil(suite.T(), err)
-		assert.Equal(suite.T(), tt.expected, actual)
+		suite.NoError(err)
+		suite.Equal(tt.expected, actual)
 	}
 }
 
diff --git a/provider/plural/plural_test.go b/provider/plural/plural_test.go
index cc693d9cb..c2ad4e47d 100644
--- a/provider/plural/plural_test.go
+++ b/provider/plural/plural_test.go
@@ -26,6 +26,7 @@ import (
 	"sigs.k8s.io/external-dns/internal/testutils"
 
 	"github.com/stretchr/testify/assert"
+
 	"sigs.k8s.io/external-dns/provider"
 )
 
@@ -178,7 +179,7 @@ func TestPluralApplyChangesCreate(t *testing.T) {
 			if err != nil {
 				t.Fatal(err)
 			}
-			assert.Equal(t, len(actual), 0, "expected no entries")
+			assert.Empty(t, actual, "expected no entries")
 
 			err = provider.ApplyChanges(context.Background(), &plan.Changes{Create: test.expectedEndpoints})
 			if err != nil {
diff --git a/provider/provider_test.go b/provider/provider_test.go
index f6e0c571c..5aa3ff22f 100644
--- a/provider/provider_test.go
+++ b/provider/provider_test.go
@@ -50,7 +50,7 @@ func TestDifference(t *testing.T) {
 	current := []string{"foo", "bar"}
 	desired := []string{"bar", "baz"}
 	add, remove, leave := Difference(current, desired)
-	assert.Equal(t, add, []string{"baz"})
-	assert.Equal(t, remove, []string{"foo"})
-	assert.Equal(t, leave, []string{"bar"})
+	assert.Equal(t, []string{"baz"}, add)
+	assert.Equal(t, []string{"foo"}, remove)
+	assert.Equal(t, []string{"bar"}, leave)
 }
diff --git a/provider/rfc2136/rfc2136_test.go b/provider/rfc2136/rfc2136_test.go
index 0ca059206..da14ae525 100644
--- a/provider/rfc2136/rfc2136_test.go
+++ b/provider/rfc2136/rfc2136_test.go
@@ -32,6 +32,7 @@ import (
 	"github.com/miekg/dns"
 	log "github.com/sirupsen/logrus"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 
 	"sigs.k8s.io/external-dns/endpoint"
 	"sigs.k8s.io/external-dns/plan"
@@ -265,15 +266,15 @@ func TestRfc2136GetRecordsMultipleTargets(t *testing.T) {
 	recs, err := provider.Records(context.Background())
 	assert.NoError(t, err)
 
-	assert.Equal(t, 1, len(recs), "expected single record")
-	assert.Equal(t, recs[0].DNSName, "foo.com")
-	assert.Equal(t, 2, len(recs[0].Targets), "expected two targets")
+	assert.Len(t, recs, 1, "expected single record")
+	assert.Equal(t, "foo.com", recs[0].DNSName)
+	assert.Len(t, recs[0].Targets, 2, "expected two targets")
 	assert.True(t, recs[0].Targets[0] == "1.1.1.1" || recs[0].Targets[1] == "1.1.1.1") // ignore order
 	assert.True(t, recs[0].Targets[0] == "2.2.2.2" || recs[0].Targets[1] == "2.2.2.2") // ignore order
-	assert.Equal(t, recs[0].RecordType, "A")
+	assert.Equal(t, "A", recs[0].RecordType)
 	assert.Equal(t, recs[0].RecordTTL, endpoint.TTL(3600))
-	assert.Equal(t, 0, len(recs[0].Labels), "expected no labels")
-	assert.Equal(t, 0, len(recs[0].ProviderSpecific), "expected no provider specific config")
+	assert.Empty(t, recs[0].Labels, "expected no labels")
+	assert.Empty(t, recs[0].ProviderSpecific, "expected no provider specific config")
 }
 
 func TestRfc2136PTRCreation(t *testing.T) {
@@ -291,17 +292,17 @@ func TestRfc2136PTRCreation(t *testing.T) {
 		},
 	})
 	assert.NoError(t, err)
-	assert.Equal(t, 2, len(stub.createMsgs), "expected two records, one A and one PTR")
+	assert.Len(t, stub.createMsgs, 2, "expected two records, one A and one PTR")
 	createMsgs := getSortedChanges(stub.createMsgs)
-	assert.True(t, strings.Contains(strings.Join(strings.Fields(createMsgs[0]), " "), "4.3.2.1.in-addr.arpa. 300 IN PTR demo.foo.com."), "excpeted a PTR record")
-	assert.True(t, strings.Contains(strings.Join(strings.Fields(createMsgs[1]), " "), "demo.foo.com. 300 IN A 1.2.3.4"), "expected an A record")
+	assert.Contains(t, strings.Join(strings.Fields(createMsgs[0]), " "), "4.3.2.1.in-addr.arpa. 300 IN PTR demo.foo.com.", "excpeted a PTR record")
+	assert.Contains(t, strings.Join(strings.Fields(createMsgs[1]), " "), "demo.foo.com. 300 IN A 1.2.3.4", "expected an A record")
 }
 
 func TestRfc2136TLSConfig(t *testing.T) {
 	stub := newStub()
 
 	caFile, err := os.CreateTemp("", "rfc2136-test-XXXXXXXX.crt")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	defer os.Remove(caFile.Name())
 	_, err = caFile.Write([]byte(
 		`-----BEGIN CERTIFICATE-----
@@ -323,15 +324,15 @@ ouB5ZN+05DzKCQhBekMnygQ=
 	}
 
 	provider, err := createRfc2136TLSStubProvider(stub, tlsConfig)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	rawProvider := provider.(*rfc2136Provider)
 
 	client, err := makeClient(rawProvider, rawProvider.nameservers[0])
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	assert.Equal(t, "tcp-tls", client.Net)
-	assert.Equal(t, false, client.TLSConfig.InsecureSkipVerify)
+	assert.False(t, client.TLSConfig.InsecureSkipVerify)
 	assert.Equal(t, "rfc2136-host", client.TLSConfig.ServerName)
 	assert.Equal(t, uint16(tls.VersionTLS13), client.TLSConfig.MinVersion)
 	assert.Equal(t, []string{"dot"}, client.TLSConfig.NextProtos)
@@ -375,7 +376,7 @@ ouB5ZN+05DzKCQhBekMnygQ=
 		ns = strings.Split(ns, ":")[0]
 
 		assert.Equal(t, "tcp-tls", client.Net)
-		assert.Equal(t, false, client.TLSConfig.InsecureSkipVerify)
+		assert.False(t, client.TLSConfig.InsecureSkipVerify)
 		assert.Equal(t, ns, client.TLSConfig.ServerName)
 		assert.Equal(t, uint16(tls.VersionTLS13), client.TLSConfig.MinVersion)
 		assert.Equal(t, []string{"dot"}, client.TLSConfig.NextProtos)
@@ -416,7 +417,7 @@ ouB5ZN+05DzKCQhBekMnygQ=
 	assert.NoError(t, err)
 
 	assert.Equal(t, "tcp-tls", client.Net)
-	assert.Equal(t, true, client.TLSConfig.InsecureSkipVerify)
+	assert.True(t, client.TLSConfig.InsecureSkipVerify)
 	assert.Equal(t, "rfc2136-host", client.TLSConfig.ServerName)
 	assert.Equal(t, uint16(tls.VersionTLS13), client.TLSConfig.MinVersion)
 	assert.Equal(t, []string{"dot"}, client.TLSConfig.NextProtos)
@@ -487,7 +488,7 @@ hl6aAPCe16pwvljB7yImxLJ+ytWk7OV/s10cmlaczrEtNeUjV1X9MTM=
 	assert.NoError(t, err)
 
 	assert.Equal(t, "tcp-tls", client.Net)
-	assert.Equal(t, false, client.TLSConfig.InsecureSkipVerify)
+	assert.False(t, client.TLSConfig.InsecureSkipVerify)
 	assert.Equal(t, "rfc2136-host", client.TLSConfig.ServerName)
 	assert.Equal(t, uint16(tls.VersionTLS13), client.TLSConfig.MinVersion)
 	assert.Equal(t, []string{"dot"}, client.TLSConfig.NextProtos)
@@ -511,7 +512,7 @@ func TestRfc2136GetRecords(t *testing.T) {
 	recs, err := provider.Records(context.Background())
 	assert.NoError(t, err)
 
-	assert.Equal(t, 6, len(recs))
+	assert.Len(t, recs, 6)
 	assert.True(t, contains(recs, "v1.foo.com"))
 	assert.True(t, contains(recs, "v2.bar.com"))
 	assert.True(t, contains(recs, "v2.foo.com"))
@@ -584,19 +585,19 @@ func TestRfc2136ApplyChanges(t *testing.T) {
 	err = provider.ApplyChanges(context.Background(), p)
 	assert.NoError(t, err)
 
-	assert.Equal(t, 3, len(stub.createMsgs))
-	assert.True(t, strings.Contains(stub.createMsgs[0].String(), "v1.foo.com"))
-	assert.True(t, strings.Contains(stub.createMsgs[0].String(), "1.2.3.4"))
+	assert.Len(t, stub.createMsgs, 3)
+	assert.Contains(t, stub.createMsgs[0].String(), "v1.foo.com")
+	assert.Contains(t, stub.createMsgs[0].String(), "1.2.3.4")
 
-	assert.True(t, strings.Contains(stub.createMsgs[1].String(), "v1.foobar.com"))
-	assert.True(t, strings.Contains(stub.createMsgs[1].String(), "boom"))
+	assert.Contains(t, stub.createMsgs[1].String(), "v1.foobar.com")
+	assert.Contains(t, stub.createMsgs[1].String(), "boom")
 
-	assert.True(t, strings.Contains(stub.createMsgs[2].String(), "ns.foobar.com"))
-	assert.True(t, strings.Contains(stub.createMsgs[2].String(), "boom"))
+	assert.Contains(t, stub.createMsgs[2].String(), "ns.foobar.com")
+	assert.Contains(t, stub.createMsgs[2].String(), "boom")
 
-	assert.Equal(t, 2, len(stub.updateMsgs))
-	assert.True(t, strings.Contains(stub.updateMsgs[0].String(), "v2.foo.com"))
-	assert.True(t, strings.Contains(stub.updateMsgs[1].String(), "v2.foobar.com"))
+	assert.Len(t, stub.updateMsgs, 2)
+	assert.Contains(t, stub.updateMsgs[0].String(), "v2.foo.com")
+	assert.Contains(t, stub.updateMsgs[1].String(), "v2.foobar.com")
 }
 
 // These tests all use the foo.com and foobar.com zones with no filters
@@ -642,25 +643,25 @@ func TestRfc2136ApplyChangesWithZones(t *testing.T) {
 	err = provider.ApplyChanges(context.Background(), p)
 	assert.NoError(t, err)
 
-	assert.Equal(t, 3, len(stub.createMsgs))
+	assert.Len(t, stub.createMsgs, 3)
 	createMsgs := getSortedChanges(stub.createMsgs)
-	assert.Equal(t, 3, len(createMsgs))
+	assert.Len(t, createMsgs, 3)
 
-	assert.True(t, strings.Contains(createMsgs[0], "v1.foo.com"))
-	assert.True(t, strings.Contains(createMsgs[0], "1.2.3.4"))
+	assert.Contains(t, createMsgs[0], "v1.foo.com")
+	assert.Contains(t, createMsgs[0], "1.2.3.4")
 
-	assert.True(t, strings.Contains(createMsgs[1], "v1.foobar.com"))
-	assert.True(t, strings.Contains(createMsgs[1], "boom"))
+	assert.Contains(t, createMsgs[1], "v1.foobar.com")
+	assert.Contains(t, createMsgs[1], "boom")
 
-	assert.True(t, strings.Contains(createMsgs[2], "ns.foobar.com"))
-	assert.True(t, strings.Contains(createMsgs[2], "boom"))
+	assert.Contains(t, createMsgs[2], "ns.foobar.com")
+	assert.Contains(t, createMsgs[2], "boom")
 
-	assert.Equal(t, 2, len(stub.updateMsgs))
+	assert.Len(t, stub.updateMsgs, 2)
 	updateMsgs := getSortedChanges(stub.updateMsgs)
-	assert.Equal(t, 2, len(updateMsgs))
+	assert.Len(t, updateMsgs, 2)
 
-	assert.True(t, strings.Contains(updateMsgs[0], "v2.foo.com"))
-	assert.True(t, strings.Contains(updateMsgs[1], "v2.foobar.com"))
+	assert.Contains(t, updateMsgs[0], "v2.foo.com")
+	assert.Contains(t, updateMsgs[1], "v2.foobar.com")
 }
 
 // These tests use the foo.com and foobar.com zones and with filters set to both zones
@@ -712,29 +713,29 @@ func TestRfc2136ApplyChangesWithZonesFilters(t *testing.T) {
 	err = provider.ApplyChanges(context.Background(), p)
 	assert.NoError(t, err)
 
-	assert.Equal(t, 3, len(stub.createMsgs))
+	assert.Len(t, stub.createMsgs, 3)
 	createMsgs := getSortedChanges(stub.createMsgs)
-	assert.Equal(t, 3, len(createMsgs))
+	assert.Len(t, createMsgs, 3)
 
-	assert.True(t, strings.Contains(createMsgs[0], "v1.foo.com"))
-	assert.True(t, strings.Contains(createMsgs[0], "1.2.3.4"))
+	assert.Contains(t, createMsgs[0], "v1.foo.com")
+	assert.Contains(t, createMsgs[0], "1.2.3.4")
 
-	assert.True(t, strings.Contains(createMsgs[1], "v1.foobar.com"))
-	assert.True(t, strings.Contains(createMsgs[1], "boom"))
+	assert.Contains(t, createMsgs[1], "v1.foobar.com")
+	assert.Contains(t, createMsgs[1], "boom")
 
-	assert.True(t, strings.Contains(createMsgs[2], "ns.foobar.com"))
-	assert.True(t, strings.Contains(createMsgs[2], "boom"))
+	assert.Contains(t, createMsgs[2], "ns.foobar.com")
+	assert.Contains(t, createMsgs[2], "boom")
 
 	for _, s := range createMsgs {
-		assert.False(t, strings.Contains(s, "filtered-out.foo.bar"))
+		assert.NotContains(t, s, "filtered-out.foo.bar")
 	}
 
-	assert.Equal(t, 2, len(stub.updateMsgs))
+	assert.Len(t, stub.updateMsgs, 2)
 	updateMsgs := getSortedChanges(stub.updateMsgs)
-	assert.Equal(t, 2, len(updateMsgs))
+	assert.Len(t, updateMsgs, 2)
 
-	assert.True(t, strings.Contains(updateMsgs[0], "v2.foo.com"))
-	assert.True(t, strings.Contains(updateMsgs[1], "v2.foobar.com"))
+	assert.Contains(t, updateMsgs[0], "v2.foo.com")
+	assert.Contains(t, updateMsgs[1], "v2.foobar.com")
 
 }
 
@@ -770,16 +771,16 @@ func TestRfc2136ApplyChangesWithDifferentTTLs(t *testing.T) {
 	assert.NoError(t, err)
 
 	createRecords := extractUpdateSectionFromMessage(stub.createMsgs[0])
-	assert.Equal(t, 3, len(createRecords))
-	assert.True(t, strings.Contains(createRecords[0], "v1.foo.com"))
-	assert.True(t, strings.Contains(createRecords[0], "2.1.1.1"))
-	assert.True(t, strings.Contains(createRecords[0], "400"))
-	assert.True(t, strings.Contains(createRecords[1], "v2.foo.com"))
-	assert.True(t, strings.Contains(createRecords[1], "3.2.2.2"))
-	assert.True(t, strings.Contains(createRecords[1], "300"))
-	assert.True(t, strings.Contains(createRecords[2], "v3.foo.com"))
-	assert.True(t, strings.Contains(createRecords[2], "4.3.3.3"))
-	assert.True(t, strings.Contains(createRecords[2], "300"))
+	assert.Len(t, createRecords, 3)
+	assert.Contains(t, createRecords[0], "v1.foo.com")
+	assert.Contains(t, createRecords[0], "2.1.1.1")
+	assert.Contains(t, createRecords[0], "400")
+	assert.Contains(t, createRecords[1], "v2.foo.com")
+	assert.Contains(t, createRecords[1], "3.2.2.2")
+	assert.Contains(t, createRecords[1], "300")
+	assert.Contains(t, createRecords[2], "v3.foo.com")
+	assert.Contains(t, createRecords[2], "4.3.3.3")
+	assert.Contains(t, createRecords[2], "300")
 }
 
 func TestRfc2136ApplyChangesWithUpdate(t *testing.T) {
@@ -839,24 +840,24 @@ func TestRfc2136ApplyChangesWithUpdate(t *testing.T) {
 	err = provider.ApplyChanges(context.Background(), p)
 	assert.NoError(t, err)
 
-	assert.Equal(t, 4, len(stub.createMsgs))
-	assert.Equal(t, 2, len(stub.updateMsgs))
+	assert.Len(t, stub.createMsgs, 4)
+	assert.Len(t, stub.updateMsgs, 2)
 
-	assert.True(t, strings.Contains(stub.createMsgs[0].String(), "v1.foo.com"))
-	assert.True(t, strings.Contains(stub.createMsgs[0].String(), "1.2.3.4"))
-	assert.True(t, strings.Contains(stub.createMsgs[2].String(), "v1.foo.com"))
-	assert.True(t, strings.Contains(stub.createMsgs[2].String(), "1.2.3.5"))
+	assert.Contains(t, stub.createMsgs[0].String(), "v1.foo.com")
+	assert.Contains(t, stub.createMsgs[0].String(), "1.2.3.4")
+	assert.Contains(t, stub.createMsgs[2].String(), "v1.foo.com")
+	assert.Contains(t, stub.createMsgs[2].String(), "1.2.3.5")
 
-	assert.True(t, strings.Contains(stub.updateMsgs[0].String(), "v1.foo.com"))
-	assert.True(t, strings.Contains(stub.updateMsgs[0].String(), "1.2.3.4"))
+	assert.Contains(t, stub.updateMsgs[0].String(), "v1.foo.com")
+	assert.Contains(t, stub.updateMsgs[0].String(), "1.2.3.4")
 
-	assert.True(t, strings.Contains(stub.createMsgs[1].String(), "v1.foobar.com"))
-	assert.True(t, strings.Contains(stub.createMsgs[1].String(), "boom"))
-	assert.True(t, strings.Contains(stub.createMsgs[3].String(), "v1.foobar.com"))
-	assert.True(t, strings.Contains(stub.createMsgs[3].String(), "kablui"))
+	assert.Contains(t, stub.createMsgs[1].String(), "v1.foobar.com")
+	assert.Contains(t, stub.createMsgs[1].String(), "boom")
+	assert.Contains(t, stub.createMsgs[3].String(), "v1.foobar.com")
+	assert.Contains(t, stub.createMsgs[3].String(), "kablui")
 
-	assert.True(t, strings.Contains(stub.updateMsgs[1].String(), "v1.foobar.com"))
-	assert.True(t, strings.Contains(stub.updateMsgs[1].String(), "boom"))
+	assert.Contains(t, stub.updateMsgs[1].String(), "v1.foobar.com")
+	assert.Contains(t, stub.updateMsgs[1].String(), "boom")
 }
 
 func TestChunkBy(t *testing.T) {
@@ -890,12 +891,12 @@ func contains(arr []*endpoint.Endpoint, name string) bool {
 func TestCreateRfc2136StubProviderWithHosts(t *testing.T) {
 	stub := newStub()
 	provider, err := createRfc2136StubProviderWithHosts(stub)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	rawProvider, ok := provider.(*rfc2136Provider)
 	assert.True(t, ok, "expected provider to be of type *rfc2136Provider")
 
-	assert.Equal(t, 3, len(rawProvider.nameservers))
+	assert.Len(t, rawProvider.nameservers, 3)
 	assert.Equal(t, "rfc2136-host1:0", rawProvider.nameservers[0])
 	assert.Equal(t, "rfc2136-host2:0", rawProvider.nameservers[1])
 	assert.Equal(t, "rfc2136-host3:0", rawProvider.nameservers[2])
@@ -905,7 +906,7 @@ func TestCreateRfc2136StubProviderWithHosts(t *testing.T) {
 func TestRoundRobinLoadBalancing(t *testing.T) {
 	stub := newStubLB("round-robin", []string{"rfc2136-host1", "rfc2136-host2", "rfc2136-host3"})
 	_, err := createRfc2136StubProviderWithStrategy(stub, "round-robin")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	m := new(dns.Msg)
 	m.SetUpdate("foo.com.")
@@ -924,7 +925,7 @@ func TestRoundRobinLoadBalancing(t *testing.T) {
 func TestRandomLoadBalancing(t *testing.T) {
 	stub := newStubLB("random", []string{"rfc2136-host1", "rfc2136-host2", "rfc2136-host3"})
 	_, err := createRfc2136StubProviderWithStrategy(stub, "random")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	m := new(dns.Msg)
 	m.SetUpdate("foo.com.")
diff --git a/provider/scaleway/scaleway_test.go b/provider/scaleway/scaleway_test.go
index 45f09b321..eec95c695 100644
--- a/provider/scaleway/scaleway_test.go
+++ b/provider/scaleway/scaleway_test.go
@@ -26,6 +26,7 @@ import (
 	"github.com/scaleway/scaleway-sdk-go/scw"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+
 	"sigs.k8s.io/external-dns/endpoint"
 	"sigs.k8s.io/external-dns/plan"
 )
@@ -246,7 +247,7 @@ func TestScalewayProvider_AdjustEndpoints(t *testing.T) {
 	}
 
 	after, err := provider.AdjustEndpoints(before)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	for i := range after {
 		if !checkRecordEquality(after[i], expected[i]) {
 			t.Errorf("got record %s instead of %s", after[i], expected[i])
@@ -352,7 +353,7 @@ func TestScalewayProvider_Records(t *testing.T) {
 				found = true
 			}
 		}
-		assert.Equal(t, true, found)
+		assert.True(t, found)
 	}
 }
 
diff --git a/provider/transip/transip_test.go b/provider/transip/transip_test.go
index 1d781fa81..85709844e 100644
--- a/provider/transip/transip_test.go
+++ b/provider/transip/transip_test.go
@@ -70,39 +70,39 @@ func TestTransIPDnsEntriesAreEqual(t *testing.T) {
 		},
 	}
 
-	assert.Equal(t, true, dnsEntriesAreEqual(a, b))
+	assert.True(t, dnsEntriesAreEqual(a, b))
 
 	// change type on one of b's records
 	b[1].Type = "NS"
-	assert.Equal(t, false, dnsEntriesAreEqual(a, b))
+	assert.False(t, dnsEntriesAreEqual(a, b))
 	b[1].Type = "CNAME"
 
 	// change ttl on one of b's records
 	b[1].Expire = 1800
-	assert.Equal(t, false, dnsEntriesAreEqual(a, b))
+	assert.False(t, dnsEntriesAreEqual(a, b))
 	b[1].Expire = 3600
 
 	// change name on one of b's records
 	b[1].Name = "example.org"
-	assert.Equal(t, false, dnsEntriesAreEqual(a, b))
+	assert.False(t, dnsEntriesAreEqual(a, b))
 
 	// remove last entry of b
 	b = b[:1]
-	assert.Equal(t, false, dnsEntriesAreEqual(a, b))
+	assert.False(t, dnsEntriesAreEqual(a, b))
 }
 
 func TestTransIPGetMinimalValidTTL(t *testing.T) {
 	// test with 'unconfigured' TTL
 	ep := &endpoint.Endpoint{}
-	assert.EqualValues(t, defaultTTL, getMinimalValidTTL(ep))
+	assert.Equal(t, defaultTTL, getMinimalValidTTL(ep))
 
 	// test with lower than minimal ttl
 	ep.RecordTTL = (defaultTTL - 1)
-	assert.EqualValues(t, defaultTTL, getMinimalValidTTL(ep))
+	assert.Equal(t, defaultTTL, getMinimalValidTTL(ep))
 
 	// test with higher than minimal ttl
 	ep.RecordTTL = (defaultTTL + 1)
-	assert.EqualValues(t, defaultTTL+1, getMinimalValidTTL(ep))
+	assert.Equal(t, defaultTTL+1, getMinimalValidTTL(ep))
 }
 
 func TestTransIPRecordNameForEndpoint(t *testing.T) {
@@ -153,22 +153,22 @@ func TestTransIPAddEndpointToEntries(t *testing.T) {
 	// add endpoint to zone's entries
 	result := dnsEntriesForEndpoint(ep, zone.Name)
 
-	if assert.Equal(t, 2, len(result)) {
+	if assert.Len(t, result, 2) {
 		assert.Equal(t, "www", result[0].Name)
 		assert.Equal(t, "A", result[0].Type)
 		assert.Equal(t, "192.168.0.1", result[0].Content)
-		assert.EqualValues(t, 1800, result[0].Expire)
+		assert.Equal(t, 1800, result[0].Expire)
 		assert.Equal(t, "www", result[1].Name)
 		assert.Equal(t, "A", result[1].Type)
 		assert.Equal(t, "192.168.0.2", result[1].Content)
-		assert.EqualValues(t, 1800, result[1].Expire)
+		assert.Equal(t, 1800, result[1].Expire)
 	}
 
 	// try again with CNAME
 	ep.RecordType = "CNAME"
 	ep.Targets = []string{"foo.bar"}
 	result = dnsEntriesForEndpoint(ep, zone.Name)
-	if assert.Equal(t, 1, len(result)) {
+	if assert.Len(t, result, 1) {
 		assert.Equal(t, "CNAME", result[0].Type)
 		assert.Equal(t, "foo.bar.", result[0].Content)
 	}
@@ -256,11 +256,11 @@ func TestProviderRecords(t *testing.T) {
 
 	endpoints, err := p.Records(context.TODO())
 	if assert.NoError(t, err) {
-		if assert.Equal(t, 4, len(endpoints)) {
+		if assert.Len(t, endpoints, 4) {
 			assert.Equal(t, "www.example.org", endpoints[0].DNSName)
-			assert.EqualValues(t, "@", endpoints[0].Targets[0])
+			assert.Equal(t, "@", endpoints[0].Targets[0])
 			assert.Equal(t, "CNAME", endpoints[0].RecordType)
-			assert.Equal(t, 0, len(endpoints[0].Labels))
+			assert.Empty(t, endpoints[0].Labels)
 			assert.EqualValues(t, 1234, endpoints[0].RecordTTL)
 		}
 	}
@@ -341,7 +341,7 @@ func TestProviderEntriesForEndpoint(t *testing.T) {
 		RecordType: "A",
 	})
 	if assert.NoError(t, err) {
-		if assert.Equal(t, 2, len(entries)) {
+		if assert.Len(t, entries, 2) {
 			// only first and third entry should be returned
 			assert.Equal(t, dnsEntries[0], entries[0])
 			assert.Equal(t, dnsEntries[2], entries[1])
diff --git a/provider/ultradns/ultradns_test.go b/provider/ultradns/ultradns_test.go
index 380650e32..d0b9bddcd 100644
--- a/provider/ultradns/ultradns_test.go
+++ b/provider/ultradns/ultradns_test.go
@@ -28,7 +28,9 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 	udnssdk "github.com/ultradns/ultradns-sdk-go"
+
 	"sigs.k8s.io/external-dns/endpoint"
 	"sigs.k8s.io/external-dns/plan"
 )
@@ -106,14 +108,14 @@ func TestNewUltraDNSProvider(t *testing.T) {
 	_ = os.Setenv("ULTRADNS_BASEURL", "")
 	_ = os.Setenv("ULTRADNS_ACCOUNTNAME", "")
 	_, err := NewUltraDNSProvider(endpoint.NewDomainFilter([]string{"test-ultradns-provider.com"}), true)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 
 	_ = os.Unsetenv("ULTRADNS_PASSWORD")
 	_ = os.Unsetenv("ULTRADNS_USERNAME")
 	_ = os.Unsetenv("ULTRADNS_BASEURL")
 	_ = os.Unsetenv("ULTRADNS_ACCOUNTNAME")
 	_, err = NewUltraDNSProvider(endpoint.NewDomainFilter([]string{"test-ultradns-provider.com"}), true)
-	assert.NotNilf(t, err, "Expected to fail %s", "formatted")
+	assert.Errorf(t, err, "Expected to fail %s", "formatted")
 }
 
 // zones function test scenario
@@ -131,10 +133,10 @@ func TestUltraDNSProvider_Zones(t *testing.T) {
 	}
 
 	expected, _, _, err := provider.client.Zone.SelectWithOffsetWithLimit(zoneKey, 0, 1000)
-	assert.Nil(t, err)
+	require.NoError(t, err)
 	zones, err := provider.Zones(context.Background())
-	assert.Nil(t, err)
-	assert.Equal(t, reflect.DeepEqual(expected, zones), true)
+	require.NoError(t, err)
+	assert.True(t, reflect.DeepEqual(expected, zones))
 }
 
 // Records function test case
@@ -151,7 +153,7 @@ func TestUltraDNSProvider_Records(t *testing.T) {
 	rrsetKey := udnssdk.RRSetKey{}
 	expected, _, _, err := provider.client.RRSets.SelectWithOffsetWithLimit(rrsetKey, 0, 1000)
 	records, err := provider.Records(context.Background())
-	assert.Nil(t, err)
+	require.NoError(t, err)
 	for _, v := range records {
 		assert.Equal(t, fmt.Sprintf("%s.", v.DNSName), expected[0].OwnerName)
 		assert.Equal(t, v.RecordType, expected[0].RRType)
@@ -182,7 +184,7 @@ func TestUltraDNSProvider_ApplyChanges(t *testing.T) {
 	changes.Delete = []*endpoint.Endpoint{{DNSName: "test-ultradns-provider.com", Targets: endpoint.Targets{"1.1.2.2", "1.1.2.3", "1.1.2.4"}, RecordType: "A", RecordTTL: 100}}
 	changes.Delete = []*endpoint.Endpoint{{DNSName: "ttl.test-ultradns-provider.com", Targets: endpoint.Targets{"1.1.1.1"}, RecordType: "A", RecordTTL: 100}}
 	err := provider.ApplyChanges(context.Background(), changes)
-	assert.Nilf(t, err, "Should not fail %s", "formatted")
+	assert.NoErrorf(t, err, "Should not fail %s", "formatted")
 }
 
 // Testing function getSpecificRecord
@@ -203,7 +205,7 @@ func TestUltraDNSProvider_getSpecificRecord(t *testing.T) {
 		Name: "teamrest",
 	}
 	err := provider.getSpecificRecord(context.Background(), recordSetKey)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 }
 
 // Fail case scenario testing where CNAME and TXT Record name are same
@@ -225,7 +227,7 @@ func TestUltraDNSProvider_ApplyChangesCNAME(t *testing.T) {
 	}
 
 	err := provider.ApplyChanges(context.Background(), changes)
-	assert.NotNil(t, err)
+	assert.Error(t, err)
 }
 
 // This will work if you would set the environment variables such as "ULTRADNS_INTEGRATION" and zone should be available "kubernetes-ultradns-provider-test.com"
@@ -243,7 +245,7 @@ func TestUltraDNSProvider_ApplyChanges_Integration(t *testing.T) {
 		}
 
 		err = providerUltradns.ApplyChanges(context.Background(), changes)
-		assert.Nil(t, err)
+		require.NoError(t, err)
 
 		rrsetKey := udnssdk.RRSetKey{
 			Zone: "kubernetes-ultradns-provider-test.com.",
@@ -252,7 +254,7 @@ func TestUltraDNSProvider_ApplyChanges_Integration(t *testing.T) {
 		}
 
 		rrsets, _ := providerUltradns.client.RRSets.Select(rrsetKey)
-		assert.Equal(t, rrsets[0].RData[0], "1.1.1.1")
+		assert.Equal(t, "1.1.1.1", rrsets[0].RData[0])
 
 		rrsetKey = udnssdk.RRSetKey{
 			Zone: "kubernetes-ultradns-provider-test.com.",
@@ -261,7 +263,7 @@ func TestUltraDNSProvider_ApplyChanges_Integration(t *testing.T) {
 		}
 
 		rrsets, _ = providerUltradns.client.RRSets.Select(rrsetKey)
-		assert.Equal(t, rrsets[0].RData[0], "2001:db8:85a3:0:0:8a2e:370:7334")
+		assert.Equal(t, "2001:db8:85a3:0:0:8a2e:370:7334", rrsets[0].RData[0])
 
 		changes = &plan.Changes{}
 		changes.UpdateNew = []*endpoint.Endpoint{
@@ -269,7 +271,7 @@ func TestUltraDNSProvider_ApplyChanges_Integration(t *testing.T) {
 			{DNSName: "ttl.kubernetes-ultradns-provider-test.com", Targets: endpoint.Targets{"2001:0db8:85a3:0000:0000:8a2e:0370:7335"}, RecordType: "AAAA", RecordTTL: 100},
 		}
 		err = providerUltradns.ApplyChanges(context.Background(), changes)
-		assert.Nil(t, err)
+		require.NoError(t, err)
 
 		rrsetKey = udnssdk.RRSetKey{
 			Zone: "kubernetes-ultradns-provider-test.com.",
@@ -278,7 +280,7 @@ func TestUltraDNSProvider_ApplyChanges_Integration(t *testing.T) {
 		}
 
 		rrsets, _ = providerUltradns.client.RRSets.Select(rrsetKey)
-		assert.Equal(t, rrsets[0].RData[0], "1.1.2.2")
+		assert.Equal(t, "1.1.2.2", rrsets[0].RData[0])
 
 		rrsetKey = udnssdk.RRSetKey{
 			Zone: "kubernetes-ultradns-provider-test.com.",
@@ -287,7 +289,7 @@ func TestUltraDNSProvider_ApplyChanges_Integration(t *testing.T) {
 		}
 
 		rrsets, _ = providerUltradns.client.RRSets.Select(rrsetKey)
-		assert.Equal(t, rrsets[0].RData[0], "2001:db8:85a3:0:0:8a2e:370:7335")
+		assert.Equal(t, "2001:db8:85a3:0:0:8a2e:370:7335", rrsets[0].RData[0])
 
 		changes = &plan.Changes{}
 		changes.Delete = []*endpoint.Endpoint{
@@ -296,13 +298,13 @@ func TestUltraDNSProvider_ApplyChanges_Integration(t *testing.T) {
 		}
 
 		err = providerUltradns.ApplyChanges(context.Background(), changes)
-		assert.Nil(t, err)
+		require.NoError(t, err)
 
 		resp, _ := providerUltradns.client.Do("GET", "zones/kubernetes-ultradns-provider-test.com./rrsets/AAAA/ttl.kubernetes-ultradns-provider-test.com.", nil, udnssdk.RRSetListDTO{})
-		assert.Equal(t, resp.Status, "404 Not Found")
+		assert.Equal(t, "404 Not Found", resp.Status)
 
 		resp, _ = providerUltradns.client.Do("GET", "zones/kubernetes-ultradns-provider-test.com./rrsets/A/kubernetes-ultradns-provider-test.com.", nil, udnssdk.RRSetListDTO{})
-		assert.Equal(t, resp.Status, "404 Not Found")
+		assert.Equal(t, "404 Not Found", resp.Status)
 
 	}
 }
@@ -321,7 +323,7 @@ func TestUltraDNSProvider_ApplyChanges_MultipleTarget_integeration(t *testing.T)
 		}
 
 		err = provider.ApplyChanges(context.Background(), changes)
-		assert.Nil(t, err)
+		assert.NoError(t, err)
 
 		rrsetKey := udnssdk.RRSetKey{
 			Zone: "kubernetes-ultradns-provider-test.com.",
@@ -330,13 +332,13 @@ func TestUltraDNSProvider_ApplyChanges_MultipleTarget_integeration(t *testing.T)
 		}
 
 		rrsets, _ := provider.client.RRSets.Select(rrsetKey)
-		assert.Equal(t, rrsets[0].RData, []string{"1.1.1.1", "1.1.2.2"})
+		assert.Equal(t, []string{"1.1.1.1", "1.1.2.2"}, rrsets[0].RData)
 
 		changes = &plan.Changes{}
 		changes.UpdateNew = []*endpoint.Endpoint{{DNSName: "kubernetes-ultradns-provider-test.com", Targets: endpoint.Targets{"1.1.2.2", "192.168.0.24", "1.2.3.4"}, RecordType: "A", RecordTTL: 100}}
 
 		err = provider.ApplyChanges(context.Background(), changes)
-		assert.Nil(t, err)
+		require.NoError(t, err)
 
 		rrsetKey = udnssdk.RRSetKey{
 			Zone: "kubernetes-ultradns-provider-test.com.",
@@ -345,14 +347,14 @@ func TestUltraDNSProvider_ApplyChanges_MultipleTarget_integeration(t *testing.T)
 		}
 
 		rrsets, _ = provider.client.RRSets.Select(rrsetKey)
-		assert.Equal(t, rrsets[0].RData, []string{"1.1.2.2", "192.168.0.24", "1.2.3.4"})
+		assert.Equal(t, []string{"1.1.2.2", "192.168.0.24", "1.2.3.4"}, rrsets[0].RData)
 
 		changes = &plan.Changes{}
 		changes.UpdateNew = []*endpoint.Endpoint{{DNSName: "kubernetes-ultradns-provider-test.com", Targets: endpoint.Targets{"1.1.2.2"}, RecordType: "A", RecordTTL: 100}}
 
 		err = provider.ApplyChanges(context.Background(), changes)
 
-		assert.Nil(t, err)
+		assert.NoError(t, err)
 
 		rrsetKey = udnssdk.RRSetKey{
 			Zone: "kubernetes-ultradns-provider-test.com.",
@@ -361,17 +363,17 @@ func TestUltraDNSProvider_ApplyChanges_MultipleTarget_integeration(t *testing.T)
 		}
 
 		rrsets, _ = provider.client.RRSets.Select(rrsetKey)
-		assert.Equal(t, rrsets[0].RData, []string{"1.1.2.2"})
+		assert.Equal(t, []string{"1.1.2.2"}, rrsets[0].RData)
 
 		changes = &plan.Changes{}
 		changes.Delete = []*endpoint.Endpoint{{DNSName: "kubernetes-ultradns-provider-test.com", Targets: endpoint.Targets{"1.1.2.2", "192.168.0.24"}, RecordType: "A"}}
 
 		err = provider.ApplyChanges(context.Background(), changes)
 
-		assert.Nil(t, err)
+		assert.NoError(t, err)
 
 		resp, _ := provider.client.Do("GET", "zones/kubernetes-ultradns-provider-test.com./rrsets/A/kubernetes-ultradns-provider-test.com.", nil, udnssdk.RRSetListDTO{})
-		assert.Equal(t, resp.Status, "404 Not Found")
+		assert.Equal(t, "404 Not Found", resp.Status)
 
 	}
 }
@@ -440,10 +442,10 @@ func TestUltraDNSProvider_MultipleTargetAAAA(t *testing.T) {
 			{DNSName: "ttl.kubernetes-ultradns-provider-test.com", Targets: endpoint.Targets{"2001:0db8:85a3:0000:0000:8a2e:0370:7334", "2001:0db8:85a3:0000:0000:8a2e:0370:7335"}, RecordType: "AAAA", RecordTTL: 100},
 		}
 		err := provider.ApplyChanges(context.Background(), changes)
-		assert.NotNilf(t, err, "We wanted it to fail since multiple AAAA targets are not allowed %s", "formatted")
+		assert.Errorf(t, err, "We wanted it to fail since multiple AAAA targets are not allowed %s", "formatted")
 
 		resp, _ := provider.client.Do("GET", "zones/kubernetes-ultradns-provider-test.com./rrsets/AAAA/ttl.kubernetes-ultradns-provider-test.com.", nil, udnssdk.RRSetListDTO{})
-		assert.Equal(t, resp.Status, "404 Not Found")
+		assert.Equal(t, "404 Not Found", resp.Status)
 		_ = os.Unsetenv("ULTRADNS_POOL_TYPE")
 	}
 }
@@ -461,21 +463,19 @@ func TestUltraDNSProvider_MultipleTargetAAAARDPool(t *testing.T) {
 			{DNSName: "ttl.kubernetes-ultradns-provider-test.com", Targets: endpoint.Targets{"2001:0db8:85a3:0000:0000:8a2e:0370:7334", "2001:0db8:85a3:0000:0000:8a2e:0370:7335"}, RecordType: "AAAA", RecordTTL: 100},
 		}
 		err := provider.ApplyChanges(context.Background(), changes)
-		assert.Nilf(t, err, " multiple AAAA targets are allowed when pool is RDPool %s", "formatted")
+		require.NoErrorf(t, err, " multiple AAAA targets are allowed when pool is RDPool %s", "formatted")
 
 		resp, _ := provider.client.Do("GET", "zones/kubernetes-ultradns-provider-test.com./rrsets/AAAA/ttl.kubernetes-ultradns-provider-test.com.", nil, udnssdk.RRSetListDTO{})
-		assert.Equal(t, resp.Status, "200 OK")
+		assert.Equal(t, "200 OK", resp.Status)
 
 		changes = &plan.Changes{}
 		changes.Delete = []*endpoint.Endpoint{{DNSName: "ttl.kubernetes-ultradns-provider-test.com", Targets: endpoint.Targets{"2001:0db8:85a3:0000:0000:8a2e:0370:7334", "2001:0db8:85a3:0000:0000:8a2e:0370:7335"}, RecordType: "AAAA"}}
 
 		err = provider.ApplyChanges(context.Background(), changes)
-
-		assert.Nil(t, err)
+		require.NoError(t, err)
 
 		resp, _ = provider.client.Do("GET", "zones/kubernetes-ultradns-provider-test.com./rrsets/A/kubernetes-ultradns-provider-test.com.", nil, udnssdk.RRSetListDTO{})
-		assert.Equal(t, resp.Status, "404 Not Found")
-
+		assert.Equal(t, "404 Not Found", resp.Status)
 	}
 }
 
@@ -493,10 +493,10 @@ func TestUltraDNSProvider_MultipleTargetCNAME(t *testing.T) {
 		}
 		err = provider.ApplyChanges(context.Background(), changes)
 
-		assert.NotNilf(t, err, "We wanted it to fail since multiple CNAME targets are not allowed %s", "formatted")
+		assert.Errorf(t, err, "We wanted it to fail since multiple CNAME targets are not allowed %s", "formatted")
 
 		resp, _ := provider.client.Do("GET", "zones/kubernetes-ultradns-provider-test.com./rrsets/CNAME/kubernetes-ultradns-provider-test.com.", nil, udnssdk.RRSetListDTO{})
-		assert.Equal(t, resp.Status, "404 Not Found")
+		assert.Equal(t, "404 Not Found", resp.Status)
 	}
 }
 
@@ -540,7 +540,7 @@ func TestNewUltraDNSProvider_FailCases(t *testing.T) {
 	_ = os.Setenv("ULTRADNS_ACCOUNTNAME", "")
 	_ = os.Setenv("ULTRADNS_POOL_TYPE", "xyz")
 	_, err := NewUltraDNSProvider(endpoint.NewDomainFilter([]string{"test-ultradns-provider.com"}), true)
-	assert.NotNilf(t, err, "Pool Type other than given type not working %s", "formatted")
+	assert.Errorf(t, err, "Pool Type other than given type not working %s", "formatted")
 
 	_ = os.Setenv("ULTRADNS_USERNAME", "")
 	_ = os.Setenv("ULTRADNS_PASSWORD", "")
@@ -548,7 +548,7 @@ func TestNewUltraDNSProvider_FailCases(t *testing.T) {
 	_ = os.Setenv("ULTRADNS_ACCOUNTNAME", "")
 	_ = os.Setenv("ULTRADNS_ENABLE_PROBING", "adefg")
 	_, err = NewUltraDNSProvider(endpoint.NewDomainFilter([]string{"test-ultradns-provider.com"}), true)
-	assert.NotNilf(t, err, "Probe value other than given values not working  %s", "formatted")
+	assert.Errorf(t, err, "Probe value other than given values not working  %s", "formatted")
 
 	_ = os.Setenv("ULTRADNS_USERNAME", "")
 	_ = os.Setenv("ULTRADNS_PASSWORD", "")
@@ -556,21 +556,21 @@ func TestNewUltraDNSProvider_FailCases(t *testing.T) {
 	_ = os.Setenv("ULTRADNS_ACCOUNTNAME", "")
 	_ = os.Setenv("ULTRADNS_ENABLE_ACTONPROBE", "adefg")
 	_, err = NewUltraDNSProvider(endpoint.NewDomainFilter([]string{"test-ultradns-provider.com"}), true)
-	assert.NotNilf(t, err, "ActOnProbe value other than given values not working %s", "formatted")
+	assert.Errorf(t, err, "ActOnProbe value other than given values not working %s", "formatted")
 
 	_ = os.Setenv("ULTRADNS_USERNAME", "")
 	_ = os.Setenv("ULTRADNS_BASEURL", "")
 	_ = os.Unsetenv("ULTRADNS_PASSWORD")
 	_ = os.Setenv("ULTRADNS_ACCOUNTNAME", "")
 	_, err = NewUltraDNSProvider(endpoint.NewDomainFilter([]string{"test-ultradns-provider.com"}), true)
-	assert.NotNilf(t, err, "Expected to give error if password is not set %s", "formatted")
+	assert.Errorf(t, err, "Expected to give error if password is not set %s", "formatted")
 
 	_ = os.Setenv("ULTRADNS_USERNAME", "")
 	_ = os.Setenv("ULTRADNS_PASSWORD", "")
 	_ = os.Unsetenv("ULTRADNS_BASEURL")
 	_ = os.Setenv("ULTRADNS_ACCOUNTNAME", "")
 	_, err = NewUltraDNSProvider(endpoint.NewDomainFilter([]string{"test-ultradns-provider.com"}), true)
-	assert.NotNilf(t, err, "Expected to give error if baseurl is not set %s", "formatted")
+	assert.Errorf(t, err, "Expected to give error if baseurl is not set %s", "formatted")
 
 	_ = os.Setenv("ULTRADNS_USERNAME", "")
 	_ = os.Setenv("ULTRADNS_BASEURL", "")
@@ -580,7 +580,7 @@ func TestNewUltraDNSProvider_FailCases(t *testing.T) {
 	_ = os.Unsetenv("ULTRADNS_ENABLE_PROBING")
 	_ = os.Unsetenv("ULTRADNS_POOL_TYPE")
 	_, accounterr := NewUltraDNSProvider(endpoint.NewDomainFilter([]string{"test-ultradns-provider.com"}), true)
-	assert.Nil(t, accounterr)
+	assert.NoError(t, accounterr)
 }
 
 // Testing success scenarios for newly introduced environment variables
@@ -591,7 +591,7 @@ func TestNewUltraDNSProvider_NewEnvVariableSuccessCases(t *testing.T) {
 	_ = os.Setenv("ULTRADNS_ACCOUNTNAME", "")
 	_ = os.Setenv("ULTRADNS_POOL_TYPE", "rdpool")
 	_, err := NewUltraDNSProvider(endpoint.NewDomainFilter([]string{"test-ultradns-provider.com"}), true)
-	assert.Nilf(t, err, "Pool Type not working in proper scenario %s", "formatted")
+	assert.NoErrorf(t, err, "Pool Type not working in proper scenario %s", "formatted")
 
 	_ = os.Setenv("ULTRADNS_USERNAME", "")
 	_ = os.Setenv("ULTRADNS_PASSWORD", "")
@@ -599,7 +599,7 @@ func TestNewUltraDNSProvider_NewEnvVariableSuccessCases(t *testing.T) {
 	_ = os.Setenv("ULTRADNS_ACCOUNTNAME", "")
 	_ = os.Setenv("ULTRADNS_ENABLE_PROBING", "false")
 	_, err1 := NewUltraDNSProvider(endpoint.NewDomainFilter([]string{"test-ultradns-provider.com"}), true)
-	assert.Nilf(t, err1, "Probe given value is  not working %s", "formatted")
+	assert.NoErrorf(t, err1, "Probe given value is  not working %s", "formatted")
 
 	_ = os.Setenv("ULTRADNS_USERNAME", "")
 	_ = os.Setenv("ULTRADNS_PASSWORD", "")
@@ -607,7 +607,7 @@ func TestNewUltraDNSProvider_NewEnvVariableSuccessCases(t *testing.T) {
 	_ = os.Setenv("ULTRADNS_ACCOUNTNAME", "")
 	_ = os.Setenv("ULTRADNS_ENABLE_ACTONPROBE", "true")
 	_, err2 := NewUltraDNSProvider(endpoint.NewDomainFilter([]string{"test-ultradns-provider.com"}), true)
-	assert.Nilf(t, err2, "ActOnProbe given value is not working %s", "formatted")
+	assert.NoErrorf(t, err2, "ActOnProbe given value is not working %s", "formatted")
 }
 
 // Base64 Bad string decoding scenario
@@ -618,7 +618,7 @@ func TestNewUltraDNSProvider_Base64DecodeFailcase(t *testing.T) {
 	_ = os.Setenv("ULTRADNS_ACCOUNTNAME", "")
 	_ = os.Setenv("ULTRADNS_ENABLE_ACTONPROBE", "true")
 	_, err := NewUltraDNSProvider(endpoint.NewDomainFilter([]string{"test-ultradns-provider.com"}), true)
-	assert.NotNilf(t, err, "Base64 decode should fail in this case %s", "formatted")
+	assert.Errorf(t, err, "Base64 decode should fail in this case %s", "formatted")
 }
 
 func TestUltraDNSProvider_PoolConversionCase(t *testing.T) {
@@ -632,10 +632,10 @@ func TestUltraDNSProvider_PoolConversionCase(t *testing.T) {
 		changes := &plan.Changes{}
 		changes.Create = []*endpoint.Endpoint{{DNSName: "ttl.kubernetes-ultradns-provider-test.com", Targets: endpoint.Targets{"1.1.1.1", "1.2.3.4"}, RecordType: "A", RecordTTL: 100}}
 		err := provider.ApplyChanges(context.Background(), changes)
-		assert.Nilf(t, err, " multiple A record creation with SBPool %s", "formatted")
+		assert.NoErrorf(t, err, " multiple A record creation with SBPool %s", "formatted")
 
 		resp, _ := provider.client.Do("GET", "zones/kubernetes-ultradns-provider-test.com./rrsets/A/ttl.kubernetes-ultradns-provider-test.com.", nil, udnssdk.RRSetListDTO{})
-		assert.Equal(t, resp.Status, "200 OK")
+		assert.Equal(t, "200 OK", resp.Status)
 
 		// Converting to RD Pool
 		_ = os.Setenv("ULTRADNS_POOL_TYPE", "rdpool")
@@ -643,9 +643,9 @@ func TestUltraDNSProvider_PoolConversionCase(t *testing.T) {
 		changes = &plan.Changes{}
 		changes.UpdateNew = []*endpoint.Endpoint{{DNSName: "ttl.kubernetes-ultradns-provider-test.com", Targets: endpoint.Targets{"1.1.1.1", "1.2.3.5"}, RecordType: "A"}}
 		err = provider.ApplyChanges(context.Background(), changes)
-		assert.Nil(t, err)
+		assert.NoError(t, err)
 		resp, _ = provider.client.Do("GET", "zones/kubernetes-ultradns-provider-test.com./rrsets/A/ttl.kubernetes-ultradns-provider-test.com.", nil, udnssdk.RRSetListDTO{})
-		assert.Equal(t, resp.Status, "200 OK")
+		assert.Equal(t, "200 OK", resp.Status)
 
 		// Converting back to SB Pool
 		_ = os.Setenv("ULTRADNS_POOL_TYPE", "sbpool")
@@ -653,17 +653,17 @@ func TestUltraDNSProvider_PoolConversionCase(t *testing.T) {
 		changes = &plan.Changes{}
 		changes.UpdateNew = []*endpoint.Endpoint{{DNSName: "ttl.kubernetes-ultradns-provider-test.com", Targets: endpoint.Targets{"1.1.1.1", "1.2.3.4"}, RecordType: "A"}}
 		err = provider.ApplyChanges(context.Background(), changes)
-		assert.Nil(t, err)
+		assert.NoError(t, err)
 		resp, _ = provider.client.Do("GET", "zones/kubernetes-ultradns-provider-test.com./rrsets/A/ttl.kubernetes-ultradns-provider-test.com.", nil, udnssdk.RRSetListDTO{})
-		assert.Equal(t, resp.Status, "200 OK")
+		assert.Equal(t, "200 OK", resp.Status)
 
 		// Deleting Record
 		changes = &plan.Changes{}
 		changes.Delete = []*endpoint.Endpoint{{DNSName: "ttl.kubernetes-ultradns-provider-test.com", Targets: endpoint.Targets{"1.1.1.1", "1.2.3.4"}, RecordType: "A"}}
 		err = provider.ApplyChanges(context.Background(), changes)
-		assert.Nil(t, err)
+		assert.NoError(t, err)
 		resp, _ = provider.client.Do("GET", "zones/kubernetes-ultradns-provider-test.com./rrsets/A/kubernetes-ultradns-provider-test.com.", nil, udnssdk.RRSetListDTO{})
-		assert.Equal(t, resp.Status, "404 Not Found")
+		assert.Equal(t, "404 Not Found", resp.Status)
 	}
 }
 
@@ -674,13 +674,13 @@ func TestUltraDNSProvider_DomainFilter(t *testing.T) {
 	} else {
 		provider, _ := NewUltraDNSProvider(endpoint.NewDomainFilter([]string{"kubernetes-ultradns-provider-test.com", "kubernetes-ultradns-provider-test.com"}), true)
 		zones, err := provider.Zones(context.Background())
-		assert.Equal(t, zones[0].Properties.Name, "kubernetes-ultradns-provider-test.com.")
-		assert.Equal(t, zones[1].Properties.Name, "kubernetes-ultradns-provider-test.com.")
-		assert.Nilf(t, err, " Multiple domain filter failed %s", "formatted")
+		assert.Equal(t, "kubernetes-ultradns-provider-test.com.", zones[0].Properties.Name)
+		assert.Equal(t, "kubernetes-ultradns-provider-test.com.", zones[1].Properties.Name)
+		assert.NoErrorf(t, err, " Multiple domain filter failed %s", "formatted")
 
 		provider, _ = NewUltraDNSProvider(endpoint.NewDomainFilter([]string{}), true)
 		zones, err = provider.Zones(context.Background())
-		assert.Nilf(t, err, " Multiple domain filter failed %s", "formatted")
+		assert.NoErrorf(t, err, " Multiple domain filter failed %s", "formatted")
 
 	}
 }
@@ -692,7 +692,7 @@ func TestUltraDNSProvider_DomainFiltersZonesFailCase(t *testing.T) {
 	} else {
 		provider, _ := NewUltraDNSProvider(endpoint.NewDomainFilter([]string{"kubernetes-ultradns-provider-test.com", "kubernetes-uldsvdsvadvvdsvadvstradns-provider-test.com"}), true)
 		_, err := provider.Zones(context.Background())
-		assert.NotNilf(t, err, " Multiple domain filter failed %s", "formatted")
+		assert.Errorf(t, err, " Multiple domain filter failed %s", "formatted")
 	}
 }
 
@@ -713,10 +713,10 @@ func TestUltraDNSProvider_DomainFilterZonesMocked(t *testing.T) {
 
 	// When AccountName not given
 	expected, _, _, err := provider.client.Zone.SelectWithOffsetWithLimit(zoneKey, 0, 1000)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	zones, err := provider.Zones(context.Background())
-	assert.Nil(t, err)
-	assert.Equal(t, reflect.DeepEqual(expected, zones), true)
+	assert.NoError(t, err)
+	assert.True(t, reflect.DeepEqual(expected, zones))
 	accountName = "teamrest"
 	// When AccountName is set
 	provider = &UltraDNSProvider{
@@ -732,10 +732,10 @@ func TestUltraDNSProvider_DomainFilterZonesMocked(t *testing.T) {
 	}
 
 	expected, _, _, err = provider.client.Zone.SelectWithOffsetWithLimit(zoneKey, 0, 1000)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	zones, err = provider.Zones(context.Background())
-	assert.Nil(t, err)
-	assert.Equal(t, reflect.DeepEqual(expected, zones), true)
+	assert.NoError(t, err)
+	assert.True(t, reflect.DeepEqual(expected, zones))
 
 	// When zone is not given but account is provided
 	provider = &UltraDNSProvider{
@@ -749,8 +749,8 @@ func TestUltraDNSProvider_DomainFilterZonesMocked(t *testing.T) {
 	}
 
 	expected, _, _, err = provider.client.Zone.SelectWithOffsetWithLimit(zoneKey, 0, 1000)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	zones, err = provider.Zones(context.Background())
-	assert.Nil(t, err)
-	assert.Equal(t, reflect.DeepEqual(expected, zones), true)
+	assert.NoError(t, err)
+	assert.True(t, reflect.DeepEqual(expected, zones))
 }
diff --git a/provider/webhook/api/httpapi_test.go b/provider/webhook/api/httpapi_test.go
index 82af2ac84..18856753a 100644
--- a/provider/webhook/api/httpapi_test.go
+++ b/provider/webhook/api/httpapi_test.go
@@ -30,6 +30,7 @@ import (
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+
 	"sigs.k8s.io/external-dns/endpoint"
 	"sigs.k8s.io/external-dns/plan"
 )
@@ -228,7 +229,7 @@ func TestRecordsHandlerWithMixedCase(t *testing.T) {
 	providerAPIServer.RecordsHandler(w, req)
 	res := w.Result()
 	require.Equal(t, http.StatusNoContent, res.StatusCode)
-	assert.Equal(t, 1, len(records))
+	assert.Len(t, records, 1)
 }
 
 func TestAdjustEndpointsHandlerWithInvalidRequest(t *testing.T) {
diff --git a/provider/webhook/webhook_test.go b/provider/webhook/webhook_test.go
index bb73e5ceb..85c2a3b55 100644
--- a/provider/webhook/webhook_test.go
+++ b/provider/webhook/webhook_test.go
@@ -125,7 +125,7 @@ func TestRecords(t *testing.T) {
 			w.Write([]byte(`{}`))
 			return
 		}
-		require.Equal(t, "/records", r.URL.Path)
+		assert.Equal(t, "/records", r.URL.Path)
 		w.Write([]byte(`[{
 			"dnsName" : "test.example.com"
 		}]`))
@@ -149,7 +149,7 @@ func TestRecordsWithErrors(t *testing.T) {
 			w.Write([]byte(`{}`))
 			return
 		}
-		require.Equal(t, "/records", r.URL.Path)
+		assert.Equal(t, "/records", r.URL.Path)
 		w.WriteHeader(http.StatusInternalServerError)
 	}))
 	defer svr.Close()
@@ -157,7 +157,7 @@ func TestRecordsWithErrors(t *testing.T) {
 	p, err := NewWebhookProvider(svr.URL)
 	require.NoError(t, err)
 	_, err = p.Records(context.Background())
-	require.NotNil(t, err)
+	require.Error(t, err)
 	require.ErrorIs(t, err, provider.SoftError)
 }
 
@@ -231,7 +231,7 @@ func TestApplyChanges(t *testing.T) {
 			w.Write([]byte(`{}`))
 			return
 		}
-		require.Equal(t, "/records", r.URL.Path)
+		assert.Equal(t, "/records", r.URL.Path)
 		if successfulApplyChanges {
 			w.WriteHeader(http.StatusNoContent)
 		} else {
@@ -248,7 +248,7 @@ func TestApplyChanges(t *testing.T) {
 	successfulApplyChanges = false
 
 	err = p.ApplyChanges(context.TODO(), nil)
-	require.NotNil(t, err)
+	require.Error(t, err)
 	require.ErrorIs(t, err, provider.SoftError)
 }
 
@@ -281,7 +281,7 @@ func TestApplyChanges_StatusCodeError(t *testing.T) {
 			w.Write([]byte(`{}`))
 			return
 		}
-		require.Equal(t, webhookapi.UrlRecords, r.URL.Path)
+		assert.Equal(t, webhookapi.UrlRecords, r.URL.Path)
 		w.WriteHeader(http.StatusNetworkAuthenticationRequired)
 	}))
 	defer svr.Close()
@@ -290,7 +290,7 @@ func TestApplyChanges_StatusCodeError(t *testing.T) {
 	require.NoError(t, err)
 
 	err = p.ApplyChanges(context.TODO(), nil)
-	require.NotNil(t, err)
+	require.Error(t, err)
 	require.NotErrorIs(t, err, provider.SoftError)
 	assert.Contains(t, err.Error(), "failed to apply changes with code 511")
 }
@@ -302,7 +302,7 @@ func TestAdjustEndpoints(t *testing.T) {
 			w.Write([]byte(`{}`))
 			return
 		}
-		require.Equal(t, webhookapi.UrlAdjustEndpoints, r.URL.Path)
+		assert.Equal(t, webhookapi.UrlAdjustEndpoints, r.URL.Path)
 
 		var endpoints []*endpoint.Endpoint
 		defer r.Body.Close()
@@ -354,7 +354,7 @@ func TestAdjustendpointsWithError(t *testing.T) {
 			w.Write([]byte(`{}`))
 			return
 		}
-		require.Equal(t, webhookapi.UrlAdjustEndpoints, r.URL.Path)
+		assert.Equal(t, webhookapi.UrlAdjustEndpoints, r.URL.Path)
 		w.WriteHeader(http.StatusInternalServerError)
 	}))
 	defer svr.Close()
@@ -386,17 +386,17 @@ func TestApplyChangesWithProviderSpecificProperty(t *testing.T) {
 		}
 		if r.URL.Path == "/records" {
 			w.Header().Set(webhookapi.ContentTypeHeader, webhookapi.MediaTypeFormatAndVersion)
-			// assert that the request contains the provider specific property
+			// assert that the request contains the provider-specific property
 			var changes plan.Changes
 			defer r.Body.Close()
 			b, err := io.ReadAll(r.Body)
-			require.Nil(t, err)
+			assert.NoError(t, err)
 			err = json.Unmarshal(b, &changes)
-			require.Nil(t, err)
-			require.Len(t, changes.Create, 1)
-			require.Len(t, changes.Create[0].ProviderSpecific, 1)
-			require.Equal(t, "prop1", changes.Create[0].ProviderSpecific[0].Name)
-			require.Equal(t, "value1", changes.Create[0].ProviderSpecific[0].Value)
+			assert.NoError(t, err)
+			assert.Len(t, changes.Create, 1)
+			assert.Len(t, changes.Create[0].ProviderSpecific, 1)
+			assert.Equal(t, "prop1", changes.Create[0].ProviderSpecific[0].Name)
+			assert.Equal(t, "value1", changes.Create[0].ProviderSpecific[0].Value)
 			w.WriteHeader(http.StatusNoContent)
 			return
 		}
diff --git a/provider/zonefinder_test.go b/provider/zonefinder_test.go
index 751b326b7..b5afb047f 100644
--- a/provider/zonefinder_test.go
+++ b/provider/zonefinder_test.go
@@ -21,6 +21,7 @@ import (
 
 	log "github.com/sirupsen/logrus"
 	"github.com/stretchr/testify/assert"
+
 	"sigs.k8s.io/external-dns/internal/testutils"
 )
 
@@ -53,13 +54,13 @@ func TestZoneIDName(t *testing.T) {
 
 	// no possible zone for entry
 	zoneID, zoneName = z.FindZone("name.qux.foo")
-	assert.Equal(t, "", zoneName)
-	assert.Equal(t, "", zoneID)
+	assert.Empty(t, zoneName)
+	assert.Empty(t, zoneID)
 
 	// no possible zone for entry of a substring to valid a zone
 	zoneID, zoneName = z.FindZone("nomatch-foo.bar")
-	assert.Equal(t, "", zoneName)
-	assert.Equal(t, "", zoneID)
+	assert.Empty(t, zoneName)
+	assert.Empty(t, zoneID)
 
 	// entry's suffix matches a subdomain but doesn't belong there
 	zoneID, zoneName = z.FindZone("name-foo.qux.baz")
diff --git a/registry/dynamodb_test.go b/registry/dynamodb_test.go
index e6e71b47d..091927fab 100644
--- a/registry/dynamodb_test.go
+++ b/registry/dynamodb_test.go
@@ -29,6 +29,7 @@ import (
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"k8s.io/apimachinery/pkg/util/sets"
+
 	"sigs.k8s.io/external-dns/endpoint"
 	"sigs.k8s.io/external-dns/internal/testutils"
 	"sigs.k8s.io/external-dns/plan"
@@ -249,7 +250,7 @@ func TestDynamoDBRegistryRecords(t *testing.T) {
 	})
 
 	records, err := r.Records(ctx)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	assert.True(t, testutils.SameEndpoints(records, expectedRecords))
 }
@@ -1080,11 +1081,11 @@ func TestDynamoDBRegistryApplyChanges(t *testing.T) {
 
 			r, _ := NewDynamoDBRegistry(p, "test-owner", api, "test-table", "txt.", "", "", []string{}, []string{}, nil, time.Hour)
 			_, err := r.Records(ctx)
-			require.Nil(t, err)
+			require.NoError(t, err)
 
 			err = r.ApplyChanges(ctx, &tc.changes)
 			if tc.expectedError == "" {
-				assert.Nil(t, err)
+				assert.NoError(t, err)
 			} else {
 				assert.EqualError(t, err, tc.expectedError)
 			}
@@ -1093,12 +1094,12 @@ func TestDynamoDBRegistryApplyChanges(t *testing.T) {
 			assert.Empty(t, tc.stubConfig.ExpectDelete, "all expected deletions made")
 
 			records, err := r.Records(ctx)
-			require.Nil(t, err)
+			require.NoError(t, err)
 			assert.True(t, testutils.SameEndpoints(records, tc.expectedRecords))
 
 			r.recordsCache = nil
 			records, err = r.Records(ctx)
-			require.Nil(t, err)
+			require.NoError(t, err)
 			assert.True(t, testutils.SameEndpoints(records, tc.expectedRecords))
 			if tc.expectedError == "" {
 				assert.Empty(t, r.orphanedLabels)
@@ -1185,7 +1186,7 @@ func (r *DynamoDBStub) Scan(ctx context.Context, input *dynamodb.ScanInput, opts
 	assert.Equal(r.t, "o = :ownerval", *input.FilterExpression)
 	assert.Len(r.t, input.ExpressionAttributeValues, 1)
 	var owner string
-	assert.Nil(r.t, attributevalue.Unmarshal(input.ExpressionAttributeValues[":ownerval"], &owner))
+	assert.NoError(r.t, attributevalue.Unmarshal(input.ExpressionAttributeValues[":ownerval"], &owner))
 	assert.Equal(r.t, "test-owner", owner)
 	assert.Equal(r.t, "k,l", *input.ProjectionExpression)
 	assert.True(r.t, *input.ConsistentRead)
@@ -1233,12 +1234,12 @@ func (r *DynamoDBStub) BatchExecuteStatement(context context.Context, input *dyn
 			assert.True(r.t, r.changesApplied, "unexpected delete before provider changes")
 
 			var key string
-			assert.Nil(r.t, attributevalue.Unmarshal(statement.Parameters[0], &key))
+			require.NoError(r.t, attributevalue.Unmarshal(statement.Parameters[0], &key))
 			assert.True(r.t, r.stubConfig.ExpectDelete.Has(key), "unexpected delete for key %q", key)
 			r.stubConfig.ExpectDelete.Delete(key)
 
 			var testOwner string
-			assert.Nil(r.t, attributevalue.Unmarshal(statement.Parameters[1], &testOwner))
+			assert.NoError(r.t, attributevalue.Unmarshal(statement.Parameters[1], &testOwner))
 			assert.Equal(r.t, "test-owner", testOwner)
 
 			responses = append(responses, dynamodbtypes.BatchStatementResponse{})
@@ -1247,7 +1248,7 @@ func (r *DynamoDBStub) BatchExecuteStatement(context context.Context, input *dyn
 			assert.False(r.t, r.changesApplied, "unexpected insert after provider changes")
 
 			var key string
-			assert.Nil(r.t, attributevalue.Unmarshal(statement.Parameters[0], &key))
+			assert.NoError(r.t, attributevalue.Unmarshal(statement.Parameters[0], &key))
 			if code, ok := r.stubConfig.ExpectInsertError[key]; ok {
 				delete(r.stubConfig.ExpectInsertError, key)
 				responses = append(responses, dynamodbtypes.BatchStatementResponse{
@@ -1264,12 +1265,12 @@ func (r *DynamoDBStub) BatchExecuteStatement(context context.Context, input *dyn
 			delete(r.stubConfig.ExpectInsert, key)
 
 			var testOwner string
-			assert.Nil(r.t, attributevalue.Unmarshal(statement.Parameters[1], &testOwner))
+			require.NoError(r.t, attributevalue.Unmarshal(statement.Parameters[1], &testOwner))
 			assert.Equal(r.t, "test-owner", testOwner)
 
 			var labels map[string]string
 			err := attributevalue.Unmarshal(statement.Parameters[2], &labels)
-			assert.Nil(r.t, err)
+			assert.NoError(r.t, err)
 
 			for label, value := range labels {
 				expectedValue, found := expectedLabels[label]
@@ -1288,7 +1289,7 @@ func (r *DynamoDBStub) BatchExecuteStatement(context context.Context, input *dyn
 			assert.False(r.t, r.changesApplied, "unexpected update after provider changes")
 
 			var key string
-			assert.Nil(r.t, attributevalue.Unmarshal(statement.Parameters[1], &key))
+			assert.NoError(r.t, attributevalue.Unmarshal(statement.Parameters[1], &key))
 			if code, exists := r.stubConfig.ExpectUpdateError[key]; exists {
 				delete(r.stubConfig.ExpectInsertError, key)
 				responses = append(responses, dynamodbtypes.BatchStatementResponse{
@@ -1305,7 +1306,7 @@ func (r *DynamoDBStub) BatchExecuteStatement(context context.Context, input *dyn
 			delete(r.stubConfig.ExpectUpdate, key)
 
 			var labels map[string]string
-			assert.Nil(r.t, attributevalue.Unmarshal(statement.Parameters[0], &labels))
+			assert.NoError(r.t, attributevalue.Unmarshal(statement.Parameters[0], &labels))
 
 			for label, value := range labels {
 				expectedValue, found := expectedLabels[label]
diff --git a/registry/txt_encryption_test.go b/registry/txt_encryption_test.go
index 788fb22cb..4b3d4023e 100644
--- a/registry/txt_encryption_test.go
+++ b/registry/txt_encryption_test.go
@@ -27,6 +27,7 @@ import (
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+
 	"sigs.k8s.io/external-dns/endpoint"
 	"sigs.k8s.io/external-dns/plan"
 	"sigs.k8s.io/external-dns/provider/inmemory"
@@ -127,7 +128,7 @@ func TestGenerateTXTGenerateTextRecordEncryptionWihDecryption(t *testing.T) {
 						assert.NoError(t, errDecrypt, "Error decrypting the encrypted text")
 
 						assert.True(t, strings.HasPrefix(encryptedText, nonce),
-							fmt.Sprintf("Nonce '%s' should be a prefix of the encrypted text: '%s'", nonce, encryptedText))
+							"Nonce '%s' should be a prefix of the encrypted text: '%s'", nonce, encryptedText)
 						assert.Equal(t, test.decrypted, actual)
 					}
 				}
diff --git a/registry/txt_test.go b/registry/txt_test.go
index 5b0dea682..bafacce54 100644
--- a/registry/txt_test.go
+++ b/registry/txt_test.go
@@ -638,7 +638,7 @@ func testTXTRegistryApplyChangesWithPrefix(t *testing.T) {
 			"Delete":    got.Delete,
 		}
 		assert.True(t, testutils.SamePlanChanges(mGot, mExpected))
-		assert.Equal(t, nil, ctx.Value(provider.RecordsContextKey))
+		assert.Nil(t, ctx.Value(provider.RecordsContextKey))
 	}
 	err := r.ApplyChanges(ctx, changes)
 	require.NoError(t, err)
@@ -684,7 +684,7 @@ func testTXTRegistryApplyChangesWithTemplatedPrefix(t *testing.T) {
 			"Delete":    got.Delete,
 		}
 		assert.True(t, testutils.SamePlanChanges(mGot, mExpected))
-		assert.Equal(t, nil, ctx.Value(provider.RecordsContextKey))
+		assert.Nil(t, ctx.Value(provider.RecordsContextKey))
 	}
 	err := r.ApplyChanges(ctx, changes)
 	require.NoError(t, err)
@@ -727,7 +727,7 @@ func testTXTRegistryApplyChangesWithTemplatedSuffix(t *testing.T) {
 			"Delete":    got.Delete,
 		}
 		assert.True(t, testutils.SamePlanChanges(mGot, mExpected))
-		assert.Equal(t, nil, ctx.Value(provider.RecordsContextKey))
+		assert.Nil(t, ctx.Value(provider.RecordsContextKey))
 	}
 	err := r.ApplyChanges(ctx, changes)
 	require.NoError(t, err)
@@ -839,7 +839,7 @@ func testTXTRegistryApplyChangesWithSuffix(t *testing.T) {
 			"Delete":    got.Delete,
 		}
 		assert.True(t, testutils.SamePlanChanges(mGot, mExpected))
-		assert.Equal(t, nil, ctx.Value(provider.RecordsContextKey))
+		assert.Nil(t, ctx.Value(provider.RecordsContextKey))
 	}
 	err := r.ApplyChanges(ctx, changes)
 	require.NoError(t, err)
@@ -920,7 +920,7 @@ func testTXTRegistryApplyChangesNoPrefix(t *testing.T) {
 			"Delete":    got.Delete,
 		}
 		assert.True(t, testutils.SamePlanChanges(mGot, mExpected))
-		assert.Equal(t, nil, ctx.Value(provider.RecordsContextKey))
+		assert.Nil(t, ctx.Value(provider.RecordsContextKey))
 	}
 	err := r.ApplyChanges(ctx, changes)
 	require.NoError(t, err)
@@ -1483,7 +1483,7 @@ func TestNewTXTScheme(t *testing.T) {
 			"Delete":    got.Delete,
 		}
 		assert.True(t, testutils.SamePlanChanges(mGot, mExpected))
-		assert.Equal(t, nil, ctx.Value(provider.RecordsContextKey))
+		assert.Nil(t, ctx.Value(provider.RecordsContextKey))
 	}
 	err := r.ApplyChanges(ctx, changes)
 	require.NoError(t, err)
@@ -1587,7 +1587,7 @@ func TestTXTRegistryApplyChangesEncrypt(t *testing.T) {
 			"Delete": got.Delete,
 		}
 		assert.True(t, testutils.SamePlanChanges(mGot, mExpected))
-		assert.Equal(t, nil, ctx.Value(provider.RecordsContextKey))
+		assert.Nil(t, ctx.Value(provider.RecordsContextKey))
 	}
 	err := r.ApplyChanges(ctx, changes)
 	require.NoError(t, err)
@@ -1746,7 +1746,7 @@ func TestGenerateTXTRecordWithNewFormatOnly(t *testing.T) {
 			r, _ := NewTXTRegistry(p, "", "", "owner", time.Hour, "", []string{}, []string{}, false, nil, tc.newFormatOnly)
 			records := r.generateTXTRecord(tc.endpoint)
 
-			assert.Equal(t, tc.expectedRecords, len(records), tc.description)
+			assert.Len(t, records, tc.expectedRecords, tc.description)
 
 			for _, record := range records {
 				assert.Equal(t, endpoint.RecordTypeTXT, record.RecordType)
@@ -1793,7 +1793,7 @@ func TestApplyChangesWithNewFormatOnly(t *testing.T) {
 		}
 	}
 
-	assert.Equal(t, 1, len(txtRecords), "Should only create one TXT record in new format")
+	assert.Len(t, txtRecords, 1, "Should only create one TXT record in new format")
 
 	if len(txtRecords) > 0 {
 		assert.True(t, strings.HasPrefix(txtRecords[0].DNSName, "a-"),
diff --git a/source/f5_transportserver_test.go b/source/f5_transportserver_test.go
index e761eea33..953dc6fa8 100644
--- a/source/f5_transportserver_test.go
+++ b/source/f5_transportserver_test.go
@@ -28,6 +28,7 @@ import (
 	"k8s.io/apimachinery/pkg/runtime"
 	fakeDynamic "k8s.io/client-go/dynamic/fake"
 	fakeKube "k8s.io/client-go/kubernetes/fake"
+
 	"sigs.k8s.io/external-dns/endpoint"
 
 	f5 "github.com/F5Networks/k8s-bigip-ctlr/v2/config/apis/cis/v1"
@@ -345,7 +346,7 @@ func TestF5TransportServerEndpoints(t *testing.T) {
 			endpoints, err := source.Endpoints(context.Background())
 			require.NoError(t, err)
 			assert.Len(t, endpoints, len(tc.expected))
-			assert.Equal(t, endpoints, tc.expected)
+			assert.Equal(t, tc.expected, endpoints)
 		})
 	}
 }
diff --git a/source/f5_virtualserver_test.go b/source/f5_virtualserver_test.go
index 7500664ba..3f21df597 100644
--- a/source/f5_virtualserver_test.go
+++ b/source/f5_virtualserver_test.go
@@ -28,6 +28,7 @@ import (
 	"k8s.io/apimachinery/pkg/runtime"
 	fakeDynamic "k8s.io/client-go/dynamic/fake"
 	fakeKube "k8s.io/client-go/kubernetes/fake"
+
 	"sigs.k8s.io/external-dns/endpoint"
 
 	f5 "github.com/F5Networks/k8s-bigip-ctlr/v2/config/apis/cis/v1"
@@ -345,7 +346,7 @@ func TestF5VirtualServerEndpoints(t *testing.T) {
 			endpoints, err := source.Endpoints(context.Background())
 			require.NoError(t, err)
 			assert.Len(t, endpoints, len(tc.expected))
-			assert.Equal(t, endpoints, tc.expected)
+			assert.Equal(t, tc.expected, endpoints)
 		})
 	}
 }
diff --git a/source/fqdn/fqdn_test.go b/source/fqdn/fqdn_test.go
index 9ec101815..9bfc02569 100644
--- a/source/fqdn/fqdn_test.go
+++ b/source/fqdn/fqdn_test.go
@@ -20,6 +20,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
 )
@@ -202,10 +203,10 @@ func TestExecTemplate(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			tmpl, err := ParseTemplate(tt.tmpl)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 
 			got, err := ExecTemplate(tmpl, tt.obj)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.Equal(t, tt.want, got)
 		})
 	}
@@ -213,7 +214,7 @@ func TestExecTemplate(t *testing.T) {
 
 func TestExecTemplateEmptyObject(t *testing.T) {
 	tmpl, err := ParseTemplate("{{ toLower .Labels.department }}.example.org")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	_, err = ExecTemplate(tmpl, nil)
 	assert.Error(t, err)
 }
@@ -240,10 +241,10 @@ func TestFqdnTemplate(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			tmpl, err := ParseTemplate(tt.fqdnTemplate)
 			if tt.expectedError {
-				assert.Error(t, err)
+				require.Error(t, err)
 				assert.Nil(t, tmpl)
 			} else {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 				if tt.fqdnTemplate == "" {
 					assert.Nil(t, tmpl)
 				} else {
diff --git a/source/istio_virtualservice_test.go b/source/istio_virtualservice_test.go
index 5f18cc582..cf7437367 100644
--- a/source/istio_virtualservice_test.go
+++ b/source/istio_virtualservice_test.go
@@ -19,7 +19,6 @@ package source
 import (
 	"context"
 	"errors"
-	"fmt"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -127,7 +126,7 @@ func (suite *VirtualServiceSuite) SetupTest() {
 func (suite *VirtualServiceSuite) TestResourceLabelIsSet() {
 	endpoints, err := suite.source.Endpoints(context.Background())
 	suite.NoError(err, "should succeed")
-	suite.Equal(len(endpoints), 2, "should return the correct number of endpoints")
+	suite.Len(endpoints, 2, "should return the correct number of endpoints")
 	for _, ep := range endpoints {
 		suite.Equal("virtualservice/istio-other/foo-virtualservice", ep.Labels[endpoint.ResourceLabelKey], "should set correct resource label")
 	}
@@ -2198,7 +2197,7 @@ func TestVirtualServiceSourceGetGateway(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			got, err := tt.fields.virtualServiceSource.getGateway(tt.args.ctx, tt.args.gatewayStr, tt.args.virtualService)
 			if tt.expectedErrStr != "" {
-				assert.EqualError(t, err, tt.expectedErrStr, fmt.Sprintf("getGateway(%v, %v, %v)", tt.args.ctx, tt.args.gatewayStr, tt.args.virtualService))
+				assert.EqualError(t, err, tt.expectedErrStr, "getGateway(%v, %v, %v)", tt.args.ctx, tt.args.gatewayStr, tt.args.virtualService)
 				return
 			} else {
 				require.NoError(t, err)
diff --git a/source/store_test.go b/source/store_test.go
index 94b42b4f1..c245b0efa 100644
--- a/source/store_test.go
+++ b/source/store_test.go
@@ -188,7 +188,7 @@ func (suite *ByNamesTestSuite) TestSourceNotFound() {
 
 	sources, err := ByNames(context.TODO(), mockClientGenerator, []string{"foo"}, &Config{})
 	suite.Equal(err, ErrSourceNotFound, "should return source not found")
-	suite.Len(sources, 0, "should not returns any source")
+	suite.Empty(sources, "should not returns any source")
 }
 
 func (suite *ByNamesTestSuite) TestKubeClientFails() {
diff --git a/source/traefik_proxy_test.go b/source/traefik_proxy_test.go
index 60d36affa..208783118 100644
--- a/source/traefik_proxy_test.go
+++ b/source/traefik_proxy_test.go
@@ -23,6 +23,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/require"
 	"k8s.io/apimachinery/pkg/runtime/schema"
 	"k8s.io/client-go/tools/cache"
 
@@ -640,16 +641,16 @@ func TestTraefikProxyIngressRouteTCPEndpoints(t *testing.T) {
 			ir := unstructured.Unstructured{}
 
 			ingressRouteAsJSON, err := json.Marshal(ti.ingressRouteTCP)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 
-			assert.NoError(t, ir.UnmarshalJSON(ingressRouteAsJSON))
+			require.NoError(t, ir.UnmarshalJSON(ingressRouteAsJSON))
 
 			// Create proxy resources
 			_, err = fakeDynamicClient.Resource(ingressrouteTCPGVR).Namespace(defaultTraefikNamespace).Create(context.Background(), &ir, metav1.CreateOptions{})
-			assert.NoError(t, err)
+			require.NoError(t, err)
 
 			source, err := NewTraefikSource(context.TODO(), fakeDynamicClient, fakeKubernetesClient, defaultTraefikNamespace, "kubernetes.io/ingress.class=traefik", ti.ignoreHostnameAnnotation, false, false)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.NotNil(t, source)
 
 			count := &unstructured.UnstructuredList{}
@@ -658,7 +659,7 @@ func TestTraefikProxyIngressRouteTCPEndpoints(t *testing.T) {
 			}
 
 			endpoints, err := source.Endpoints(context.Background())
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.Len(t, endpoints, len(ti.expected))
 			assert.Equal(t, ti.expected, endpoints)
 		})