mirrors/external-dns
1
0
Fork 0
mirror of https://github.com/kubernetes-sigs/external-dns.git synced 2025-08-05 17:16:59 +02:00
Code Issues Packages Projects Releases Wiki Activity

chore(codebase): enable testifylint (#5441)

Browse Source 
* chore(codebase): enable testifylint

* chore(codebase): enable testifylint

Signed-off-by: ivan katliarchuk <ivan.katliarchuk@gmail.com>

* chore(codebase): enable testifylint

Signed-off-by: ivan katliarchuk <ivan.katliarchuk@gmail.com>

---------

Signed-off-by: ivan katliarchuk <ivan.katliarchuk@gmail.com>
This commit is contained in:
Ivan Ka 2025-05-21 11:46:34 +01:00 committed by GitHub
parent 5188f7c3a6
commit bdb51b2d96
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
47 changed files with 513 additions and 481 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
.golangci.yml
View File

@ -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:

2
endpoint/crypto_test.go
View File

@ -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) {

8
endpoint/domain_filter_test.go
View File

@ -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)
})
}
}

4
endpoint/endpoint_test.go
View File

@ -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)
})

4
endpoint/target_filter_test.go
View File

@ -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))
}

2
internal/gen/docs/flags/main_test.go
View File

@ -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) {

3
internal/gen/docs/metrics/main_test.go
View File

@ -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.")

5
pkg/apis/externaldns/types_test.go
View File

@ -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")
}

22
pkg/apis/externaldns/validation/validation_test.go
View File

@ -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)
}
}

8
pkg/tlsutils/tlsconfig_test.go
View File

@ -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))
},
},

13
plan/plan_test.go
View File

@ -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() {

44
provider/akamai/akamai_test.go
View File

@ -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)
}

9
provider/aws/aws_fixtures_test.go
View File

@ -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"])
})
}
}

20
provider/aws/aws_test.go
View File

@ -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) {

10
provider/awssd/aws_sd_test.go
View File

@ -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) {

6
provider/azure/config_test.go
View File

@ -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

23
provider/civo/civo_test.go
View File

@ -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",

49
provider/cloudflare/cloudflare_test.go
View File

@ -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"))
}

44
provider/digitalocean/digital_ocean_test.go
View File

@ -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)
}

30
provider/dnsimple/dnsimple_test.go
View File

@ -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)
}

16
provider/exoscale/exoscale_test.go
View File

@ -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)
}

10
provider/gandi/gandi_test.go
View File

@ -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]) {

4
provider/godaddy/client_test.go
View File

@ -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)

10
provider/google/google_test.go
View File

@ -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) {

11
provider/ibmcloud/ibmcloud_test.go
View File

@ -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

4
provider/inmemory/inmemory_test.go
View File

@ -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 {

4
provider/linode/linode_test.go
View File

@ -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",

2
provider/ns1/ns1_test.go
View File

@ -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)

143
provider/pdns/pdns_test.go
View File

@ -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)
}
}

3
provider/plural/plural_test.go
View File

@ -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 {

6
provider/provider_test.go
View File

@ -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)
}

161
provider/rfc2136/rfc2136_test.go
View File

@ -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.")

5
provider/scaleway/scaleway_test.go
View File

@ -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)
}
}

32
provider/transip/transip_test.go
View File

@ -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])

136
provider/ultradns/ultradns_test.go
View File

@ -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))
}

3
provider/webhook/api/httpapi_test.go
View File

@ -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) {

32
provider/webhook/webhook_test.go
View File

@ -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
}

9
provider/zonefinder_test.go
View File

@ -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")

27
registry/dynamodb_test.go
View File

@ -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]

3
registry/txt_encryption_test.go
View File

@ -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)
}
}

18
registry/txt_test.go
View File

@ -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-"),

3
source/f5_transportserver_test.go
View File

@ -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)
})
}
}

3
source/f5_virtualserver_test.go
View File

@ -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)
})
}
}

11
source/fqdn/fqdn_test.go
View File

@ -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 {

5
source/istio_virtualservice_test.go
View File

@ -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)

2
source/store_test.go
View File

@ -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() {

11
source/traefik_proxy_test.go
View File

@ -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)
})