From 6fc68a82dbb8de1bbf453e968e1539baeb39352c Mon Sep 17 00:00:00 2001 From: Rick Henry Date: Tue, 7 Dec 2021 14:38:34 +0000 Subject: [PATCH] Reformat code to meet lint standards --- provider/safedns/safedns.go | 360 ++++++++++---------- provider/safedns/safedns_test.go | 553 +++++++++++++++---------------- 2 files changed, 456 insertions(+), 457 deletions(-) diff --git a/provider/safedns/safedns.go b/provider/safedns/safedns.go index f313b133a..947414591 100644 --- a/provider/safedns/safedns.go +++ b/provider/safedns/safedns.go @@ -17,225 +17,225 @@ limitations under the License. package safedns import ( - "context" - "fmt" - "os" + "context" + "fmt" + "os" - "github.com/ukfast/sdk-go/pkg/service/safedns" - log "github.com/sirupsen/logrus" - ukf_client "github.com/ukfast/sdk-go/pkg/client" - ukf_connection "github.com/ukfast/sdk-go/pkg/connection" + log "github.com/sirupsen/logrus" + ukfClient "github.com/ukfast/sdk-go/pkg/client" + ukfConnection "github.com/ukfast/sdk-go/pkg/connection" + "github.com/ukfast/sdk-go/pkg/service/safedns" - "sigs.k8s.io/external-dns/provider" - "sigs.k8s.io/external-dns/endpoint" - "sigs.k8s.io/external-dns/plan" + "sigs.k8s.io/external-dns/endpoint" + "sigs.k8s.io/external-dns/plan" + "sigs.k8s.io/external-dns/provider" ) // SafeDNS is an interface that is a subset of the SafeDNS service API that are actually used. // Signatures must match exactly. type SafeDNS interface { - CreateZoneRecord(zoneName string, req safedns.CreateRecordRequest) (int, error) - DeleteZoneRecord(zoneName string, recordID int) error - GetZone(zoneName string) (safedns.Zone, error) - GetZoneRecord(zoneName string, recordID int) (safedns.Record, error) - GetZoneRecords(zoneName string, parameters ukf_connection.APIRequestParameters) ([]safedns.Record, error) - GetZones(parameters ukf_connection.APIRequestParameters) ([]safedns.Zone, error) - PatchZoneRecord(zoneName string, recordID int, patch safedns.PatchRecordRequest) (int, error) - UpdateZoneRecord(zoneName string, record safedns.Record) (int, error) + CreateZoneRecord(zoneName string, req safedns.CreateRecordRequest) (int, error) + DeleteZoneRecord(zoneName string, recordID int) error + GetZone(zoneName string) (safedns.Zone, error) + GetZoneRecord(zoneName string, recordID int) (safedns.Record, error) + GetZoneRecords(zoneName string, parameters ukfConnection.APIRequestParameters) ([]safedns.Record, error) + GetZones(parameters ukfConnection.APIRequestParameters) ([]safedns.Zone, error) + PatchZoneRecord(zoneName string, recordID int, patch safedns.PatchRecordRequest) (int, error) + UpdateZoneRecord(zoneName string, record safedns.Record) (int, error) } // SafeDNSProvider implements the DNS provider spec for UKFast SafeDNS. type SafeDNSProvider struct { - provider.BaseProvider - Client SafeDNS - // Only consider hosted zones managing domains ending in this suffix - domainFilter endpoint.DomainFilter - DryRun bool - APIRequestParams ukf_connection.APIRequestParameters + provider.BaseProvider + Client SafeDNS + // Only consider hosted zones managing domains ending in this suffix + domainFilter endpoint.DomainFilter + DryRun bool + APIRequestParams ukfConnection.APIRequestParameters } // ZoneRecord is a datatype to simplify management of a record in a zone. type ZoneRecord struct { - ID int - Name string - Type safedns.RecordType - TTL safedns.RecordTTL - Zone string - Content string + ID int + Name string + Type safedns.RecordType + TTL safedns.RecordTTL + Zone string + Content string } func NewSafeDNSProvider(domainFilter endpoint.DomainFilter, dryRun bool) (*SafeDNSProvider, error) { - token, ok := os.LookupEnv("SAFEDNS_TOKEN") - if !ok { - return nil, fmt.Errorf("No SAFEDNS_TOKEN found in environment") - } + token, ok := os.LookupEnv("SAFEDNS_TOKEN") + if !ok { + return nil, fmt.Errorf("no SAFEDNS_TOKEN found in environment") + } - ukfAPIConnection := ukf_connection.NewAPIKeyCredentialsAPIConnection(token) - ukfClient := ukf_client.NewClient(ukfAPIConnection) - safeDNS := ukfClient.SafeDNSService() + ukfAPIConnection := ukfConnection.NewAPIKeyCredentialsAPIConnection(token) + ukfClient := ukfClient.NewClient(ukfAPIConnection) + safeDNS := ukfClient.SafeDNSService() - provider := &SafeDNSProvider{ - Client: safeDNS, - domainFilter: domainFilter, - DryRun: dryRun, - APIRequestParams: *ukf_connection.NewAPIRequestParameters(), - } - return provider, nil + provider := &SafeDNSProvider{ + Client: safeDNS, + domainFilter: domainFilter, + DryRun: dryRun, + APIRequestParams: *ukfConnection.NewAPIRequestParameters(), + } + return provider, nil } // Zones returns the list of hosted zones in the SafeDNS account func (p *SafeDNSProvider) Zones(ctx context.Context) ([]safedns.Zone, error) { - var zones []safedns.Zone + var zones []safedns.Zone - allZones, err := p.Client.GetZones(p.APIRequestParams) - if err != nil { - return nil, err - } + allZones, err := p.Client.GetZones(p.APIRequestParams) + if err != nil { + return nil, err + } - // Check each found zone to see whether they match the domain filter provided. If they do, append it to the array of - // zones defined above. If not, continue to the next item in the loop. - for _, zone := range allZones { - if p.domainFilter.Match(zone.Name) { - zones = append(zones, zone) - } else { - continue - } - } - return zones, nil + // Check each found zone to see whether they match the domain filter provided. If they do, append it to the array of + // zones defined above. If not, continue to the next item in the loop. + for _, zone := range allZones { + if p.domainFilter.Match(zone.Name) { + zones = append(zones, zone) + } else { + continue + } + } + return zones, nil } -func (p *SafeDNSProvider) ZoneRecords(ctx context.Context) ([]ZoneRecord, error){ - zones, err := p.Zones(ctx) - if err != nil { - return nil, err - } +func (p *SafeDNSProvider) ZoneRecords(ctx context.Context) ([]ZoneRecord, error) { + zones, err := p.Zones(ctx) + if err != nil { + return nil, err + } - var zoneRecords []ZoneRecord - for _, zone := range zones { - // For each zone in the zonelist, get all records of an ExternalDNS supported type. - records, err := p.Client.GetZoneRecords(zone.Name, p.APIRequestParams) - if err != nil { - return nil, err - } - for _, r := range records { - zoneRecord := ZoneRecord{ - ID: r.ID, - Name: r.Name, - Type: r.Type, - TTL: r.TTL, - Zone: zone.Name, - Content: r.Content, - } - zoneRecords = append(zoneRecords, zoneRecord) - } - } - return zoneRecords, nil + var zoneRecords []ZoneRecord + for _, zone := range zones { + // For each zone in the zonelist, get all records of an ExternalDNS supported type. + records, err := p.Client.GetZoneRecords(zone.Name, p.APIRequestParams) + if err != nil { + return nil, err + } + for _, r := range records { + zoneRecord := ZoneRecord{ + ID: r.ID, + Name: r.Name, + Type: r.Type, + TTL: r.TTL, + Zone: zone.Name, + Content: r.Content, + } + zoneRecords = append(zoneRecords, zoneRecord) + } + } + return zoneRecords, nil } // Records returns a list of Endpoint resources created from all records in supported zones. func (p *SafeDNSProvider) Records(ctx context.Context) ([]*endpoint.Endpoint, error) { - var endpoints []*endpoint.Endpoint - zoneRecords, err := p.ZoneRecords(ctx) - if err != nil { - return nil, err - } - for _, r := range zoneRecords { - if provider.SupportedRecordType(string(r.Type)) { - endpoints = append(endpoints, endpoint.NewEndpointWithTTL(r.Name, string(r.Type), endpoint.TTL(r.TTL), r.Content)) - } - } - return endpoints, nil + var endpoints []*endpoint.Endpoint + zoneRecords, err := p.ZoneRecords(ctx) + if err != nil { + return nil, err + } + for _, r := range zoneRecords { + if provider.SupportedRecordType(string(r.Type)) { + endpoints = append(endpoints, endpoint.NewEndpointWithTTL(r.Name, string(r.Type), endpoint.TTL(r.TTL), r.Content)) + } + } + return endpoints, nil } // ApplyChanges applies a given set of changes in a given zone. func (p *SafeDNSProvider) ApplyChanges(ctx context.Context, changes *plan.Changes) error { - // Identify the zone name for each record - zoneNameIDMapper := provider.ZoneIDName{} + // Identify the zone name for each record + zoneNameIDMapper := provider.ZoneIDName{} - zones, err := p.Zones(ctx) - if err != nil { - return err - } - for _, zone := range zones { - zoneNameIDMapper.Add(zone.Name, zone.Name) - } + zones, err := p.Zones(ctx) + if err != nil { + return err + } + for _, zone := range zones { + zoneNameIDMapper.Add(zone.Name, zone.Name) + } - zoneRecords, err := p.ZoneRecords(ctx) - if err != nil { - return err - } + zoneRecords, err := p.ZoneRecords(ctx) + if err != nil { + return err + } - for _, endpoint := range changes.Create { - _, ZoneName := zoneNameIDMapper.FindZone(endpoint.DNSName) - for _, target := range endpoint.Targets { - request := safedns.CreateRecordRequest { - Name: endpoint.DNSName, - Type: endpoint.RecordType, - Content: target, - } - log.WithFields(log.Fields{ - "zoneID": ZoneName, - "dnsName": endpoint.DNSName, - "recordType": endpoint.RecordType, - "Value": target, - }).Info("Creating record") - _, err := p.Client.CreateZoneRecord(ZoneName, request) - if err != nil { - return err - } - } - } - for _, endpoint := range changes.UpdateNew { - // TODO: Find a more effient way of doing this. - // Currently iterates over each zoneRecord in ZoneRecords for each Endpoint in UpdateNew; the same will go for - // Delete. As it's double-iteration, that's O(n^2), which isn't great. - var zoneRecord ZoneRecord - for _, target := range endpoint.Targets { - for _, zr := range zoneRecords { - if zr.Name == endpoint.DNSName && zr.Content == target { - zoneRecord = zr - break - } - } + for _, endpoint := range changes.Create { + _, ZoneName := zoneNameIDMapper.FindZone(endpoint.DNSName) + for _, target := range endpoint.Targets { + request := safedns.CreateRecordRequest{ + Name: endpoint.DNSName, + Type: endpoint.RecordType, + Content: target, + } + log.WithFields(log.Fields{ + "zoneID": ZoneName, + "dnsName": endpoint.DNSName, + "recordType": endpoint.RecordType, + "Value": target, + }).Info("Creating record") + _, err := p.Client.CreateZoneRecord(ZoneName, request) + if err != nil { + return err + } + } + } + for _, endpoint := range changes.UpdateNew { + // TODO: Find a more effient way of doing this. + // Currently iterates over each zoneRecord in ZoneRecords for each Endpoint in UpdateNew; the same will go for + // Delete. As it's double-iteration, that's O(n^2), which isn't great. + var zoneRecord ZoneRecord + for _, target := range endpoint.Targets { + for _, zr := range zoneRecords { + if zr.Name == endpoint.DNSName && zr.Content == target { + zoneRecord = zr + break + } + } - newTTL := safedns.RecordTTL(int(endpoint.RecordTTL)) - newRecord := safedns.PatchRecordRequest{ - Name: endpoint.DNSName, - Content: target, - TTL: &newTTL, - Type: endpoint.RecordType, - } - log.WithFields(log.Fields{ - "zoneID": zoneRecord.Zone, - "dnsName": newRecord.Name, - "recordType": newRecord.Type, - "Value": newRecord.Content, - "Priority": newRecord.Priority, - }).Info("Patching record") - _, err = p.Client.PatchZoneRecord(zoneRecord.Zone, zoneRecord.ID, newRecord) - if err != nil { - return err - } - } - } - for _, endpoint := range changes.Delete { - // TODO: Find a more effient way of doing this. - var zoneRecord ZoneRecord - for _, zr := range zoneRecords { - if zr.Name == endpoint.DNSName && string(zr.Type) == endpoint.RecordType { - zoneRecord = zr - break - } - } - log.WithFields(log.Fields{ - "zoneID": zoneRecord.Zone, - "dnsName": zoneRecord.Name, - "recordType": zoneRecord.Type, - }).Info("Deleting record") - err := p.Client.DeleteZoneRecord(zoneRecord.Zone, zoneRecord.ID) - if err != nil { - return err - } - } - return nil + newTTL := safedns.RecordTTL(int(endpoint.RecordTTL)) + newRecord := safedns.PatchRecordRequest{ + Name: endpoint.DNSName, + Content: target, + TTL: &newTTL, + Type: endpoint.RecordType, + } + log.WithFields(log.Fields{ + "zoneID": zoneRecord.Zone, + "dnsName": newRecord.Name, + "recordType": newRecord.Type, + "Value": newRecord.Content, + "Priority": newRecord.Priority, + }).Info("Patching record") + _, err = p.Client.PatchZoneRecord(zoneRecord.Zone, zoneRecord.ID, newRecord) + if err != nil { + return err + } + } + } + for _, endpoint := range changes.Delete { + // TODO: Find a more effient way of doing this. + var zoneRecord ZoneRecord + for _, zr := range zoneRecords { + if zr.Name == endpoint.DNSName && string(zr.Type) == endpoint.RecordType { + zoneRecord = zr + break + } + } + log.WithFields(log.Fields{ + "zoneID": zoneRecord.Zone, + "dnsName": zoneRecord.Name, + "recordType": zoneRecord.Type, + }).Info("Deleting record") + err := p.Client.DeleteZoneRecord(zoneRecord.Zone, zoneRecord.ID) + if err != nil { + return err + } + } + return nil } diff --git a/provider/safedns/safedns_test.go b/provider/safedns/safedns_test.go index 47fae0c78..3c6da6109 100644 --- a/provider/safedns/safedns_test.go +++ b/provider/safedns/safedns_test.go @@ -17,351 +17,350 @@ limitations under the License. package safedns import ( - "context" - "os" - "testing" + "context" + "os" + "testing" - "github.com/stretchr/testify/assert" - "github.com/stretchr/testify/mock" - "github.com/stretchr/testify/require" - "github.com/ukfast/sdk-go/pkg/service/safedns" - ukf_connection "github.com/ukfast/sdk-go/pkg/connection" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/mock" + "github.com/stretchr/testify/require" + ukfConnection "github.com/ukfast/sdk-go/pkg/connection" + "github.com/ukfast/sdk-go/pkg/service/safedns" - "sigs.k8s.io/external-dns/endpoint" - "sigs.k8s.io/external-dns/plan" + "sigs.k8s.io/external-dns/endpoint" + "sigs.k8s.io/external-dns/plan" ) // Create an implementation of the SafeDNS interface for Mocking type MockSafeDNSService struct { - mock.Mock + mock.Mock } func (m *MockSafeDNSService) CreateZoneRecord(zoneName string, req safedns.CreateRecordRequest) (int, error) { - args := m.Called(zoneName, req) - return args.Int(0), args.Error(1) + args := m.Called(zoneName, req) + return args.Int(0), args.Error(1) } func (m *MockSafeDNSService) DeleteZoneRecord(zoneName string, recordID int) error { - args := m.Called(zoneName, recordID) - return args.Error(0) + args := m.Called(zoneName, recordID) + return args.Error(0) } func (m *MockSafeDNSService) GetZone(zoneName string) (safedns.Zone, error) { - args := m.Called(zoneName) - return args.Get(0).(safedns.Zone), args.Error(1) + args := m.Called(zoneName) + return args.Get(0).(safedns.Zone), args.Error(1) } func (m *MockSafeDNSService) GetZoneRecord(zoneName string, recordID int) (safedns.Record, error) { - args := m.Called(zoneName, recordID) - return args.Get(0).(safedns.Record), args.Error(1) + args := m.Called(zoneName, recordID) + return args.Get(0).(safedns.Record), args.Error(1) } -func (m *MockSafeDNSService) GetZoneRecords(zoneName string, parameters ukf_connection.APIRequestParameters) ([]safedns.Record, error) { - args := m.Called(zoneName, parameters) - return args.Get(0).([]safedns.Record), args.Error(1) +func (m *MockSafeDNSService) GetZoneRecords(zoneName string, parameters ukfConnection.APIRequestParameters) ([]safedns.Record, error) { + args := m.Called(zoneName, parameters) + return args.Get(0).([]safedns.Record), args.Error(1) } -func (m *MockSafeDNSService) GetZones(parameters ukf_connection.APIRequestParameters) ([]safedns.Zone, error) { - args := m.Called(parameters) - return args.Get(0).([]safedns.Zone), args.Error(1) +func (m *MockSafeDNSService) GetZones(parameters ukfConnection.APIRequestParameters) ([]safedns.Zone, error) { + args := m.Called(parameters) + return args.Get(0).([]safedns.Zone), args.Error(1) } func (m *MockSafeDNSService) PatchZoneRecord(zoneName string, recordID int, patch safedns.PatchRecordRequest) (int, error) { - args := m.Called(zoneName, recordID, patch) - return args.Int(0), args.Error(1) + args := m.Called(zoneName, recordID, patch) + return args.Int(0), args.Error(1) } func (m *MockSafeDNSService) UpdateZoneRecord(zoneName string, record safedns.Record) (int, error) { - args := m.Called(zoneName, record) - return args.Int(0), args.Error(1) + args := m.Called(zoneName, record) + return args.Int(0), args.Error(1) } - // Utility functions func createZones() []safedns.Zone { - return []safedns.Zone{ - {Name: "foo.com", Description: "Foo dot com"}, - {Name: "bar.io", Description: ""}, - {Name: "baz.org", Description: "Org"}, - } + return []safedns.Zone{ + {Name: "foo.com", Description: "Foo dot com"}, + {Name: "bar.io", Description: ""}, + {Name: "baz.org", Description: "Org"}, + } } func createFooRecords() []safedns.Record { - return []safedns.Record{ - { - ID: 11, - Type: safedns.RecordTypeA, - Name: "foo.com", - Content: "targetFoo", - TTL: safedns.RecordTTL(3600), - }, - { - ID: 12, - Type: safedns.RecordTypeTXT, - Name: "foo.com", - Content: "text", - TTL: safedns.RecordTTL(3600), - }, - { - ID: 13, - Type: safedns.RecordTypeCAA, - Name: "foo.com", - Content: "", - TTL: safedns.RecordTTL(3600), - }, - } + return []safedns.Record{ + { + ID: 11, + Type: safedns.RecordTypeA, + Name: "foo.com", + Content: "targetFoo", + TTL: safedns.RecordTTL(3600), + }, + { + ID: 12, + Type: safedns.RecordTypeTXT, + Name: "foo.com", + Content: "text", + TTL: safedns.RecordTTL(3600), + }, + { + ID: 13, + Type: safedns.RecordTypeCAA, + Name: "foo.com", + Content: "", + TTL: safedns.RecordTTL(3600), + }, + } } func createBarRecords() []safedns.Record { - return []safedns.Record{} + return []safedns.Record{} } func createBazRecords() []safedns.Record { - return []safedns.Record{ - { - ID: 31, - Type: safedns.RecordTypeA, - Name: "baz.org", - Content: "targetBaz", - TTL: safedns.RecordTTL(3600), - }, - { - ID: 32, - Type: safedns.RecordTypeTXT, - Name: "baz.org", - Content: "text", - TTL: safedns.RecordTTL(3600), - }, - { - ID: 33, - Type: safedns.RecordTypeA, - Name: "api.baz.org", - Content: "targetBazAPI", - TTL: safedns.RecordTTL(3600), - }, - { - ID: 34, - Type: safedns.RecordTypeTXT, - Name: "api.baz.org", - Content: "text", - TTL: safedns.RecordTTL(3600), - }, - } + return []safedns.Record{ + { + ID: 31, + Type: safedns.RecordTypeA, + Name: "baz.org", + Content: "targetBaz", + TTL: safedns.RecordTTL(3600), + }, + { + ID: 32, + Type: safedns.RecordTypeTXT, + Name: "baz.org", + Content: "text", + TTL: safedns.RecordTTL(3600), + }, + { + ID: 33, + Type: safedns.RecordTypeA, + Name: "api.baz.org", + Content: "targetBazAPI", + TTL: safedns.RecordTTL(3600), + }, + { + ID: 34, + Type: safedns.RecordTypeTXT, + Name: "api.baz.org", + Content: "text", + TTL: safedns.RecordTTL(3600), + }, + } } // Actual tests func TestNewSafeDNSProvider(t *testing.T) { - _ = os.Setenv("SAFEDNS_TOKEN", "DUMMYVALUE") - _, err := NewSafeDNSProvider(endpoint.NewDomainFilter([]string{"ext-dns-test.zalando.to."}), true) - require.NoError(t, err) + _ = os.Setenv("SAFEDNS_TOKEN", "DUMMYVALUE") + _, err := NewSafeDNSProvider(endpoint.NewDomainFilter([]string{"ext-dns-test.zalando.to."}), true) + require.NoError(t, err) - _ = os.Unsetenv("SAFEDNS_TOKEN") - _, err = NewSafeDNSProvider(endpoint.NewDomainFilter([]string{"ext-dns-test.zalando.to."}), true) - require.Error(t, err) + _ = os.Unsetenv("SAFEDNS_TOKEN") + _, err = NewSafeDNSProvider(endpoint.NewDomainFilter([]string{"ext-dns-test.zalando.to."}), true) + require.Error(t, err) } func TestRecords(t *testing.T) { - mockSafeDNSService := MockSafeDNSService{} + mockSafeDNSService := MockSafeDNSService{} - provider := &SafeDNSProvider{ - Client: &mockSafeDNSService, - domainFilter: endpoint.NewDomainFilter([]string{}), - DryRun: false, - } + provider := &SafeDNSProvider{ + Client: &mockSafeDNSService, + domainFilter: endpoint.NewDomainFilter([]string{}), + DryRun: false, + } - mockSafeDNSService.On( - "GetZones", - mock.Anything, - ).Return(createZones(), nil).Once() + mockSafeDNSService.On( + "GetZones", + mock.Anything, + ).Return(createZones(), nil).Once() - mockSafeDNSService.On( - "GetZoneRecords", - "foo.com", - mock.Anything, - ).Return(createFooRecords(), nil).Once() + mockSafeDNSService.On( + "GetZoneRecords", + "foo.com", + mock.Anything, + ).Return(createFooRecords(), nil).Once() - mockSafeDNSService.On( - "GetZoneRecords", - "bar.io", - mock.Anything, - ).Return(createBarRecords(), nil).Once() + mockSafeDNSService.On( + "GetZoneRecords", + "bar.io", + mock.Anything, + ).Return(createBarRecords(), nil).Once() - mockSafeDNSService.On( - "GetZoneRecords", - "baz.org", - mock.Anything, - ).Return(createBazRecords(), nil).Once() + mockSafeDNSService.On( + "GetZoneRecords", + "baz.org", + mock.Anything, + ).Return(createBazRecords(), nil).Once() - actual, err := provider.Records(context.Background()) - require.NoError(t, err) + actual, err := provider.Records(context.Background()) + require.NoError(t, err) - expected := []*endpoint.Endpoint{ - { - DNSName: "foo.com", - Targets: []string{"targetFoo"}, - RecordType: "A", - RecordTTL: 3600, - Labels: endpoint.NewLabels(), - }, - { - DNSName: "foo.com", - Targets: []string{"text"}, - RecordType: "TXT", - RecordTTL: 3600, - Labels: endpoint.NewLabels(), - }, - { - DNSName: "baz.org", - Targets: []string{"targetBaz"}, - RecordType: "A", - RecordTTL: 3600, - Labels: endpoint.NewLabels(), - }, - { - DNSName: "baz.org", - Targets: []string{"text"}, - RecordType: "TXT", - RecordTTL: 3600, - Labels: endpoint.NewLabels(), - }, - { - DNSName: "api.baz.org", - Targets: []string{"targetBazAPI"}, - RecordType: "A", - RecordTTL: 3600, - Labels: endpoint.NewLabels(), - }, - { - DNSName: "api.baz.org", - Targets: []string{"text"}, - RecordType: "TXT", - RecordTTL: 3600, - Labels: endpoint.NewLabels(), - }, - } + expected := []*endpoint.Endpoint{ + { + DNSName: "foo.com", + Targets: []string{"targetFoo"}, + RecordType: "A", + RecordTTL: 3600, + Labels: endpoint.NewLabels(), + }, + { + DNSName: "foo.com", + Targets: []string{"text"}, + RecordType: "TXT", + RecordTTL: 3600, + Labels: endpoint.NewLabels(), + }, + { + DNSName: "baz.org", + Targets: []string{"targetBaz"}, + RecordType: "A", + RecordTTL: 3600, + Labels: endpoint.NewLabels(), + }, + { + DNSName: "baz.org", + Targets: []string{"text"}, + RecordType: "TXT", + RecordTTL: 3600, + Labels: endpoint.NewLabels(), + }, + { + DNSName: "api.baz.org", + Targets: []string{"targetBazAPI"}, + RecordType: "A", + RecordTTL: 3600, + Labels: endpoint.NewLabels(), + }, + { + DNSName: "api.baz.org", + Targets: []string{"text"}, + RecordType: "TXT", + RecordTTL: 3600, + Labels: endpoint.NewLabels(), + }, + } - mockSafeDNSService.AssertExpectations(t) - assert.Equal(t, expected, actual) + mockSafeDNSService.AssertExpectations(t) + assert.Equal(t, expected, actual) } -func TestSafeDNSApplyChanges( t *testing.T) { - mockSafeDNSService := MockSafeDNSService{} +func TestSafeDNSApplyChanges(t *testing.T) { + mockSafeDNSService := MockSafeDNSService{} - provider := &SafeDNSProvider{ - Client: &mockSafeDNSService, - domainFilter: endpoint.NewDomainFilter([]string{}), - DryRun: false, - } + provider := &SafeDNSProvider{ + Client: &mockSafeDNSService, + domainFilter: endpoint.NewDomainFilter([]string{}), + DryRun: false, + } - // Dummy data - mockSafeDNSService.On( - "GetZones", - mock.Anything, - ).Return(createZones(), nil).Once() - mockSafeDNSService.On( - "GetZones", - mock.Anything, - ).Return(createZones(), nil).Once() + // Dummy data + mockSafeDNSService.On( + "GetZones", + mock.Anything, + ).Return(createZones(), nil).Once() + mockSafeDNSService.On( + "GetZones", + mock.Anything, + ).Return(createZones(), nil).Once() - mockSafeDNSService.On( - "GetZoneRecords", - "foo.com", - mock.Anything, - ).Return(createFooRecords(), nil).Once() + mockSafeDNSService.On( + "GetZoneRecords", + "foo.com", + mock.Anything, + ).Return(createFooRecords(), nil).Once() - mockSafeDNSService.On( - "GetZoneRecords", - "bar.io", - mock.Anything, - ).Return(createBarRecords(), nil).Once() + mockSafeDNSService.On( + "GetZoneRecords", + "bar.io", + mock.Anything, + ).Return(createBarRecords(), nil).Once() - mockSafeDNSService.On( - "GetZoneRecords", - "baz.org", - mock.Anything, - ).Return(createBazRecords(), nil).Once() + mockSafeDNSService.On( + "GetZoneRecords", + "baz.org", + mock.Anything, + ).Return(createBazRecords(), nil).Once() - // Apply actions - mockSafeDNSService.On( - "DeleteZoneRecord", - "baz.org", - 33, - ).Return(nil).Once() - mockSafeDNSService.On( - "DeleteZoneRecord", - "baz.org", - 34, - ).Return(nil).Once() + // Apply actions + mockSafeDNSService.On( + "DeleteZoneRecord", + "baz.org", + 33, + ).Return(nil).Once() + mockSafeDNSService.On( + "DeleteZoneRecord", + "baz.org", + 34, + ).Return(nil).Once() - TTL300 := safedns.RecordTTL(300) - mockSafeDNSService.On( - "PatchZoneRecord", - "foo.com", - 11, - safedns.PatchRecordRequest{ - Type: "A", - Name: "foo.com", - Content: "targetFoo", - TTL: &TTL300, - }, - ).Return(123, nil).Once() + TTL300 := safedns.RecordTTL(300) + mockSafeDNSService.On( + "PatchZoneRecord", + "foo.com", + 11, + safedns.PatchRecordRequest{ + Type: "A", + Name: "foo.com", + Content: "targetFoo", + TTL: &TTL300, + }, + ).Return(123, nil).Once() - mockSafeDNSService.On( - "CreateZoneRecord", - "bar.io", - safedns.CreateRecordRequest{ - Type: "A", - Name: "create.bar.io", - Content: "targetBar", - }, - ).Return(246, nil).Once() + mockSafeDNSService.On( + "CreateZoneRecord", + "bar.io", + safedns.CreateRecordRequest{ + Type: "A", + Name: "create.bar.io", + Content: "targetBar", + }, + ).Return(246, nil).Once() - mockSafeDNSService.On( - "CreateZoneRecord", - "bar.io", - safedns.CreateRecordRequest{ - Type: "A", - Name: "bar.io", - Content: "targetBar", - }, - ).Return(369, nil).Once() + mockSafeDNSService.On( + "CreateZoneRecord", + "bar.io", + safedns.CreateRecordRequest{ + Type: "A", + Name: "bar.io", + Content: "targetBar", + }, + ).Return(369, nil).Once() - err := provider.ApplyChanges(context.Background(), &plan.Changes{ - Create: []*endpoint.Endpoint{ - { - DNSName: "create.bar.io", - RecordType: "A", - Targets: []string{"targetBar"}, - RecordTTL: 3600, - }, - { - DNSName: "bar.io", - RecordType: "A", - Targets: []string{"targetBar"}, - RecordTTL: 3600, - }, - }, - Delete: []*endpoint.Endpoint{ - { - DNSName: "api.baz.org", - RecordType: "A", - }, - { - DNSName: "api.baz.org", - RecordType: "TXT", - }, - }, - UpdateNew: []*endpoint.Endpoint{ - { - DNSName: "foo.com", - RecordType: "A", - RecordTTL: 300, - Targets: []string{"targetFoo"}, - }, - }, - UpdateOld: []*endpoint.Endpoint{}, - }) - require.NoError(t, err) + err := provider.ApplyChanges(context.Background(), &plan.Changes{ + Create: []*endpoint.Endpoint{ + { + DNSName: "create.bar.io", + RecordType: "A", + Targets: []string{"targetBar"}, + RecordTTL: 3600, + }, + { + DNSName: "bar.io", + RecordType: "A", + Targets: []string{"targetBar"}, + RecordTTL: 3600, + }, + }, + Delete: []*endpoint.Endpoint{ + { + DNSName: "api.baz.org", + RecordType: "A", + }, + { + DNSName: "api.baz.org", + RecordType: "TXT", + }, + }, + UpdateNew: []*endpoint.Endpoint{ + { + DNSName: "foo.com", + RecordType: "A", + RecordTTL: 300, + Targets: []string{"targetFoo"}, + }, + }, + UpdateOld: []*endpoint.Endpoint{}, + }) + require.NoError(t, err) - mockSafeDNSService.AssertExpectations(t) + mockSafeDNSService.AssertExpectations(t) }