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

makes tests pass

Browse Source 
Signed-off-by: Raffaele Di Fazio <difazio.raffaele@gmail.com>
This commit is contained in:
Raffaele Di Fazio 2020-05-08 13:54:13 +02:00
parent db4224c705
commit 82539e35a3
21 changed files with 159 additions and 120 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
provider/akamai/akamai_test.go
View File

@ -32,6 +32,7 @@ import (
"github.com/stretchr/testify/mock" "github.com/stretchr/testify/mock"
"sigs.k8s.io/external-dns/endpoint" "sigs.k8s.io/external-dns/endpoint"
"sigs.k8s.io/external-dns/plan" "sigs.k8s.io/external-dns/plan"
"sigs.k8s.io/external-dns/provider"
) )
type mockAkamaiClient struct { type mockAkamaiClient struct {
@ -92,7 +93,7 @@ func TestRequestError(t *testing.T) {
func TestFetchZonesZoneIDFilter(t *testing.T) { func TestFetchZonesZoneIDFilter(t *testing.T) {
config := AkamaiConfig{ config := AkamaiConfig{
ZoneIDFilter: NewZoneIDFilter([]string{"Test"}), ZoneIDFilter: provider.NewZoneIDFilter([]string{"Test"}),
} }
client := &mockAkamaiClient{} client := &mockAkamaiClient{}
@ -109,7 +110,7 @@ func TestFetchZonesZoneIDFilter(t *testing.T) {
func TestFetchZonesEmpty(t *testing.T) { func TestFetchZonesEmpty(t *testing.T) {
config := AkamaiConfig{ config := AkamaiConfig{
DomainFilter: endpoint.NewDomainFilter([]string{"Nonexistent"}), DomainFilter: endpoint.NewDomainFilter([]string{"Nonexistent"}),
ZoneIDFilter: NewZoneIDFilter([]string{"Nonexistent"}), ZoneIDFilter: provider.NewZoneIDFilter([]string{"Nonexistent"}),
} }
client := &mockAkamaiClient{} client := &mockAkamaiClient{}
@ -171,7 +172,7 @@ func TestAkamaiRecords(t *testing.T) {
func TestAkamaiRecordsEmpty(t *testing.T) { func TestAkamaiRecordsEmpty(t *testing.T) {
config := AkamaiConfig{ config := AkamaiConfig{
ZoneIDFilter: NewZoneIDFilter([]string{"Nonexistent"}), ZoneIDFilter: provider.NewZoneIDFilter([]string{"Nonexistent"}),
} }
client := &mockAkamaiClient{} client := &mockAkamaiClient{}
@ -185,7 +186,7 @@ func TestAkamaiRecordsEmpty(t *testing.T) {
func TestAkamaiRecordsFilters(t *testing.T) { func TestAkamaiRecordsFilters(t *testing.T) {
config := AkamaiConfig{ config := AkamaiConfig{
DomainFilter: endpoint.NewDomainFilter([]string{"www.exclude.me"}), DomainFilter: endpoint.NewDomainFilter([]string{"www.exclude.me"}),
ZoneIDFilter: NewZoneIDFilter([]string{"Exclude-Me"}), ZoneIDFilter: provider.NewZoneIDFilter([]string{"Exclude-Me"}),
} }
client := &mockAkamaiClient{} client := &mockAkamaiClient{}
@ -208,7 +209,7 @@ func TestCreateRecords(t *testing.T) {
c := NewAkamaiProvider(config) c := NewAkamaiProvider(config)
c.client = client c.client = client
zoneNameIDMapper := zoneIDName{"example.com": "example.com"} zoneNameIDMapper := provider.ZoneIDName{"example.com": "example.com"}
endpoints := make([]*endpoint.Endpoint, 0) endpoints := make([]*endpoint.Endpoint, 0)
endpoints = append(endpoints, endpoint.NewEndpoint("www.example.com", endpoint.RecordTypeA, "10.0.0.2", "10.0.0.3")) endpoints = append(endpoints, endpoint.NewEndpoint("www.example.com", endpoint.RecordTypeA, "10.0.0.2", "10.0.0.3"))
endpoints = append(endpoints, endpoint.NewEndpoint("www.example.com", endpoint.RecordTypeTXT, "heritage=external-dns,external-dns/owner=default")) endpoints = append(endpoints, endpoint.NewEndpoint("www.example.com", endpoint.RecordTypeTXT, "heritage=external-dns,external-dns/owner=default"))
@ -228,7 +229,7 @@ func TestCreateRecordsDomainFilter(t *testing.T) {
c := NewAkamaiProvider(config) c := NewAkamaiProvider(config)
c.client = client c.client = client
zoneNameIDMapper := zoneIDName{"example.com": "example.com"} zoneNameIDMapper := provider.ZoneIDName{"example.com": "example.com"}
endpoints := make([]*endpoint.Endpoint, 0) endpoints := make([]*endpoint.Endpoint, 0)
endpoints = append(endpoints, endpoint.NewEndpoint("www.example.com", endpoint.RecordTypeA, "10.0.0.2", "10.0.0.3")) endpoints = append(endpoints, endpoint.NewEndpoint("www.example.com", endpoint.RecordTypeA, "10.0.0.2", "10.0.0.3"))
endpoints = append(endpoints, endpoint.NewEndpoint("www.example.com", endpoint.RecordTypeTXT, "heritage=external-dns,external-dns/owner=default")) endpoints = append(endpoints, endpoint.NewEndpoint("www.example.com", endpoint.RecordTypeTXT, "heritage=external-dns,external-dns/owner=default"))
@ -247,7 +248,7 @@ func TestDeleteRecords(t *testing.T) {
c := NewAkamaiProvider(config) c := NewAkamaiProvider(config)
c.client = client c.client = client
zoneNameIDMapper := zoneIDName{"example.com": "example.com"} zoneNameIDMapper := provider.ZoneIDName{"example.com": "example.com"}
endpoints := make([]*endpoint.Endpoint, 0) endpoints := make([]*endpoint.Endpoint, 0)
endpoints = append(endpoints, endpoint.NewEndpoint("www.example.com", endpoint.RecordTypeA, "10.0.0.2", "10.0.0.3")) endpoints = append(endpoints, endpoint.NewEndpoint("www.example.com", endpoint.RecordTypeA, "10.0.0.2", "10.0.0.3"))
endpoints = append(endpoints, endpoint.NewEndpoint("www.example.com", endpoint.RecordTypeTXT, "heritage=external-dns,external-dns/owner=default")) endpoints = append(endpoints, endpoint.NewEndpoint("www.example.com", endpoint.RecordTypeTXT, "heritage=external-dns,external-dns/owner=default"))
@ -267,7 +268,7 @@ func TestDeleteRecordsDomainFilter(t *testing.T) {
c := NewAkamaiProvider(config) c := NewAkamaiProvider(config)
c.client = client c.client = client
zoneNameIDMapper := zoneIDName{"example.com": "example.com"} zoneNameIDMapper := provider.ZoneIDName{"example.com": "example.com"}
endpoints := make([]*endpoint.Endpoint, 0) endpoints := make([]*endpoint.Endpoint, 0)
endpoints = append(endpoints, endpoint.NewEndpoint("www.example.com", endpoint.RecordTypeA, "10.0.0.2", "10.0.0.3")) endpoints = append(endpoints, endpoint.NewEndpoint("www.example.com", endpoint.RecordTypeA, "10.0.0.2", "10.0.0.3"))
endpoints = append(endpoints, endpoint.NewEndpoint("www.example.com", endpoint.RecordTypeTXT, "heritage=external-dns,external-dns/owner=default")) endpoints = append(endpoints, endpoint.NewEndpoint("www.example.com", endpoint.RecordTypeTXT, "heritage=external-dns,external-dns/owner=default"))
@ -286,7 +287,7 @@ func TestUpdateRecords(t *testing.T) {
c := NewAkamaiProvider(config) c := NewAkamaiProvider(config)
c.client = client c.client = client
zoneNameIDMapper := zoneIDName{"example.com": "example.com"} zoneNameIDMapper := provider.ZoneIDName{"example.com": "example.com"}
endpoints := make([]*endpoint.Endpoint, 0) endpoints := make([]*endpoint.Endpoint, 0)
endpoints = append(endpoints, endpoint.NewEndpoint("www.example.com", endpoint.RecordTypeA, "10.0.0.2", "10.0.0.3")) endpoints = append(endpoints, endpoint.NewEndpoint("www.example.com", endpoint.RecordTypeA, "10.0.0.2", "10.0.0.3"))
endpoints = append(endpoints, endpoint.NewEndpoint("www.example.com", endpoint.RecordTypeTXT, "heritage=external-dns,external-dns/owner=default")) endpoints = append(endpoints, endpoint.NewEndpoint("www.example.com", endpoint.RecordTypeTXT, "heritage=external-dns,external-dns/owner=default"))
@ -306,7 +307,7 @@ func TestUpdateRecordsDomainFilter(t *testing.T) {
c := NewAkamaiProvider(config) c := NewAkamaiProvider(config)
c.client = client c.client = client
zoneNameIDMapper := zoneIDName{"example.com": "example.com"} zoneNameIDMapper := provider.ZoneIDName{"example.com": "example.com"}
endpoints := make([]*endpoint.Endpoint, 0) endpoints := make([]*endpoint.Endpoint, 0)
endpoints = append(endpoints, endpoint.NewEndpoint("www.example.com", endpoint.RecordTypeA, "10.0.0.2", "10.0.0.3")) endpoints = append(endpoints, endpoint.NewEndpoint("www.example.com", endpoint.RecordTypeA, "10.0.0.2", "10.0.0.3"))
endpoints = append(endpoints, endpoint.NewEndpoint("www.example.com", endpoint.RecordTypeTXT, "heritage=external-dns,external-dns/owner=default")) endpoints = append(endpoints, endpoint.NewEndpoint("www.example.com", endpoint.RecordTypeTXT, "heritage=external-dns,external-dns/owner=default"))

51
provider/aws/aws_test.go
View File

@ -35,6 +35,7 @@ import (
"sigs.k8s.io/external-dns/endpoint" "sigs.k8s.io/external-dns/endpoint"
"sigs.k8s.io/external-dns/internal/testutils" "sigs.k8s.io/external-dns/internal/testutils"
"sigs.k8s.io/external-dns/plan" "sigs.k8s.io/external-dns/plan"
"sigs.k8s.io/external-dns/provider"
) )
const ( const (
@ -178,10 +179,10 @@ func (r *Route53APIStub) ChangeResourceRecordSetsWithContext(ctx context.Context
} }
} }
change.ResourceRecordSet.Name = aws.String(wildcardEscape(ensureTrailingDot(aws.StringValue(change.ResourceRecordSet.Name)))) change.ResourceRecordSet.Name = aws.String(wildcardEscape(provider.EnsureTrailingDot(aws.StringValue(change.ResourceRecordSet.Name))))
if change.ResourceRecordSet.AliasTarget != nil { if change.ResourceRecordSet.AliasTarget != nil {
change.ResourceRecordSet.AliasTarget.DNSName = aws.String(wildcardEscape(ensureTrailingDot(aws.StringValue(change.ResourceRecordSet.AliasTarget.DNSName)))) change.ResourceRecordSet.AliasTarget.DNSName = aws.String(wildcardEscape(provider.EnsureTrailingDot(aws.StringValue(change.ResourceRecordSet.AliasTarget.DNSName))))
} }
setId := "" setId := ""
@ -287,17 +288,17 @@ func TestAWSZones(t *testing.T) {
for _, ti := range []struct { for _, ti := range []struct {
msg string msg string
zoneIDFilter ZoneIDFilter zoneIDFilter provider.ZoneIDFilter
zoneTypeFilter ZoneTypeFilter zoneTypeFilter provider.ZoneTypeFilter
zoneTagFilter ZoneTagFilter zoneTagFilter provider.ZoneTagFilter
expectedZones map[string]*route53.HostedZone expectedZones map[string]*route53.HostedZone
}{ }{
{"no filter", NewZoneIDFilter([]string{}), NewZoneTypeFilter(""), NewZoneTagFilter([]string{}), allZones}, {"no filter", provider.NewZoneIDFilter([]string{}), provider.NewZoneTypeFilter(""), provider.NewZoneTagFilter([]string{}), allZones},
{"public filter", NewZoneIDFilter([]string{}), NewZoneTypeFilter("public"), NewZoneTagFilter([]string{}), publicZones}, {"public filter", provider.NewZoneIDFilter([]string{}), provider.NewZoneTypeFilter("public"), provider.NewZoneTagFilter([]string{}), publicZones},
{"private filter", NewZoneIDFilter([]string{}), NewZoneTypeFilter("private"), NewZoneTagFilter([]string{}), privateZones}, {"private filter", provider.NewZoneIDFilter([]string{}), provider.NewZoneTypeFilter("private"), provider.NewZoneTagFilter([]string{}), privateZones},
{"unknown filter", NewZoneIDFilter([]string{}), NewZoneTypeFilter("unknown"), NewZoneTagFilter([]string{}), noZones}, {"unknown filter", provider.NewZoneIDFilter([]string{}), provider.NewZoneTypeFilter("unknown"), provider.NewZoneTagFilter([]string{}), noZones},
{"zone id filter", NewZoneIDFilter([]string{"/hostedzone/zone-3.ext-dns-test-2.teapot.zalan.do."}), NewZoneTypeFilter(""), NewZoneTagFilter([]string{}), privateZones}, {"zone id filter", provider.NewZoneIDFilter([]string{"/hostedzone/zone-3.ext-dns-test-2.teapot.zalan.do."}), provider.NewZoneTypeFilter(""), provider.NewZoneTagFilter([]string{}), privateZones},
{"tag filter", NewZoneIDFilter([]string{}), NewZoneTypeFilter(""), NewZoneTagFilter([]string{"zone=3"}), privateZones}, {"tag filter", provider.NewZoneIDFilter([]string{}), provider.NewZoneTypeFilter(""), provider.NewZoneTagFilter([]string{"zone=3"}), privateZones},
} { } {
provider, _ := newAWSProviderWithTagFilter(t, endpoint.NewDomainFilter([]string{"ext-dns-test-2.teapot.zalan.do."}), ti.zoneIDFilter, ti.zoneTypeFilter, ti.zoneTagFilter, defaultEvaluateTargetHealth, false, []*endpoint.Endpoint{}) provider, _ := newAWSProviderWithTagFilter(t, endpoint.NewDomainFilter([]string{"ext-dns-test-2.teapot.zalan.do."}), ti.zoneIDFilter, ti.zoneTypeFilter, ti.zoneTagFilter, defaultEvaluateTargetHealth, false, []*endpoint.Endpoint{})
@ -309,7 +310,7 @@ func TestAWSZones(t *testing.T) {
} }
func TestAWSRecords(t *testing.T) { func TestAWSRecords(t *testing.T) {
provider, _ := newAWSProvider(t, endpoint.NewDomainFilter([]string{"ext-dns-test-2.teapot.zalan.do."}), NewZoneIDFilter([]string{}), NewZoneTypeFilter(""), false, false, []*endpoint.Endpoint{ provider, _ := newAWSProvider(t, endpoint.NewDomainFilter([]string{"ext-dns-test-2.teapot.zalan.do."}), provider.NewZoneIDFilter([]string{}), provider.NewZoneTypeFilter(""), false, false, []*endpoint.Endpoint{
endpoint.NewEndpointWithTTL("list-test.zone-1.ext-dns-test-2.teapot.zalan.do", endpoint.RecordTypeA, endpoint.TTL(recordTTL), "1.2.3.4"), endpoint.NewEndpointWithTTL("list-test.zone-1.ext-dns-test-2.teapot.zalan.do", endpoint.RecordTypeA, endpoint.TTL(recordTTL), "1.2.3.4"),
endpoint.NewEndpointWithTTL("list-test.zone-2.ext-dns-test-2.teapot.zalan.do", endpoint.RecordTypeA, endpoint.TTL(recordTTL), "8.8.8.8"), endpoint.NewEndpointWithTTL("list-test.zone-2.ext-dns-test-2.teapot.zalan.do", endpoint.RecordTypeA, endpoint.TTL(recordTTL), "8.8.8.8"),
endpoint.NewEndpointWithTTL("*.wildcard-test.zone-2.ext-dns-test-2.teapot.zalan.do", endpoint.RecordTypeA, endpoint.TTL(recordTTL), "8.8.8.8"), endpoint.NewEndpointWithTTL("*.wildcard-test.zone-2.ext-dns-test-2.teapot.zalan.do", endpoint.RecordTypeA, endpoint.TTL(recordTTL), "8.8.8.8"),
@ -351,7 +352,7 @@ func TestAWSRecords(t *testing.T) {
func TestAWSCreateRecords(t *testing.T) { func TestAWSCreateRecords(t *testing.T) {
customTTL := endpoint.TTL(60) customTTL := endpoint.TTL(60)
provider, _ := newAWSProvider(t, endpoint.NewDomainFilter([]string{"ext-dns-test-2.teapot.zalan.do."}), NewZoneIDFilter([]string{}), NewZoneTypeFilter(""), defaultEvaluateTargetHealth, false, []*endpoint.Endpoint{}) provider, _ := newAWSProvider(t, endpoint.NewDomainFilter([]string{"ext-dns-test-2.teapot.zalan.do."}), provider.NewZoneIDFilter([]string{}), provider.NewZoneTypeFilter(""), defaultEvaluateTargetHealth, false, []*endpoint.Endpoint{})
records := []*endpoint.Endpoint{ records := []*endpoint.Endpoint{
endpoint.NewEndpoint("create-test.zone-1.ext-dns-test-2.teapot.zalan.do", endpoint.RecordTypeA, "1.2.3.4"), endpoint.NewEndpoint("create-test.zone-1.ext-dns-test-2.teapot.zalan.do", endpoint.RecordTypeA, "1.2.3.4"),
@ -376,7 +377,7 @@ func TestAWSCreateRecords(t *testing.T) {
} }
func TestAWSUpdateRecords(t *testing.T) { func TestAWSUpdateRecords(t *testing.T) {
provider, _ := newAWSProvider(t, endpoint.NewDomainFilter([]string{"ext-dns-test-2.teapot.zalan.do."}), NewZoneIDFilter([]string{}), NewZoneTypeFilter(""), defaultEvaluateTargetHealth, false, []*endpoint.Endpoint{ provider, _ := newAWSProvider(t, endpoint.NewDomainFilter([]string{"ext-dns-test-2.teapot.zalan.do."}), provider.NewZoneIDFilter([]string{}), provider.NewZoneTypeFilter(""), defaultEvaluateTargetHealth, false, []*endpoint.Endpoint{
endpoint.NewEndpointWithTTL("update-test.zone-1.ext-dns-test-2.teapot.zalan.do", endpoint.RecordTypeA, endpoint.TTL(recordTTL), "8.8.8.8"), endpoint.NewEndpointWithTTL("update-test.zone-1.ext-dns-test-2.teapot.zalan.do", endpoint.RecordTypeA, endpoint.TTL(recordTTL), "8.8.8.8"),
endpoint.NewEndpointWithTTL("update-test.zone-2.ext-dns-test-2.teapot.zalan.do", endpoint.RecordTypeA, endpoint.TTL(recordTTL), "8.8.4.4"), endpoint.NewEndpointWithTTL("update-test.zone-2.ext-dns-test-2.teapot.zalan.do", endpoint.RecordTypeA, endpoint.TTL(recordTTL), "8.8.4.4"),
endpoint.NewEndpointWithTTL("update-test-cname.zone-1.ext-dns-test-2.teapot.zalan.do", endpoint.RecordTypeCNAME, endpoint.TTL(recordTTL), "foo.elb.amazonaws.com"), endpoint.NewEndpointWithTTL("update-test-cname.zone-1.ext-dns-test-2.teapot.zalan.do", endpoint.RecordTypeCNAME, endpoint.TTL(recordTTL), "foo.elb.amazonaws.com"),
@ -419,7 +420,7 @@ func TestAWSDeleteRecords(t *testing.T) {
endpoint.NewEndpointWithTTL("delete-test-multiple.zone-1.ext-dns-test-2.teapot.zalan.do", endpoint.RecordTypeA, endpoint.TTL(recordTTL), "8.8.8.8", "8.8.4.4"), endpoint.NewEndpointWithTTL("delete-test-multiple.zone-1.ext-dns-test-2.teapot.zalan.do", endpoint.RecordTypeA, endpoint.TTL(recordTTL), "8.8.8.8", "8.8.4.4"),
} }
provider, _ := newAWSProvider(t, endpoint.NewDomainFilter([]string{"ext-dns-test-2.teapot.zalan.do."}), NewZoneIDFilter([]string{}), NewZoneTypeFilter(""), false, false, originalEndpoints) provider, _ := newAWSProvider(t, endpoint.NewDomainFilter([]string{"ext-dns-test-2.teapot.zalan.do."}), provider.NewZoneIDFilter([]string{}), provider.NewZoneTypeFilter(""), false, false, originalEndpoints)
require.NoError(t, provider.DeleteRecords(context.Background(), originalEndpoints)) require.NoError(t, provider.DeleteRecords(context.Background(), originalEndpoints))
@ -441,12 +442,12 @@ func TestAWSApplyChanges(t *testing.T) {
ctx := context.Background() ctx := context.Background()
records, err := p.Records(ctx) records, err := p.Records(ctx)
require.NoError(t, err) require.NoError(t, err)
return context.WithValue(ctx, RecordsContextKey, records) return context.WithValue(ctx, provider.RecordsContextKey, records)
}, 0}, }, 0},
} }
for _, tt := range tests { for _, tt := range tests {
provider, _ := newAWSProvider(t, endpoint.NewDomainFilter([]string{"ext-dns-test-2.teapot.zalan.do."}), NewZoneIDFilter([]string{}), NewZoneTypeFilter(""), defaultEvaluateTargetHealth, false, []*endpoint.Endpoint{ provider, _ := newAWSProvider(t, endpoint.NewDomainFilter([]string{"ext-dns-test-2.teapot.zalan.do."}), provider.NewZoneIDFilter([]string{}), provider.NewZoneTypeFilter(""), defaultEvaluateTargetHealth, false, []*endpoint.Endpoint{
endpoint.NewEndpointWithTTL("update-test.zone-1.ext-dns-test-2.teapot.zalan.do", endpoint.RecordTypeA, endpoint.TTL(recordTTL), "8.8.8.8"), endpoint.NewEndpointWithTTL("update-test.zone-1.ext-dns-test-2.teapot.zalan.do", endpoint.RecordTypeA, endpoint.TTL(recordTTL), "8.8.8.8"),
endpoint.NewEndpointWithTTL("delete-test.zone-1.ext-dns-test-2.teapot.zalan.do", endpoint.RecordTypeA, endpoint.TTL(recordTTL), "8.8.8.8"), endpoint.NewEndpointWithTTL("delete-test.zone-1.ext-dns-test-2.teapot.zalan.do", endpoint.RecordTypeA, endpoint.TTL(recordTTL), "8.8.8.8"),
endpoint.NewEndpointWithTTL("update-test.zone-2.ext-dns-test-2.teapot.zalan.do", endpoint.RecordTypeA, endpoint.TTL(recordTTL), "8.8.4.4"), endpoint.NewEndpointWithTTL("update-test.zone-2.ext-dns-test-2.teapot.zalan.do", endpoint.RecordTypeA, endpoint.TTL(recordTTL), "8.8.4.4"),
@ -538,7 +539,7 @@ func TestAWSApplyChangesDryRun(t *testing.T) {
endpoint.NewEndpointWithTTL("delete-test-multiple.zone-2.ext-dns-test-2.teapot.zalan.do", endpoint.RecordTypeA, endpoint.TTL(recordTTL), "1.2.3.4", "4.3.2.1"), endpoint.NewEndpointWithTTL("delete-test-multiple.zone-2.ext-dns-test-2.teapot.zalan.do", endpoint.RecordTypeA, endpoint.TTL(recordTTL), "1.2.3.4", "4.3.2.1"),
} }
provider, _ := newAWSProvider(t, endpoint.NewDomainFilter([]string{"ext-dns-test-2.teapot.zalan.do."}), NewZoneIDFilter([]string{}), NewZoneTypeFilter(""), defaultEvaluateTargetHealth, true, originalEndpoints) provider, _ := newAWSProvider(t, endpoint.NewDomainFilter([]string{"ext-dns-test-2.teapot.zalan.do."}), provider.NewZoneIDFilter([]string{}), provider.NewZoneTypeFilter(""), defaultEvaluateTargetHealth, true, originalEndpoints)
createRecords := []*endpoint.Endpoint{ createRecords := []*endpoint.Endpoint{
endpoint.NewEndpoint("create-test.zone-1.ext-dns-test-2.teapot.zalan.do", endpoint.RecordTypeA, "8.8.8.8"), endpoint.NewEndpoint("create-test.zone-1.ext-dns-test-2.teapot.zalan.do", endpoint.RecordTypeA, "8.8.8.8"),
@ -686,7 +687,7 @@ func TestAWSChangesByZones(t *testing.T) {
} }
func TestAWSsubmitChanges(t *testing.T) { func TestAWSsubmitChanges(t *testing.T) {
provider, _ := newAWSProvider(t, endpoint.NewDomainFilter([]string{"ext-dns-test-2.teapot.zalan.do."}), NewZoneIDFilter([]string{}), NewZoneTypeFilter(""), defaultEvaluateTargetHealth, false, []*endpoint.Endpoint{}) provider, _ := newAWSProvider(t, endpoint.NewDomainFilter([]string{"ext-dns-test-2.teapot.zalan.do."}), provider.NewZoneIDFilter([]string{}), provider.NewZoneTypeFilter(""), defaultEvaluateTargetHealth, false, []*endpoint.Endpoint{})
const subnets = 16 const subnets = 16
const hosts = defaultBatchChangeSize / subnets const hosts = defaultBatchChangeSize / subnets
@ -715,7 +716,7 @@ func TestAWSsubmitChanges(t *testing.T) {
} }
func TestAWSsubmitChangesError(t *testing.T) { func TestAWSsubmitChangesError(t *testing.T) {
provider, clientStub := newAWSProvider(t, endpoint.NewDomainFilter([]string{"ext-dns-test-2.teapot.zalan.do."}), NewZoneIDFilter([]string{}), NewZoneTypeFilter(""), defaultEvaluateTargetHealth, false, []*endpoint.Endpoint{}) provider, clientStub := newAWSProvider(t, endpoint.NewDomainFilter([]string{"ext-dns-test-2.teapot.zalan.do."}), provider.NewZoneIDFilter([]string{}), provider.NewZoneTypeFilter(""), defaultEvaluateTargetHealth, false, []*endpoint.Endpoint{})
clientStub.MockMethod("ChangeResourceRecordSets", mock.Anything).Return(nil, fmt.Errorf("Mock route53 failure")) clientStub.MockMethod("ChangeResourceRecordSets", mock.Anything).Return(nil, fmt.Errorf("Mock route53 failure"))
ctx := context.Background() ctx := context.Background()
@ -851,7 +852,7 @@ func validateAWSChangeRecord(t *testing.T, record *route53.Change, expected *rou
} }
func TestAWSCreateRecordsWithCNAME(t *testing.T) { func TestAWSCreateRecordsWithCNAME(t *testing.T) {
provider, _ := newAWSProvider(t, endpoint.NewDomainFilter([]string{"ext-dns-test-2.teapot.zalan.do."}), NewZoneIDFilter([]string{}), NewZoneTypeFilter(""), defaultEvaluateTargetHealth, false, []*endpoint.Endpoint{}) provider, _ := newAWSProvider(t, endpoint.NewDomainFilter([]string{"ext-dns-test-2.teapot.zalan.do."}), provider.NewZoneIDFilter([]string{}), provider.NewZoneTypeFilter(""), defaultEvaluateTargetHealth, false, []*endpoint.Endpoint{})
records := []*endpoint.Endpoint{ records := []*endpoint.Endpoint{
{DNSName: "create-test.zone-1.ext-dns-test-2.teapot.zalan.do", Targets: endpoint.Targets{"foo.example.org"}, RecordType: endpoint.RecordTypeCNAME}, {DNSName: "create-test.zone-1.ext-dns-test-2.teapot.zalan.do", Targets: endpoint.Targets{"foo.example.org"}, RecordType: endpoint.RecordTypeCNAME},
@ -881,7 +882,7 @@ func TestAWSCreateRecordsWithALIAS(t *testing.T) {
"false": false, "false": false,
"": false, "": false,
} { } {
provider, _ := newAWSProvider(t, endpoint.NewDomainFilter([]string{"ext-dns-test-2.teapot.zalan.do."}), NewZoneIDFilter([]string{}), NewZoneTypeFilter(""), defaultEvaluateTargetHealth, false, []*endpoint.Endpoint{}) provider, _ := newAWSProvider(t, endpoint.NewDomainFilter([]string{"ext-dns-test-2.teapot.zalan.do."}), provider.NewZoneIDFilter([]string{}), provider.NewZoneTypeFilter(""), defaultEvaluateTargetHealth, false, []*endpoint.Endpoint{})
// Test dualstack and ipv4 load balancer targets // Test dualstack and ipv4 load balancer targets
records := []*endpoint.Endpoint{ records := []*endpoint.Endpoint{
@ -1182,11 +1183,11 @@ func escapeAWSRecords(t *testing.T, provider *AWSProvider, zone string) {
require.NoError(t, err) require.NoError(t, err)
} }
} }
func newAWSProvider(t *testing.T, domainFilter endpoint.DomainFilter, zoneIDFilter ZoneIDFilter, zoneTypeFilter ZoneTypeFilter, evaluateTargetHealth, dryRun bool, records []*endpoint.Endpoint) (*AWSProvider, *Route53APIStub) { func newAWSProvider(t *testing.T, domainFilter endpoint.DomainFilter, zoneIDFilter provider.ZoneIDFilter, zoneTypeFilter provider.ZoneTypeFilter, evaluateTargetHealth, dryRun bool, records []*endpoint.Endpoint) (*AWSProvider, *Route53APIStub) {
return newAWSProviderWithTagFilter(t, domainFilter, zoneIDFilter, zoneTypeFilter, NewZoneTagFilter([]string{}), evaluateTargetHealth, dryRun, records) return newAWSProviderWithTagFilter(t, domainFilter, zoneIDFilter, zoneTypeFilter, provider.NewZoneTagFilter([]string{}), evaluateTargetHealth, dryRun, records)
} }
func newAWSProviderWithTagFilter(t *testing.T, domainFilter endpoint.DomainFilter, zoneIDFilter ZoneIDFilter, zoneTypeFilter ZoneTypeFilter, zoneTagFilter ZoneTagFilter, evaluateTargetHealth, dryRun bool, records []*endpoint.Endpoint) (*AWSProvider, *Route53APIStub) { func newAWSProviderWithTagFilter(t *testing.T, domainFilter endpoint.DomainFilter, zoneIDFilter provider.ZoneIDFilter, zoneTypeFilter provider.ZoneTypeFilter, zoneTagFilter provider.ZoneTagFilter, evaluateTargetHealth, dryRun bool, records []*endpoint.Endpoint) (*AWSProvider, *Route53APIStub) {
client := NewRoute53APIStub() client := NewRoute53APIStub()
provider := &AWSProvider{ provider := &AWSProvider{

15
provider/azure/azure_privatedns_test.go
View File

@ -27,6 +27,11 @@ import (
"sigs.k8s.io/external-dns/endpoint" "sigs.k8s.io/external-dns/endpoint"
"sigs.k8s.io/external-dns/plan" "sigs.k8s.io/external-dns/plan"
"sigs.k8s.io/external-dns/provider"
)
const (
recordTTL = 300
) )
// mockPrivateZonesClient implements the methods of the Azure Private DNS Zones Client which are used in the Azure Private DNS Provider // mockPrivateZonesClient implements the methods of the Azure Private DNS Zones Client which are used in the Azure Private DNS Provider
@ -203,7 +208,7 @@ func (client *mockPrivateRecordSetsClient) CreateOrUpdate(ctx context.Context, r
} }
// newMockedAzurePrivateDNSProvider creates an AzureProvider comprising the mocked clients for zones and recordsets // newMockedAzurePrivateDNSProvider creates an AzureProvider comprising the mocked clients for zones and recordsets
func newMockedAzurePrivateDNSProvider(domainFilter endpoint.DomainFilter, zoneIDFilter ZoneIDFilter, dryRun bool, resourceGroup string, zones *[]privatedns.PrivateZone, recordSets *[]privatedns.RecordSet) (*AzurePrivateDNSProvider, error) { func newMockedAzurePrivateDNSProvider(domainFilter endpoint.DomainFilter, zoneIDFilter provider.ZoneIDFilter, dryRun bool, resourceGroup string, zones *[]privatedns.PrivateZone, recordSets *[]privatedns.RecordSet) (*AzurePrivateDNSProvider, error) {
// init zone-related parts of the mock-client // init zone-related parts of the mock-client
pageIterator := mockPrivateZoneListResultPageIterator{ pageIterator := mockPrivateZoneListResultPageIterator{
results: []privatedns.PrivateZoneListResult{ results: []privatedns.PrivateZoneListResult{
@ -236,7 +241,7 @@ func newMockedAzurePrivateDNSProvider(domainFilter endpoint.DomainFilter, zoneID
return newAzurePrivateDNSProvider(domainFilter, zoneIDFilter, dryRun, resourceGroup, &zonesClient, &recordSetsClient), nil return newAzurePrivateDNSProvider(domainFilter, zoneIDFilter, dryRun, resourceGroup, &zonesClient, &recordSetsClient), nil
} }
func newAzurePrivateDNSProvider(domainFilter endpoint.DomainFilter, zoneIDFilter ZoneIDFilter, dryRun bool, resourceGroup string, privateZonesClient PrivateZonesClient, privateRecordsClient PrivateRecordSetsClient) *AzurePrivateDNSProvider { func newAzurePrivateDNSProvider(domainFilter endpoint.DomainFilter, zoneIDFilter provider.ZoneIDFilter, dryRun bool, resourceGroup string, privateZonesClient PrivateZonesClient, privateRecordsClient PrivateRecordSetsClient) *AzurePrivateDNSProvider {
return &AzurePrivateDNSProvider{ return &AzurePrivateDNSProvider{
domainFilter: domainFilter, domainFilter: domainFilter,
zoneIDFilter: zoneIDFilter, zoneIDFilter: zoneIDFilter,
@ -248,7 +253,7 @@ func newAzurePrivateDNSProvider(domainFilter endpoint.DomainFilter, zoneIDFilter
} }
func TestAzurePrivateDNSRecord(t *testing.T) { func TestAzurePrivateDNSRecord(t *testing.T) {
provider, err := newMockedAzurePrivateDNSProvider(endpoint.NewDomainFilter([]string{"example.com"}), NewZoneIDFilter([]string{""}), true, "k8s", provider, err := newMockedAzurePrivateDNSProvider(endpoint.NewDomainFilter([]string{"example.com"}), provider.NewZoneIDFilter([]string{""}), true, "k8s",
&[]privatedns.PrivateZone{ &[]privatedns.PrivateZone{
createMockPrivateZone("example.com", "/privateDnsZones/example.com"), createMockPrivateZone("example.com", "/privateDnsZones/example.com"),
}, },
@ -284,7 +289,7 @@ func TestAzurePrivateDNSRecord(t *testing.T) {
} }
func TestAzurePrivateDNSMultiRecord(t *testing.T) { func TestAzurePrivateDNSMultiRecord(t *testing.T) {
provider, err := newMockedAzurePrivateDNSProvider(endpoint.NewDomainFilter([]string{"example.com"}), NewZoneIDFilter([]string{""}), true, "k8s", provider, err := newMockedAzurePrivateDNSProvider(endpoint.NewDomainFilter([]string{"example.com"}), provider.NewZoneIDFilter([]string{""}), true, "k8s",
&[]privatedns.PrivateZone{ &[]privatedns.PrivateZone{
createMockPrivateZone("example.com", "/privateDnsZones/example.com"), createMockPrivateZone("example.com", "/privateDnsZones/example.com"),
}, },
@ -383,7 +388,7 @@ func testAzurePrivateDNSApplyChangesInternal(t *testing.T, dryRun bool, client P
provider := newAzurePrivateDNSProvider( provider := newAzurePrivateDNSProvider(
endpoint.NewDomainFilter([]string{""}), endpoint.NewDomainFilter([]string{""}),
NewZoneIDFilter([]string{""}), provider.NewZoneIDFilter([]string{""}),
dryRun, dryRun,
"group", "group",
&zonesClient, &zonesClient,

11
provider/azure/azure_test.go
View File

@ -30,6 +30,7 @@ import (
"sigs.k8s.io/external-dns/endpoint" "sigs.k8s.io/external-dns/endpoint"
"sigs.k8s.io/external-dns/internal/testutils" "sigs.k8s.io/external-dns/internal/testutils"
"sigs.k8s.io/external-dns/plan" "sigs.k8s.io/external-dns/plan"
"sigs.k8s.io/external-dns/provider"
) )
// mockZonesClient implements the methods of the Azure DNS Zones Client which are used in the Azure Provider // mockZonesClient implements the methods of the Azure DNS Zones Client which are used in the Azure Provider
@ -206,7 +207,7 @@ func (client *mockRecordSetsClient) CreateOrUpdate(ctx context.Context, resource
} }
// newMockedAzureProvider creates an AzureProvider comprising the mocked clients for zones and recordsets // newMockedAzureProvider creates an AzureProvider comprising the mocked clients for zones and recordsets
func newMockedAzureProvider(domainFilter endpoint.DomainFilter, zoneIDFilter ZoneIDFilter, dryRun bool, resourceGroup string, userAssignedIdentityClientID string, zones *[]dns.Zone, recordSets *[]dns.RecordSet) (*AzureProvider, error) { func newMockedAzureProvider(domainFilter endpoint.DomainFilter, zoneIDFilter provider.ZoneIDFilter, dryRun bool, resourceGroup string, userAssignedIdentityClientID string, zones *[]dns.Zone, recordSets *[]dns.RecordSet) (*AzureProvider, error) {
// init zone-related parts of the mock-client // init zone-related parts of the mock-client
pageIterator := mockZoneListResultPageIterator{ pageIterator := mockZoneListResultPageIterator{
results: []dns.ZoneListResult{ results: []dns.ZoneListResult{
@ -239,7 +240,7 @@ func newMockedAzureProvider(domainFilter endpoint.DomainFilter, zoneIDFilter Zon
return newAzureProvider(domainFilter, zoneIDFilter, dryRun, resourceGroup, userAssignedIdentityClientID, &zonesClient, &recordSetsClient), nil return newAzureProvider(domainFilter, zoneIDFilter, dryRun, resourceGroup, userAssignedIdentityClientID, &zonesClient, &recordSetsClient), nil
} }
func newAzureProvider(domainFilter endpoint.DomainFilter, zoneIDFilter ZoneIDFilter, dryRun bool, resourceGroup string, userAssignedIdentityClientID string, zonesClient ZonesClient, recordsClient RecordSetsClient) *AzureProvider { func newAzureProvider(domainFilter endpoint.DomainFilter, zoneIDFilter provider.ZoneIDFilter, dryRun bool, resourceGroup string, userAssignedIdentityClientID string, zonesClient ZonesClient, recordsClient RecordSetsClient) *AzureProvider {
return &AzureProvider{ return &AzureProvider{
domainFilter: domainFilter, domainFilter: domainFilter,
zoneIDFilter: zoneIDFilter, zoneIDFilter: zoneIDFilter,
@ -256,7 +257,7 @@ func validateAzureEndpoints(t *testing.T, endpoints []*endpoint.Endpoint, expect
} }
func TestAzureRecord(t *testing.T) { func TestAzureRecord(t *testing.T) {
provider, err := newMockedAzureProvider(endpoint.NewDomainFilter([]string{"example.com"}), NewZoneIDFilter([]string{""}), true, "k8s", "", provider, err := newMockedAzureProvider(endpoint.NewDomainFilter([]string{"example.com"}), provider.NewZoneIDFilter([]string{""}), true, "k8s", "",
&[]dns.Zone{ &[]dns.Zone{
createMockZone("example.com", "/dnszones/example.com"), createMockZone("example.com", "/dnszones/example.com"),
}, },
@ -293,7 +294,7 @@ func TestAzureRecord(t *testing.T) {
} }
func TestAzureMultiRecord(t *testing.T) { func TestAzureMultiRecord(t *testing.T) {
provider, err := newMockedAzureProvider(endpoint.NewDomainFilter([]string{"example.com"}), NewZoneIDFilter([]string{""}), true, "k8s", "", provider, err := newMockedAzureProvider(endpoint.NewDomainFilter([]string{"example.com"}), provider.NewZoneIDFilter([]string{""}), true, "k8s", "",
&[]dns.Zone{ &[]dns.Zone{
createMockZone("example.com", "/dnszones/example.com"), createMockZone("example.com", "/dnszones/example.com"),
}, },
@ -393,7 +394,7 @@ func testAzureApplyChangesInternal(t *testing.T, dryRun bool, client RecordSetsC
provider := newAzureProvider( provider := newAzureProvider(
endpoint.NewDomainFilter([]string{""}), endpoint.NewDomainFilter([]string{""}),
NewZoneIDFilter([]string{""}), provider.NewZoneIDFilter([]string{""}),
dryRun, dryRun,
"group", "group",
"", "",

9
provider/cloudflare/cloudflare_test.go
View File

@ -28,6 +28,7 @@ import (
"github.com/maxatome/go-testdeep/td" "github.com/maxatome/go-testdeep/td"
"sigs.k8s.io/external-dns/endpoint" "sigs.k8s.io/external-dns/endpoint"
"sigs.k8s.io/external-dns/plan" "sigs.k8s.io/external-dns/plan"
"sigs.k8s.io/external-dns/provider"
) )
type MockAction struct { type MockAction struct {
@ -510,7 +511,7 @@ func TestCloudflareZones(t *testing.T) {
provider := &CloudFlareProvider{ provider := &CloudFlareProvider{
Client: NewMockCloudFlareClient(), Client: NewMockCloudFlareClient(),
domainFilter: endpoint.NewDomainFilter([]string{"bar.com"}), domainFilter: endpoint.NewDomainFilter([]string{"bar.com"}),
zoneIDFilter: NewZoneIDFilter([]string{""}), zoneIDFilter: provider.NewZoneIDFilter([]string{""}),
} }
zones, err := provider.Zones(context.Background()) zones, err := provider.Zones(context.Background())
@ -555,7 +556,7 @@ func TestCloudflareProvider(t *testing.T) {
_ = os.Setenv("CF_API_TOKEN", "abc123def") _ = os.Setenv("CF_API_TOKEN", "abc123def")
_, err := NewCloudFlareProvider( _, err := NewCloudFlareProvider(
endpoint.NewDomainFilter([]string{"bar.com"}), endpoint.NewDomainFilter([]string{"bar.com"}),
NewZoneIDFilter([]string{""}), provider.NewZoneIDFilter([]string{""}),
25, 25,
false, false,
true) true)
@ -567,7 +568,7 @@ func TestCloudflareProvider(t *testing.T) {
_ = os.Setenv("CF_API_EMAIL", "test@test.com") _ = os.Setenv("CF_API_EMAIL", "test@test.com")
_, err = NewCloudFlareProvider( _, err = NewCloudFlareProvider(
endpoint.NewDomainFilter([]string{"bar.com"}), endpoint.NewDomainFilter([]string{"bar.com"}),
NewZoneIDFilter([]string{""}), provider.NewZoneIDFilter([]string{""}),
1, 1,
false, false,
true) true)
@ -578,7 +579,7 @@ func TestCloudflareProvider(t *testing.T) {
_ = os.Unsetenv("CF_API_EMAIL") _ = os.Unsetenv("CF_API_EMAIL")
_, err = NewCloudFlareProvider( _, err = NewCloudFlareProvider(
endpoint.NewDomainFilter([]string{"bar.com"}), endpoint.NewDomainFilter([]string{"bar.com"}),
NewZoneIDFilter([]string{""}), provider.NewZoneIDFilter([]string{""}),
50, 50,
false, false,
true) true)

3
provider/designate/designate_test.go
View File

@ -34,6 +34,7 @@ import (
"sigs.k8s.io/external-dns/endpoint" "sigs.k8s.io/external-dns/endpoint"
"sigs.k8s.io/external-dns/plan" "sigs.k8s.io/external-dns/plan"
"sigs.k8s.io/external-dns/provider"
) )
var lastGeneratedDesignateID int32 var lastGeneratedDesignateID int32
@ -130,7 +131,7 @@ func (c fakeDesignateClient) DeleteRecordSet(zoneID, recordSetID string) error {
return nil return nil
} }
func (c fakeDesignateClient) ToProvider() Provider { func (c fakeDesignateClient) ToProvider() provider.Provider {
return &designateProvider{client: c} return &designateProvider{client: c}
} }

3
provider/dnsimple/dnsimple_test.go
View File

@ -31,6 +31,7 @@ import (
"sigs.k8s.io/external-dns/endpoint" "sigs.k8s.io/external-dns/endpoint"
"sigs.k8s.io/external-dns/plan" "sigs.k8s.io/external-dns/plan"
"sigs.k8s.io/external-dns/provider"
) )
var mockProvider dnsimpleProvider var mockProvider dnsimpleProvider
@ -203,7 +204,7 @@ func testDnsimpleSuitableZone(t *testing.T) {
func TestNewDnsimpleProvider(t *testing.T) { func TestNewDnsimpleProvider(t *testing.T) {
os.Setenv("DNSIMPLE_OAUTH", "xxxxxxxxxxxxxxxxxxxxxxxxxx") os.Setenv("DNSIMPLE_OAUTH", "xxxxxxxxxxxxxxxxxxxxxxxxxx")
_, err := NewDnsimpleProvider(endpoint.NewDomainFilter([]string{"example.com"}), NewZoneIDFilter([]string{""}), true) _, err := NewDnsimpleProvider(endpoint.NewDomainFilter([]string{"example.com"}), provider.NewZoneIDFilter([]string{""}), true)
if err == nil { if err == nil {
t.Errorf("Expected to fail new provider on bad token") t.Errorf("Expected to fail new provider on bad token")
} }

3
provider/dyn/dyn_test.go
View File

@ -25,6 +25,7 @@ import (
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"sigs.k8s.io/external-dns/endpoint" "sigs.k8s.io/external-dns/endpoint"
"sigs.k8s.io/external-dns/provider"
) )
func TestDynMerge_NoUpdateOnTTL0Changes(t *testing.T) { func TestDynMerge_NoUpdateOnTTL0Changes(t *testing.T) {
@ -187,7 +188,7 @@ func TestDyn_endpointToRecord(t *testing.T) {
func TestDyn_buildLinkToRecord(t *testing.T) { func TestDyn_buildLinkToRecord(t *testing.T) {
provider := &dynProviderState{ provider := &dynProviderState{
DynConfig: DynConfig{ DynConfig: DynConfig{
ZoneIDFilter: NewZoneIDFilter([]string{"example.com"}), ZoneIDFilter: provider.NewZoneIDFilter([]string{"example.com"}),
DomainFilter: endpoint.NewDomainFilter([]string{"the-target.example.com"}), DomainFilter: endpoint.NewDomainFilter([]string{"the-target.example.com"}),
}, },
} }

34
provider/google/google_test.go
View File

@ -30,7 +30,9 @@ import (
"google.golang.org/api/googleapi" "google.golang.org/api/googleapi"
"sigs.k8s.io/external-dns/endpoint" "sigs.k8s.io/external-dns/endpoint"
"sigs.k8s.io/external-dns/internal/testutils"
"sigs.k8s.io/external-dns/plan" "sigs.k8s.io/external-dns/plan"
"sigs.k8s.io/external-dns/provider"
) )
var ( var (
@ -192,7 +194,7 @@ func hasTrailingDot(target string) bool {
} }
func TestGoogleZonesIDFilter(t *testing.T) { func TestGoogleZonesIDFilter(t *testing.T) {
provider := newGoogleProviderZoneOverlap(t, endpoint.NewDomainFilter([]string{"cluster.local."}), NewZoneIDFilter([]string{"10002"}), false, []*endpoint.Endpoint{}) provider := newGoogleProviderZoneOverlap(t, endpoint.NewDomainFilter([]string{"cluster.local."}), provider.NewZoneIDFilter([]string{"10002"}), false, []*endpoint.Endpoint{})
zones, err := provider.Zones(context.Background()) zones, err := provider.Zones(context.Background())
require.NoError(t, err) require.NoError(t, err)
@ -203,7 +205,7 @@ func TestGoogleZonesIDFilter(t *testing.T) {
} }
func TestGoogleZonesNameFilter(t *testing.T) { func TestGoogleZonesNameFilter(t *testing.T) {
provider := newGoogleProviderZoneOverlap(t, endpoint.NewDomainFilter([]string{"cluster.local."}), NewZoneIDFilter([]string{"internal-2"}), false, []*endpoint.Endpoint{}) provider := newGoogleProviderZoneOverlap(t, endpoint.NewDomainFilter([]string{"cluster.local."}), provider.NewZoneIDFilter([]string{"internal-2"}), false, []*endpoint.Endpoint{})
zones, err := provider.Zones(context.Background()) zones, err := provider.Zones(context.Background())
require.NoError(t, err) require.NoError(t, err)
@ -214,7 +216,7 @@ func TestGoogleZonesNameFilter(t *testing.T) {
} }
func TestGoogleZones(t *testing.T) { func TestGoogleZones(t *testing.T) {
provider := newGoogleProvider(t, endpoint.NewDomainFilter([]string{"ext-dns-test-2.gcp.zalan.do."}), NewZoneIDFilter([]string{""}), false, []*endpoint.Endpoint{}) provider := newGoogleProvider(t, endpoint.NewDomainFilter([]string{"ext-dns-test-2.gcp.zalan.do."}), provider.NewZoneIDFilter([]string{""}), false, []*endpoint.Endpoint{})
zones, err := provider.Zones(context.Background()) zones, err := provider.Zones(context.Background())
require.NoError(t, err) require.NoError(t, err)
@ -233,7 +235,7 @@ func TestGoogleRecords(t *testing.T) {
endpoint.NewEndpointWithTTL("list-test-alias.zone-1.ext-dns-test-2.gcp.zalan.do", endpoint.RecordTypeCNAME, endpoint.TTL(3), "foo.elb.amazonaws.com"), endpoint.NewEndpointWithTTL("list-test-alias.zone-1.ext-dns-test-2.gcp.zalan.do", endpoint.RecordTypeCNAME, endpoint.TTL(3), "foo.elb.amazonaws.com"),
} }
provider := newGoogleProvider(t, endpoint.NewDomainFilter([]string{"ext-dns-test-2.gcp.zalan.do."}), NewZoneIDFilter([]string{""}), false, originalEndpoints) provider := newGoogleProvider(t, endpoint.NewDomainFilter([]string{"ext-dns-test-2.gcp.zalan.do."}), provider.NewZoneIDFilter([]string{""}), false, originalEndpoints)
records, err := provider.Records(context.Background()) records, err := provider.Records(context.Background())
require.NoError(t, err) require.NoError(t, err)
@ -261,7 +263,7 @@ func TestGoogleRecordsFilter(t *testing.T) {
"zone-0.ext-dns-test-2.gcp.zalan.do.", "zone-0.ext-dns-test-2.gcp.zalan.do.",
// there exists a third zone "zone-3" that we want to exclude from being managed. // there exists a third zone "zone-3" that we want to exclude from being managed.
}), }),
NewZoneIDFilter([]string{""}), provider.NewZoneIDFilter([]string{""}),
false, false,
originalEndpoints, originalEndpoints,
) )
@ -286,7 +288,7 @@ func TestGoogleRecordsFilter(t *testing.T) {
} }
func TestGoogleCreateRecords(t *testing.T) { func TestGoogleCreateRecords(t *testing.T) {
provider := newGoogleProvider(t, endpoint.NewDomainFilter([]string{"ext-dns-test-2.gcp.zalan.do."}), NewZoneIDFilter([]string{""}), false, []*endpoint.Endpoint{}) provider := newGoogleProvider(t, endpoint.NewDomainFilter([]string{"ext-dns-test-2.gcp.zalan.do."}), provider.NewZoneIDFilter([]string{""}), false, []*endpoint.Endpoint{})
records := []*endpoint.Endpoint{ records := []*endpoint.Endpoint{
endpoint.NewEndpoint("create-test.zone-1.ext-dns-test-2.gcp.zalan.do", endpoint.RecordTypeA, "1.2.3.4"), endpoint.NewEndpoint("create-test.zone-1.ext-dns-test-2.gcp.zalan.do", endpoint.RecordTypeA, "1.2.3.4"),
@ -312,7 +314,7 @@ func TestGoogleUpdateRecords(t *testing.T) {
endpoint.NewEndpointWithTTL("update-test-ttl.zone-2.ext-dns-test-2.gcp.zalan.do", endpoint.RecordTypeA, endpoint.TTL(15), "8.8.4.4"), endpoint.NewEndpointWithTTL("update-test-ttl.zone-2.ext-dns-test-2.gcp.zalan.do", endpoint.RecordTypeA, endpoint.TTL(15), "8.8.4.4"),
endpoint.NewEndpointWithTTL("update-test-cname.zone-1.ext-dns-test-2.gcp.zalan.do", endpoint.RecordTypeCNAME, googleRecordTTL, "foo.elb.amazonaws.com"), endpoint.NewEndpointWithTTL("update-test-cname.zone-1.ext-dns-test-2.gcp.zalan.do", endpoint.RecordTypeCNAME, googleRecordTTL, "foo.elb.amazonaws.com"),
} }
provider := newGoogleProvider(t, endpoint.NewDomainFilter([]string{"ext-dns-test-2.gcp.zalan.do."}), NewZoneIDFilter([]string{""}), false, currentRecords) provider := newGoogleProvider(t, endpoint.NewDomainFilter([]string{"ext-dns-test-2.gcp.zalan.do."}), provider.NewZoneIDFilter([]string{""}), false, currentRecords)
updatedRecords := []*endpoint.Endpoint{ updatedRecords := []*endpoint.Endpoint{
endpoint.NewEndpoint("update-test.zone-1.ext-dns-test-2.gcp.zalan.do", endpoint.RecordTypeA, "1.2.3.4"), endpoint.NewEndpoint("update-test.zone-1.ext-dns-test-2.gcp.zalan.do", endpoint.RecordTypeA, "1.2.3.4"),
endpoint.NewEndpointWithTTL("update-test-ttl.zone-2.ext-dns-test-2.gcp.zalan.do", endpoint.RecordTypeA, endpoint.TTL(25), "4.3.2.1"), endpoint.NewEndpointWithTTL("update-test-ttl.zone-2.ext-dns-test-2.gcp.zalan.do", endpoint.RecordTypeA, endpoint.TTL(25), "4.3.2.1"),
@ -338,7 +340,7 @@ func TestGoogleDeleteRecords(t *testing.T) {
endpoint.NewEndpointWithTTL("delete-test-cname.zone-1.ext-dns-test-2.gcp.zalan.do", endpoint.RecordTypeCNAME, googleRecordTTL, "baz.elb.amazonaws.com"), endpoint.NewEndpointWithTTL("delete-test-cname.zone-1.ext-dns-test-2.gcp.zalan.do", endpoint.RecordTypeCNAME, googleRecordTTL, "baz.elb.amazonaws.com"),
} }
provider := newGoogleProvider(t, endpoint.NewDomainFilter([]string{"ext-dns-test-2.gcp.zalan.do."}), NewZoneIDFilter([]string{""}), false, originalEndpoints) provider := newGoogleProvider(t, endpoint.NewDomainFilter([]string{"ext-dns-test-2.gcp.zalan.do."}), provider.NewZoneIDFilter([]string{""}), false, originalEndpoints)
require.NoError(t, provider.DeleteRecords(originalEndpoints)) require.NoError(t, provider.DeleteRecords(originalEndpoints))
@ -359,7 +361,7 @@ func TestGoogleApplyChanges(t *testing.T) {
"zone-0.ext-dns-test-2.gcp.zalan.do.", "zone-0.ext-dns-test-2.gcp.zalan.do.",
// there exists a third zone "zone-3" that we want to exclude from being managed. // there exists a third zone "zone-3" that we want to exclude from being managed.
}), }),
NewZoneIDFilter([]string{""}), provider.NewZoneIDFilter([]string{""}),
false, false,
[]*endpoint.Endpoint{ []*endpoint.Endpoint{
endpoint.NewEndpointWithTTL("update-test.zone-1.ext-dns-test-2.gcp.zalan.do", endpoint.RecordTypeA, googleRecordTTL, "8.8.8.8"), endpoint.NewEndpointWithTTL("update-test.zone-1.ext-dns-test-2.gcp.zalan.do", endpoint.RecordTypeA, googleRecordTTL, "8.8.8.8"),
@ -433,7 +435,7 @@ func TestGoogleApplyChangesDryRun(t *testing.T) {
endpoint.NewEndpointWithTTL("delete-test-cname.zone-1.ext-dns-test-2.gcp.zalan.do", endpoint.RecordTypeCNAME, googleRecordTTL, "qux.elb.amazonaws.com"), endpoint.NewEndpointWithTTL("delete-test-cname.zone-1.ext-dns-test-2.gcp.zalan.do", endpoint.RecordTypeCNAME, googleRecordTTL, "qux.elb.amazonaws.com"),
} }
provider := newGoogleProvider(t, endpoint.NewDomainFilter([]string{"ext-dns-test-2.gcp.zalan.do."}), NewZoneIDFilter([]string{""}), true, originalEndpoints) provider := newGoogleProvider(t, endpoint.NewDomainFilter([]string{"ext-dns-test-2.gcp.zalan.do."}), provider.NewZoneIDFilter([]string{""}), true, originalEndpoints)
createRecords := []*endpoint.Endpoint{ createRecords := []*endpoint.Endpoint{
endpoint.NewEndpoint("create-test.zone-1.ext-dns-test-2.gcp.zalan.do", endpoint.RecordTypeA, "8.8.8.8"), endpoint.NewEndpoint("create-test.zone-1.ext-dns-test-2.gcp.zalan.do", endpoint.RecordTypeA, "8.8.8.8"),
@ -475,12 +477,12 @@ func TestGoogleApplyChangesDryRun(t *testing.T) {
} }
func TestGoogleApplyChangesEmpty(t *testing.T) { func TestGoogleApplyChangesEmpty(t *testing.T) {
provider := newGoogleProvider(t, endpoint.NewDomainFilter([]string{"ext-dns-test-2.gcp.zalan.do."}), NewZoneIDFilter([]string{""}), false, []*endpoint.Endpoint{}) provider := newGoogleProvider(t, endpoint.NewDomainFilter([]string{"ext-dns-test-2.gcp.zalan.do."}), provider.NewZoneIDFilter([]string{""}), false, []*endpoint.Endpoint{})
assert.NoError(t, provider.ApplyChanges(context.Background(), &plan.Changes{})) assert.NoError(t, provider.ApplyChanges(context.Background(), &plan.Changes{}))
} }
func TestNewFilteredRecords(t *testing.T) { func TestNewFilteredRecords(t *testing.T) {
provider := newGoogleProvider(t, endpoint.NewDomainFilter([]string{"ext-dns-test-2.gcp.zalan.do."}), NewZoneIDFilter([]string{""}), false, []*endpoint.Endpoint{}) provider := newGoogleProvider(t, endpoint.NewDomainFilter([]string{"ext-dns-test-2.gcp.zalan.do."}), provider.NewZoneIDFilter([]string{""}), false, []*endpoint.Endpoint{})
records := provider.newFilteredRecords([]*endpoint.Endpoint{ records := provider.newFilteredRecords([]*endpoint.Endpoint{
endpoint.NewEndpointWithTTL("update-test.zone-2.ext-dns-test-2.gcp.zalan.do", endpoint.RecordTypeA, 1, "8.8.4.4"), endpoint.NewEndpointWithTTL("update-test.zone-2.ext-dns-test-2.gcp.zalan.do", endpoint.RecordTypeA, 1, "8.8.4.4"),
@ -670,7 +672,7 @@ func validateChangeRecord(t *testing.T, record *dns.ResourceRecordSet, expected
assert.Equal(t, expected.Type, record.Type) assert.Equal(t, expected.Type, record.Type)
} }
func newGoogleProviderZoneOverlap(t *testing.T, domainFilter endpoint.DomainFilter, zoneIDFilter ZoneIDFilter, dryRun bool, records []*endpoint.Endpoint) *GoogleProvider { func newGoogleProviderZoneOverlap(t *testing.T, domainFilter endpoint.DomainFilter, zoneIDFilter provider.ZoneIDFilter, dryRun bool, records []*endpoint.Endpoint) *GoogleProvider {
provider := &GoogleProvider{ provider := &GoogleProvider{
project: "zalando-external-dns-test", project: "zalando-external-dns-test",
dryRun: false, dryRun: false,
@ -705,7 +707,7 @@ func newGoogleProviderZoneOverlap(t *testing.T, domainFilter endpoint.DomainFilt
} }
func newGoogleProvider(t *testing.T, domainFilter endpoint.DomainFilter, zoneIDFilter ZoneIDFilter, dryRun bool, records []*endpoint.Endpoint) *GoogleProvider { func newGoogleProvider(t *testing.T, domainFilter endpoint.DomainFilter, zoneIDFilter provider.ZoneIDFilter, dryRun bool, records []*endpoint.Endpoint) *GoogleProvider {
provider := &GoogleProvider{ provider := &GoogleProvider{
project: "zalando-external-dns-test", project: "zalando-external-dns-test",
dryRun: false, dryRun: false,
@ -792,3 +794,7 @@ func clearGoogleRecords(t *testing.T, provider *GoogleProvider, zone string) {
require.NoError(t, err) require.NoError(t, err)
} }
} }
func validateEndpoints(t *testing.T, endpoints []*endpoint.Endpoint, expected []*endpoint.Endpoint) {
assert.True(t, testutils.SameEndpoints(endpoints, expected), "actual and expected endpoints don't match. %s:%s", endpoints, expected)
}

14
provider/infoblox/infoblox_test.go
View File

@ -28,7 +28,9 @@ import (
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"sigs.k8s.io/external-dns/endpoint" "sigs.k8s.io/external-dns/endpoint"
"sigs.k8s.io/external-dns/internal/testutils"
"sigs.k8s.io/external-dns/plan" "sigs.k8s.io/external-dns/plan"
"sigs.k8s.io/external-dns/provider"
) )
type mockIBConnector struct { type mockIBConnector struct {
@ -329,7 +331,7 @@ func createMockInfobloxObject(name, recordType, value string) ibclient.IBObject
return nil return nil
} }
func newInfobloxProvider(domainFilter endpoint.DomainFilter, zoneIDFilter ZoneIDFilter, dryRun bool, client ibclient.IBConnector) *InfobloxProvider { func newInfobloxProvider(domainFilter endpoint.DomainFilter, zoneIDFilter provider.ZoneIDFilter, dryRun bool, client ibclient.IBConnector) *InfobloxProvider {
return &InfobloxProvider{ return &InfobloxProvider{
client: client, client: client,
domainFilter: domainFilter, domainFilter: domainFilter,
@ -354,7 +356,7 @@ func TestInfobloxRecords(t *testing.T) {
}, },
} }
provider := newInfobloxProvider(endpoint.NewDomainFilter([]string{"example.com"}), NewZoneIDFilter([]string{""}), true, &client) provider := newInfobloxProvider(endpoint.NewDomainFilter([]string{"example.com"}), provider.NewZoneIDFilter([]string{""}), true, &client)
actual, err := provider.Records(context.Background()) actual, err := provider.Records(context.Background())
if err != nil { if err != nil {
@ -428,7 +430,7 @@ func testInfobloxApplyChangesInternal(t *testing.T, dryRun bool, client ibclient
provider := newInfobloxProvider( provider := newInfobloxProvider(
endpoint.NewDomainFilter([]string{""}), endpoint.NewDomainFilter([]string{""}),
NewZoneIDFilter([]string{""}), provider.NewZoneIDFilter([]string{""}),
dryRun, dryRun,
client, client,
) )
@ -486,7 +488,7 @@ func TestInfobloxZones(t *testing.T) {
mockInfobloxObjects: &[]ibclient.IBObject{}, mockInfobloxObjects: &[]ibclient.IBObject{},
} }
provider := newInfobloxProvider(endpoint.NewDomainFilter([]string{"example.com"}), NewZoneIDFilter([]string{""}), true, &client) provider := newInfobloxProvider(endpoint.NewDomainFilter([]string{"example.com"}), provider.NewZoneIDFilter([]string{""}), true, &client)
zones, _ := provider.zones() zones, _ := provider.zones()
var emptyZoneAuth *ibclient.ZoneAuth var emptyZoneAuth *ibclient.ZoneAuth
assert.Equal(t, provider.findZone(zones, "example.com").Fqdn, "example.com") assert.Equal(t, provider.findZone(zones, "example.com").Fqdn, "example.com")
@ -521,3 +523,7 @@ func TestMaxResultsRequestBuilder(t *testing.T) {
assert.True(t, req.URL.Query().Get("_max_results") == "") assert.True(t, req.URL.Query().Get("_max_results") == "")
} }
func validateEndpoints(t *testing.T, endpoints []*endpoint.Endpoint, expected []*endpoint.Endpoint) {
assert.True(t, testutils.SameEndpoints(endpoints, expected), "actual and expected endpoints don't match. %s:%s", endpoints, expected)
}

3
provider/inmemory/inmemory_test.go
View File

@ -26,10 +26,11 @@ import (
"sigs.k8s.io/external-dns/endpoint" "sigs.k8s.io/external-dns/endpoint"
"sigs.k8s.io/external-dns/internal/testutils" "sigs.k8s.io/external-dns/internal/testutils"
"sigs.k8s.io/external-dns/plan" "sigs.k8s.io/external-dns/plan"
"sigs.k8s.io/external-dns/provider"
) )
var ( var (
_ Provider = &InMemoryProvider{} _ provider.Provider = &InMemoryProvider{}
) )
func TestInMemoryProvider(t *testing.T) { func TestInMemoryProvider(t *testing.T) {

7
provider/ns1/ns1_test.go
View File

@ -31,6 +31,7 @@ import (
"sigs.k8s.io/external-dns/endpoint" "sigs.k8s.io/external-dns/endpoint"
"sigs.k8s.io/external-dns/plan" "sigs.k8s.io/external-dns/plan"
"sigs.k8s.io/external-dns/provider"
) )
type MockNS1DomainClient struct { type MockNS1DomainClient struct {
@ -130,7 +131,7 @@ func TestNS1Records(t *testing.T) {
provider := &NS1Provider{ provider := &NS1Provider{
client: &MockNS1DomainClient{}, client: &MockNS1DomainClient{},
domainFilter: endpoint.NewDomainFilter([]string{"foo.com."}), domainFilter: endpoint.NewDomainFilter([]string{"foo.com."}),
zoneIDFilter: NewZoneIDFilter([]string{""}), zoneIDFilter: provider.NewZoneIDFilter([]string{""}),
} }
ctx := context.Background() ctx := context.Background()
@ -151,7 +152,7 @@ func TestNewNS1Provider(t *testing.T) {
_ = os.Setenv("NS1_APIKEY", "xxxxxxxxxxxxxxxxx") _ = os.Setenv("NS1_APIKEY", "xxxxxxxxxxxxxxxxx")
testNS1Config := NS1Config{ testNS1Config := NS1Config{
DomainFilter: endpoint.NewDomainFilter([]string{"foo.com."}), DomainFilter: endpoint.NewDomainFilter([]string{"foo.com."}),
ZoneIDFilter: NewZoneIDFilter([]string{""}), ZoneIDFilter: provider.NewZoneIDFilter([]string{""}),
DryRun: false, DryRun: false,
} }
_, err := NewNS1Provider(testNS1Config) _, err := NewNS1Provider(testNS1Config)
@ -166,7 +167,7 @@ func TestNS1Zones(t *testing.T) {
provider := &NS1Provider{ provider := &NS1Provider{
client: &MockNS1DomainClient{}, client: &MockNS1DomainClient{},
domainFilter: endpoint.NewDomainFilter([]string{"foo.com."}), domainFilter: endpoint.NewDomainFilter([]string{"foo.com."}),
zoneIDFilter: NewZoneIDFilter([]string{""}), zoneIDFilter: provider.NewZoneIDFilter([]string{""}),
} }
zones, err := provider.zonesFiltered() zones, err := provider.zonesFiltered()

23
provider/oci/oci_test.go
View File

@ -28,6 +28,7 @@ import (
"sigs.k8s.io/external-dns/endpoint" "sigs.k8s.io/external-dns/endpoint"
"sigs.k8s.io/external-dns/plan" "sigs.k8s.io/external-dns/plan"
"sigs.k8s.io/external-dns/provider"
) )
type mockOCIDNSClient struct{} type mockOCIDNSClient struct{}
@ -100,7 +101,7 @@ func (c *mockOCIDNSClient) PatchZoneRecords(ctx context.Context, request dns.Pat
} }
// newOCIProvider creates an OCI provider with API calls mocked out. // newOCIProvider creates an OCI provider with API calls mocked out.
func newOCIProvider(client ociDNSClient, domainFilter endpoint.DomainFilter, zoneIDFilter ZoneIDFilter, dryRun bool) *OCIProvider { func newOCIProvider(client ociDNSClient, domainFilter endpoint.DomainFilter, zoneIDFilter provider.ZoneIDFilter, dryRun bool) *OCIProvider {
return &OCIProvider{ return &OCIProvider{
client: client, client: client,
cfg: OCIConfig{ cfg: OCIConfig{
@ -184,7 +185,7 @@ hKRtDhmSdWBo3tJK12RrAe4t7CUe8gMgTvU7ExlcA3xQkseFPx9K
_, err := NewOCIProvider( _, err := NewOCIProvider(
tc.config, tc.config,
endpoint.NewDomainFilter([]string{"com"}), endpoint.NewDomainFilter([]string{"com"}),
NewZoneIDFilter([]string{""}), provider.NewZoneIDFilter([]string{""}),
false, false,
) )
if err == nil { if err == nil {
@ -200,13 +201,13 @@ func TestOCIZones(t *testing.T) {
testCases := []struct { testCases := []struct {
name string name string
domainFilter endpoint.DomainFilter domainFilter endpoint.DomainFilter
zoneIDFilter ZoneIDFilter zoneIDFilter provider.ZoneIDFilter
expected map[string]dns.ZoneSummary expected map[string]dns.ZoneSummary
}{ }{
{ {
name: "DomainFilter_com", name: "DomainFilter_com",
domainFilter: endpoint.NewDomainFilter([]string{"com"}), domainFilter: endpoint.NewDomainFilter([]string{"com"}),
zoneIDFilter: NewZoneIDFilter([]string{""}), zoneIDFilter: provider.NewZoneIDFilter([]string{""}),
expected: map[string]dns.ZoneSummary{ expected: map[string]dns.ZoneSummary{
"foo.com": { "foo.com": {
Id: common.String("ocid1.dns-zone.oc1..e1e042ef0bfbb5c251b9713fd7bf8959"), Id: common.String("ocid1.dns-zone.oc1..e1e042ef0bfbb5c251b9713fd7bf8959"),
@ -220,7 +221,7 @@ func TestOCIZones(t *testing.T) {
}, { }, {
name: "DomainFilter_foo.com", name: "DomainFilter_foo.com",
domainFilter: endpoint.NewDomainFilter([]string{"foo.com"}), domainFilter: endpoint.NewDomainFilter([]string{"foo.com"}),
zoneIDFilter: NewZoneIDFilter([]string{""}), zoneIDFilter: provider.NewZoneIDFilter([]string{""}),
expected: map[string]dns.ZoneSummary{ expected: map[string]dns.ZoneSummary{
"foo.com": { "foo.com": {
Id: common.String("ocid1.dns-zone.oc1..e1e042ef0bfbb5c251b9713fd7bf8959"), Id: common.String("ocid1.dns-zone.oc1..e1e042ef0bfbb5c251b9713fd7bf8959"),
@ -230,7 +231,7 @@ func TestOCIZones(t *testing.T) {
}, { }, {
name: "ZoneIDFilter_ocid1.dns-zone.oc1..e1e042ef0bfbb5c251b9713fd7bf8959", name: "ZoneIDFilter_ocid1.dns-zone.oc1..e1e042ef0bfbb5c251b9713fd7bf8959",
domainFilter: endpoint.NewDomainFilter([]string{""}), domainFilter: endpoint.NewDomainFilter([]string{""}),
zoneIDFilter: NewZoneIDFilter([]string{"ocid1.dns-zone.oc1..e1e042ef0bfbb5c251b9713fd7bf8959"}), zoneIDFilter: provider.NewZoneIDFilter([]string{"ocid1.dns-zone.oc1..e1e042ef0bfbb5c251b9713fd7bf8959"}),
expected: map[string]dns.ZoneSummary{ expected: map[string]dns.ZoneSummary{
"foo.com": { "foo.com": {
Id: common.String("ocid1.dns-zone.oc1..e1e042ef0bfbb5c251b9713fd7bf8959"), Id: common.String("ocid1.dns-zone.oc1..e1e042ef0bfbb5c251b9713fd7bf8959"),
@ -253,13 +254,13 @@ func TestOCIRecords(t *testing.T) {
testCases := []struct { testCases := []struct {
name string name string
domainFilter endpoint.DomainFilter domainFilter endpoint.DomainFilter
zoneIDFilter ZoneIDFilter zoneIDFilter provider.ZoneIDFilter
expected []*endpoint.Endpoint expected []*endpoint.Endpoint
}{ }{
{ {
name: "unfiltered", name: "unfiltered",
domainFilter: endpoint.NewDomainFilter([]string{""}), domainFilter: endpoint.NewDomainFilter([]string{""}),
zoneIDFilter: NewZoneIDFilter([]string{""}), zoneIDFilter: provider.NewZoneIDFilter([]string{""}),
expected: []*endpoint.Endpoint{ expected: []*endpoint.Endpoint{
endpoint.NewEndpointWithTTL("foo.foo.com", endpoint.RecordTypeA, endpoint.TTL(ociRecordTTL), "127.0.0.1"), endpoint.NewEndpointWithTTL("foo.foo.com", endpoint.RecordTypeA, endpoint.TTL(ociRecordTTL), "127.0.0.1"),
endpoint.NewEndpointWithTTL("foo.foo.com", endpoint.RecordTypeTXT, endpoint.TTL(ociRecordTTL), "heritage=external-dns,external-dns/owner=default,external-dns/resource=service/default/my-svc"), endpoint.NewEndpointWithTTL("foo.foo.com", endpoint.RecordTypeTXT, endpoint.TTL(ociRecordTTL), "heritage=external-dns,external-dns/owner=default,external-dns/resource=service/default/my-svc"),
@ -269,7 +270,7 @@ func TestOCIRecords(t *testing.T) {
}, { }, {
name: "DomainFilter_foo.com", name: "DomainFilter_foo.com",
domainFilter: endpoint.NewDomainFilter([]string{"foo.com"}), domainFilter: endpoint.NewDomainFilter([]string{"foo.com"}),
zoneIDFilter: NewZoneIDFilter([]string{""}), zoneIDFilter: provider.NewZoneIDFilter([]string{""}),
expected: []*endpoint.Endpoint{ expected: []*endpoint.Endpoint{
endpoint.NewEndpointWithTTL("foo.foo.com", endpoint.RecordTypeA, endpoint.TTL(ociRecordTTL), "127.0.0.1"), endpoint.NewEndpointWithTTL("foo.foo.com", endpoint.RecordTypeA, endpoint.TTL(ociRecordTTL), "127.0.0.1"),
endpoint.NewEndpointWithTTL("foo.foo.com", endpoint.RecordTypeTXT, endpoint.TTL(ociRecordTTL), "heritage=external-dns,external-dns/owner=default,external-dns/resource=service/default/my-svc"), endpoint.NewEndpointWithTTL("foo.foo.com", endpoint.RecordTypeTXT, endpoint.TTL(ociRecordTTL), "heritage=external-dns,external-dns/owner=default,external-dns/resource=service/default/my-svc"),
@ -278,7 +279,7 @@ func TestOCIRecords(t *testing.T) {
}, { }, {
name: "ZoneIDFilter_ocid1.dns-zone.oc1..502aeddba262b92fd13ed7874f6f1404", name: "ZoneIDFilter_ocid1.dns-zone.oc1..502aeddba262b92fd13ed7874f6f1404",
domainFilter: endpoint.NewDomainFilter([]string{""}), domainFilter: endpoint.NewDomainFilter([]string{""}),
zoneIDFilter: NewZoneIDFilter([]string{"ocid1.dns-zone.oc1..502aeddba262b92fd13ed7874f6f1404"}), zoneIDFilter: provider.NewZoneIDFilter([]string{"ocid1.dns-zone.oc1..502aeddba262b92fd13ed7874f6f1404"}),
expected: []*endpoint.Endpoint{ expected: []*endpoint.Endpoint{
endpoint.NewEndpointWithTTL("foo.bar.com", endpoint.RecordTypeA, endpoint.TTL(ociRecordTTL), "127.0.0.1"), endpoint.NewEndpointWithTTL("foo.bar.com", endpoint.RecordTypeA, endpoint.TTL(ociRecordTTL), "127.0.0.1"),
}, },
@ -826,7 +827,7 @@ func TestOCIApplyChanges(t *testing.T) {
provider := newOCIProvider( provider := newOCIProvider(
client, client,
endpoint.NewDomainFilter([]string{""}), endpoint.NewDomainFilter([]string{""}),
NewZoneIDFilter([]string{""}), provider.NewZoneIDFilter([]string{""}),
tc.dryRun, tc.dryRun,
) )

16
provider/pdns/pdns_test.go
View File

@ -735,7 +735,7 @@ func (suite *NewPDNSProviderTestSuite) TestPDNSProviderCreateTLS() {
DomainFilter: endpoint.NewDomainFilter([]string{""}), DomainFilter: endpoint.NewDomainFilter([]string{""}),
TLSConfig: TLSConfig{ TLSConfig: TLSConfig{
TLSEnabled: true, TLSEnabled: true,
CAFilePath: "../internal/testresources/ca.pem", CAFilePath: "../../internal/testresources/ca.pem",
}, },
}) })
assert.Nil(suite.T(), err, "Enabled TLS Config with --tls-ca should raise no error") assert.Nil(suite.T(), err, "Enabled TLS Config with --tls-ca should raise no error")
@ -748,8 +748,8 @@ func (suite *NewPDNSProviderTestSuite) TestPDNSProviderCreateTLS() {
DomainFilter: endpoint.NewDomainFilter([]string{""}), DomainFilter: endpoint.NewDomainFilter([]string{""}),
TLSConfig: TLSConfig{ TLSConfig: TLSConfig{
TLSEnabled: true, TLSEnabled: true,
CAFilePath: "../internal/testresources/ca.pem", CAFilePath: "../../internal/testresources/ca.pem",
ClientCertFilePath: "../internal/testresources/client-cert.pem", ClientCertFilePath: "../../internal/testresources/client-cert.pem",
}, },
}) })
assert.Error(suite.T(), err, "Enabled TLS Config with --tls-client-cert only should raise an error") assert.Error(suite.T(), err, "Enabled TLS Config with --tls-client-cert only should raise an error")
@ -762,8 +762,8 @@ func (suite *NewPDNSProviderTestSuite) TestPDNSProviderCreateTLS() {
DomainFilter: endpoint.NewDomainFilter([]string{""}), DomainFilter: endpoint.NewDomainFilter([]string{""}),
TLSConfig: TLSConfig{ TLSConfig: TLSConfig{
TLSEnabled: true, TLSEnabled: true,
CAFilePath: "../internal/testresources/ca.pem", CAFilePath: "../../internal/testresources/ca.pem",
ClientCertKeyFilePath: "../internal/testresources/client-cert-key.pem", ClientCertKeyFilePath: "../../internal/testresources/client-cert-key.pem",
}, },
}) })
assert.Error(suite.T(), err, "Enabled TLS Config with --tls-client-cert-key only should raise an error") assert.Error(suite.T(), err, "Enabled TLS Config with --tls-client-cert-key only should raise an error")
@ -776,9 +776,9 @@ func (suite *NewPDNSProviderTestSuite) TestPDNSProviderCreateTLS() {
DomainFilter: endpoint.NewDomainFilter([]string{""}), DomainFilter: endpoint.NewDomainFilter([]string{""}),
TLSConfig: TLSConfig{ TLSConfig: TLSConfig{
TLSEnabled: true, TLSEnabled: true,
CAFilePath: "../internal/testresources/ca.pem", CAFilePath: "../../internal/testresources/ca.pem",
ClientCertFilePath: "../internal/testresources/client-cert.pem", ClientCertFilePath: "../../internal/testresources/client-cert.pem",
ClientCertKeyFilePath: "../internal/testresources/client-cert-key.pem", ClientCertKeyFilePath: "../../internal/testresources/client-cert-key.pem",
}, },
}) })
assert.Nil(suite.T(), err, "Enabled TLS Config with all flags should raise no error") assert.Nil(suite.T(), err, "Enabled TLS Config with all flags should raise no error")

2
provider/provider_test.go
View File

@ -37,7 +37,7 @@ func TestEnsureTrailingDot(t *testing.T) {
{"example.org.", "example.org."}, {"example.org.", "example.org."},
{"8.8.8.8", "8.8.8.8"}, {"8.8.8.8", "8.8.8.8"},
} { } {
output := ensureTrailingDot(tc.input) output := EnsureTrailingDot(tc.input)
if output != tc.expected { if output != tc.expected {
t.Errorf("expected %s, got %s", tc.expected, output) t.Errorf("expected %s, got %s", tc.expected, output)

2
provider/recordfilter_test.go
View File

@ -41,7 +41,7 @@ func TestRecordTypeFilter(t *testing.T) {
}, },
} }
for _, r := range records { for _, r := range records {
got := supportedRecordType(r.rtype) got := SupportedRecordType(r.rtype)
if r.expect != got { if r.expect != got {
t.Errorf("wrong record type %s: expect %v, but got %v", r.rtype, r.expect, got) t.Errorf("wrong record type %s: expect %v, but got %v", r.rtype, r.expect, got)
} }

12
provider/rfc2136/rfc2136_test.go
View File

@ -29,6 +29,7 @@ import (
"sigs.k8s.io/external-dns/endpoint" "sigs.k8s.io/external-dns/endpoint"
"sigs.k8s.io/external-dns/plan" "sigs.k8s.io/external-dns/plan"
"sigs.k8s.io/external-dns/provider"
) )
type rfc2136Stub struct { type rfc2136Stub struct {
@ -93,7 +94,7 @@ func (r *rfc2136Stub) IncomeTransfer(m *dns.Msg, a string) (env chan *dns.Envelo
return outChan, nil return outChan, nil
} }
func createRfc2136StubProvider(stub *rfc2136Stub) (Provider, error) { func createRfc2136StubProvider(stub *rfc2136Stub) (provider.Provider, error) {
return NewRfc2136Provider("", 0, "", false, "key", "secret", "hmac-sha512", true, endpoint.DomainFilter{}, false, 300*time.Second, stub) return NewRfc2136Provider("", 0, "", false, "key", "secret", "hmac-sha512", true, endpoint.DomainFilter{}, false, 300*time.Second, stub)
} }
@ -246,3 +247,12 @@ func TestRfc2136ApplyChangesWithDifferentTTLs(t *testing.T) {
assert.True(t, strings.Contains(createRecords[2], "300")) assert.True(t, strings.Contains(createRecords[2], "300"))
} }
func contains(arr []*endpoint.Endpoint, name string) bool {
for _, a := range arr {
if a.DNSName == name {
return true
}
}
return false
}

15
provider/vinyldns/vinyldns_test.go
View File

@ -28,6 +28,7 @@ import (
"sigs.k8s.io/external-dns/endpoint" "sigs.k8s.io/external-dns/endpoint"
"sigs.k8s.io/external-dns/plan" "sigs.k8s.io/external-dns/plan"
"sigs.k8s.io/external-dns/provider"
) )
type mockVinyldnsZoneInterface struct { type mockVinyldnsZoneInterface struct {
@ -97,12 +98,12 @@ func testVinylDNSProviderRecords(t *testing.T) {
assert.Nil(t, err) assert.Nil(t, err)
assert.Equal(t, len(vinylDNSRecords), len(result)) assert.Equal(t, len(vinylDNSRecords), len(result))
mockVinylDNSProvider.zoneFilter = NewZoneIDFilter([]string{"0"}) mockVinylDNSProvider.zoneFilter = provider.NewZoneIDFilter([]string{"0"})
result, err = mockVinylDNSProvider.Records(ctx) result, err = mockVinylDNSProvider.Records(ctx)
assert.Nil(t, err) assert.Nil(t, err)
assert.Equal(t, len(vinylDNSRecords), len(result)) assert.Equal(t, len(vinylDNSRecords), len(result))
mockVinylDNSProvider.zoneFilter = NewZoneIDFilter([]string{"1"}) mockVinylDNSProvider.zoneFilter = provider.NewZoneIDFilter([]string{"1"})
result, err = mockVinylDNSProvider.Records(ctx) result, err = mockVinylDNSProvider.Records(ctx)
assert.Nil(t, err) assert.Nil(t, err)
assert.Equal(t, 0, len(result)) assert.Equal(t, 0, len(result))
@ -118,7 +119,7 @@ func testVinylDNSProviderApplyChanges(t *testing.T) {
} }
changes.Delete = []*endpoint.Endpoint{{DNSName: "example.com", Targets: endpoint.Targets{"vinyldns.com"}, RecordType: endpoint.RecordTypeCNAME}} changes.Delete = []*endpoint.Endpoint{{DNSName: "example.com", Targets: endpoint.Targets{"vinyldns.com"}, RecordType: endpoint.RecordTypeCNAME}}
mockVinylDNSProvider.zoneFilter = NewZoneIDFilter([]string{"1"}) mockVinylDNSProvider.zoneFilter = provider.NewZoneIDFilter([]string{"1"})
err := mockVinylDNSProvider.ApplyChanges(context.Background(), changes) err := mockVinylDNSProvider.ApplyChanges(context.Background(), changes)
if err != nil { if err != nil {
t.Errorf("Failed to apply changes: %v", err) t.Errorf("Failed to apply changes: %v", err)
@ -126,7 +127,7 @@ func testVinylDNSProviderApplyChanges(t *testing.T) {
} }
func testVinylDNSSuitableZone(t *testing.T) { func testVinylDNSSuitableZone(t *testing.T) {
mockVinylDNSProvider.zoneFilter = NewZoneIDFilter([]string{"0"}) mockVinylDNSProvider.zoneFilter = provider.NewZoneIDFilter([]string{"0"})
zone := vinyldnsSuitableZone("example.com", vinylDNSZones) zone := vinyldnsSuitableZone("example.com", vinylDNSZones)
assert.Equal(t, zone.Name, "example.com.") assert.Equal(t, zone.Name, "example.com.")
@ -134,11 +135,11 @@ func testVinylDNSSuitableZone(t *testing.T) {
func TestNewVinylDNSProvider(t *testing.T) { func TestNewVinylDNSProvider(t *testing.T) {
os.Setenv("VINYLDNS_ACCESS_KEY", "xxxxxxxxxxxxxxxxxxxxxxxxxx") os.Setenv("VINYLDNS_ACCESS_KEY", "xxxxxxxxxxxxxxxxxxxxxxxxxx")
_, err := NewVinylDNSProvider(endpoint.NewDomainFilter([]string{"example.com"}), NewZoneIDFilter([]string{"0"}), true) _, err := NewVinylDNSProvider(endpoint.NewDomainFilter([]string{"example.com"}), provider.NewZoneIDFilter([]string{"0"}), true)
assert.Nil(t, err) assert.Nil(t, err)
os.Unsetenv("VINYLDNS_ACCESS_KEY") os.Unsetenv("VINYLDNS_ACCESS_KEY")
_, err = NewVinylDNSProvider(endpoint.NewDomainFilter([]string{"example.com"}), NewZoneIDFilter([]string{"0"}), true) _, err = NewVinylDNSProvider(endpoint.NewDomainFilter([]string{"example.com"}), provider.NewZoneIDFilter([]string{"0"}), true)
assert.NotNil(t, err) assert.NotNil(t, err)
if err == nil { if err == nil {
t.Errorf("Expected to fail new provider on empty token") t.Errorf("Expected to fail new provider on empty token")
@ -146,7 +147,7 @@ func TestNewVinylDNSProvider(t *testing.T) {
} }
func testVinylDNSFindRecordSetID(t *testing.T) { func testVinylDNSFindRecordSetID(t *testing.T) {
mockVinylDNSProvider.zoneFilter = NewZoneIDFilter([]string{"0"}) mockVinylDNSProvider.zoneFilter = provider.NewZoneIDFilter([]string{"0"})
result, err := mockVinylDNSProvider.findRecordSetID("0", "example.com.") result, err := mockVinylDNSProvider.findRecordSetID("0", "example.com.")
assert.Nil(t, err) assert.Nil(t, err)
assert.Equal(t, "", result) assert.Equal(t, "", result)

4
provider/zonefinder_test.go
View File

@ -23,12 +23,12 @@ import (
) )
func TestZoneIDName(t *testing.T) { func TestZoneIDName(t *testing.T) {
z := zoneIDName{} z := ZoneIDName{}
z.Add("123456", "foo.bar") z.Add("123456", "foo.bar")
z.Add("123456", "qux.baz") z.Add("123456", "qux.baz")
z.Add("654321", "foo.qux.baz") z.Add("654321", "foo.qux.baz")
assert.Equal(t, zoneIDName{ assert.Equal(t, ZoneIDName{
"123456": "qux.baz", "123456": "qux.baz",
"654321": "foo.qux.baz", "654321": "foo.qux.baz",
}, z) }, z)

20
registry/noop_test.go
View File

@ -26,7 +26,7 @@ import (
"sigs.k8s.io/external-dns/endpoint" "sigs.k8s.io/external-dns/endpoint"
"sigs.k8s.io/external-dns/internal/testutils" "sigs.k8s.io/external-dns/internal/testutils"
"sigs.k8s.io/external-dns/plan" "sigs.k8s.io/external-dns/plan"
"sigs.k8s.io/external-dns/provider" "sigs.k8s.io/external-dns/provider/inmemory"
) )
var _ Registry = &NoopRegistry{} var _ Registry = &NoopRegistry{}
@ -38,7 +38,7 @@ func TestNoopRegistry(t *testing.T) {
} }
func testNoopInit(t *testing.T) { func testNoopInit(t *testing.T) {
p := provider.NewInMemoryProvider() p := inmemory.NewInMemoryProvider()
r, err := NewNoopRegistry(p) r, err := NewNoopRegistry(p)
require.NoError(t, err) require.NoError(t, err)
assert.Equal(t, p, r.provider) assert.Equal(t, p, r.provider)
@ -46,9 +46,9 @@ func testNoopInit(t *testing.T) {
func testNoopRecords(t *testing.T) { func testNoopRecords(t *testing.T) {
ctx := context.Background() ctx := context.Background()
p := provider.NewInMemoryProvider() p := inmemory.NewInMemoryProvider()
p.CreateZone("org") p.CreateZone("org")
providerRecords := []*endpoint.Endpoint{ inmemoryRecords := []*endpoint.Endpoint{
{ {
DNSName: "example.org", DNSName: "example.org",
Targets: endpoint.Targets{"example-lb.com"}, Targets: endpoint.Targets{"example-lb.com"},
@ -56,21 +56,21 @@ func testNoopRecords(t *testing.T) {
}, },
} }
p.ApplyChanges(ctx, &plan.Changes{ p.ApplyChanges(ctx, &plan.Changes{
Create: providerRecords, Create: inmemoryRecords,
}) })
r, _ := NewNoopRegistry(p) r, _ := NewNoopRegistry(p)
eps, err := r.Records(ctx) eps, err := r.Records(ctx)
require.NoError(t, err) require.NoError(t, err)
assert.True(t, testutils.SameEndpoints(eps, providerRecords)) assert.True(t, testutils.SameEndpoints(eps, inmemoryRecords))
} }
func testNoopApplyChanges(t *testing.T) { func testNoopApplyChanges(t *testing.T) {
// do some prep // do some prep
p := provider.NewInMemoryProvider() p := inmemory.NewInMemoryProvider()
p.CreateZone("org") p.CreateZone("org")
providerRecords := []*endpoint.Endpoint{ inmemoryRecords := []*endpoint.Endpoint{
{ {
DNSName: "example.org", DNSName: "example.org",
Targets: endpoint.Targets{"old-lb.com"}, Targets: endpoint.Targets{"old-lb.com"},
@ -92,7 +92,7 @@ func testNoopApplyChanges(t *testing.T) {
ctx := context.Background() ctx := context.Background()
p.ApplyChanges(ctx, &plan.Changes{ p.ApplyChanges(ctx, &plan.Changes{
Create: providerRecords, Create: inmemoryRecords,
}) })
// wrong changes // wrong changes
@ -106,7 +106,7 @@ func testNoopApplyChanges(t *testing.T) {
}, },
}, },
}) })
assert.EqualError(t, err, provider.ErrRecordAlreadyExists.Error()) assert.EqualError(t, err, inmemory.ErrRecordAlreadyExists.Error())
//correct changes //correct changes
require.NoError(t, r.ApplyChanges(ctx, &plan.Changes{ require.NoError(t, r.ApplyChanges(ctx, &plan.Changes{

11
registry/txt_test.go
View File

@ -29,6 +29,7 @@ import (
"sigs.k8s.io/external-dns/internal/testutils" "sigs.k8s.io/external-dns/internal/testutils"
"sigs.k8s.io/external-dns/plan" "sigs.k8s.io/external-dns/plan"
"sigs.k8s.io/external-dns/provider" "sigs.k8s.io/external-dns/provider"
"sigs.k8s.io/external-dns/provider/inmemory"
) )
const ( const (
@ -42,7 +43,7 @@ func TestTXTRegistry(t *testing.T) {
} }
func testTXTRegistryNew(t *testing.T) { func testTXTRegistryNew(t *testing.T) {
p := provider.NewInMemoryProvider() p := inmemory.NewInMemoryProvider()
_, err := NewTXTRegistry(p, "txt", "", time.Hour) _, err := NewTXTRegistry(p, "txt", "", time.Hour)
require.Error(t, err) require.Error(t, err)
@ -68,7 +69,7 @@ func testTXTRegistryRecords(t *testing.T) {
func testTXTRegistryRecordsPrefixed(t *testing.T) { func testTXTRegistryRecordsPrefixed(t *testing.T) {
ctx := context.Background() ctx := context.Background()
p := provider.NewInMemoryProvider() p := inmemory.NewInMemoryProvider()
p.CreateZone(testZone) p.CreateZone(testZone)
p.ApplyChanges(ctx, &plan.Changes{ p.ApplyChanges(ctx, &plan.Changes{
Create: []*endpoint.Endpoint{ Create: []*endpoint.Endpoint{
@ -172,7 +173,7 @@ func testTXTRegistryRecordsPrefixed(t *testing.T) {
} }
func testTXTRegistryRecordsNoPrefix(t *testing.T) { func testTXTRegistryRecordsNoPrefix(t *testing.T) {
p := provider.NewInMemoryProvider() p := inmemory.NewInMemoryProvider()
ctx := context.Background() ctx := context.Background()
p.CreateZone(testZone) p.CreateZone(testZone)
p.ApplyChanges(ctx, &plan.Changes{ p.ApplyChanges(ctx, &plan.Changes{
@ -252,7 +253,7 @@ func testTXTRegistryApplyChanges(t *testing.T) {
} }
func testTXTRegistryApplyChangesWithPrefix(t *testing.T) { func testTXTRegistryApplyChangesWithPrefix(t *testing.T) {
p := provider.NewInMemoryProvider() p := inmemory.NewInMemoryProvider()
p.CreateZone(testZone) p.CreateZone(testZone)
ctxEndpoints := []*endpoint.Endpoint{} ctxEndpoints := []*endpoint.Endpoint{}
ctx := context.WithValue(context.Background(), provider.RecordsContextKey, ctxEndpoints) ctx := context.WithValue(context.Background(), provider.RecordsContextKey, ctxEndpoints)
@ -343,7 +344,7 @@ func testTXTRegistryApplyChangesWithPrefix(t *testing.T) {
} }
func testTXTRegistryApplyChangesNoPrefix(t *testing.T) { func testTXTRegistryApplyChangesNoPrefix(t *testing.T) {
p := provider.NewInMemoryProvider() p := inmemory.NewInMemoryProvider()
p.CreateZone(testZone) p.CreateZone(testZone)
ctxEndpoints := []*endpoint.Endpoint{} ctxEndpoints := []*endpoint.Endpoint{}
ctx := context.WithValue(context.Background(), provider.RecordsContextKey, ctxEndpoints) ctx := context.WithValue(context.Background(), provider.RecordsContextKey, ctxEndpoints)