public async Task Two_Records_Are_Successfully_Created()
{
DNSRecordCollection dnsRecords = new DNSRecordCollection(new[]
{
new DNSRecord
{
Data = "100.100.100.100",
TTL = 1800,
Type = DNSRecordType.A
},
new DNSRecord
{
Data = "100.100.100.101",
TTL = 1800,
Type = DNSRecordType.A
},
});
IDigitalOceanClient client = A.Fake <IDigitalOceanClient>();
IDigitalOceanDNSRecordCreator creater = new DigitalOceanDNSRecordCreator(client, _mappingHelper.Mapper);
Result result = await creater.CreateAsync(string.Empty, dnsRecords, string.Empty, CancellationToken.None);
A.CallTo(() => client.CreateDNSRecordAsync(A <string> .Ignored, A <DigitalOceanCreateDomainRecordRequest> .Ignored, A <string> .Ignored, A <CancellationToken> .Ignored)).MustHaveHappenedTwiceExactly();
Assert.True(result.IsSuccess);
}
public async Task ReturnsFailureWhenUpdateFails()
{
DNSRecordCollection dnsRecordCollection = DNSRecordCollection.Empty();
DigitalOceanDomain domain = new DigitalOceanDomain();
ExternalAddress externalAddress = new ExternalAddress();
IDNSRecordCollectionMutator dnsRecordMutator = A.Fake <IDNSRecordCollectionMutator>();
A.CallTo(() => dnsRecordMutator.Mutate(A <DNSRecordCollection> .Ignored, A <IDNSRecordCollectionMutation> .Ignored)).Returns(dnsRecordCollection);
IDigitalOceanDNSRecordCreator dnsRecordCreator = A.Fake <IDigitalOceanDNSRecordCreator>();
A.CallTo(() => dnsRecordCreator.CreateAsync(A <string> .Ignored, A <DNSRecordCollection> .Ignored, A <string> .Ignored, A <CancellationToken> .Ignored)).Returns(Result.Ok());
IDigitalOceanDNSRecordReader dnsRecordReader = A.Fake <IDigitalOceanDNSRecordReader>();
A.CallTo(() => dnsRecordReader.ReadAsync(A <DigitalOceanDomain> .Ignored, A <string> .Ignored, A <CancellationToken> .Ignored)).Returns(Result.Ok(dnsRecordCollection));
IDigitalOceanDNSRecordUpdater dnsRecordUpdater = A.Fake <IDigitalOceanDNSRecordUpdater>();
A.CallTo(() => dnsRecordUpdater.UpdateAsync(A <string> .Ignored, A <DNSRecordCollection> .Ignored, A <string> .Ignored, A <CancellationToken> .Ignored)).Returns(Result.Fail("Error."));
IDigitalOceanDomainProcessor processor = new DigitalOceanDomainProcessor(dnsRecordMutator, dnsRecordCreator, dnsRecordReader, dnsRecordUpdater);
Result result = await processor.ProcessAsync(domain, externalAddress, string.Empty, new CancellationToken());
Assert.True(result.IsFailed);
}
public void UpdatedRecords()
{
DNSRecord record1 = new DNSRecord {
Data = "192.168.10.1", Name = "record1", Type = DNSRecordType.A
};
DNSRecord record2 = new DNSRecord {
Data = "192.168.10.2", Name = "record2", Type = DNSRecordType.A
};
DNSRecord record3 = new DNSRecord {
Data = "192.168.10.3", Name = "record1", Type = DNSRecordType.A
};
DNSRecord record4 = new DNSRecord {
Data = "192.168.10.2", Name = "record2", Type = DNSRecordType.A
};
DNSRecord record5 = new DNSRecord {
Data = "192.168.10.5", Name = "record5", Type = DNSRecordType.A
};
DNSRecord record6 = new DNSRecord {
Data = "192.168.10.6", Name = "record6", Type = DNSRecordType.A
};
DNSRecordCollection compareWith = new DNSRecordCollection(record1, record2, record5);
DNSRecordCollection compareTo = new DNSRecordCollection(record3, record4, record6);
DNSRecordCollection updateRecords = compareWith.WhereUpdated(compareTo);
Assert.Contains(record3, updateRecords, DNSRecordEqualityComparer.Instance);
Assert.DoesNotContain(record1, updateRecords, DNSRecordEqualityComparer.Instance);
Assert.DoesNotContain(record2, updateRecords, DNSRecordEqualityComparer.Instance);
Assert.DoesNotContain(record4, updateRecords, DNSRecordEqualityComparer.Instance);
Assert.DoesNotContain(record5, updateRecords, DNSRecordEqualityComparer.Instance);
Assert.DoesNotContain(record6, updateRecords, DNSRecordEqualityComparer.Instance);
}
public DNSRecordCollection Mutate(DNSRecordCollection dnsRecords, params IDNSRecordCollectionMutation[] mutators)
{
DNSRecordCollection hydratedRecords = dnsRecords;
foreach (IDNSRecordCollectionMutation mutation in mutators)
{
hydratedRecords = mutation.Mutate(hydratedRecords);
}
return hydratedRecords;
}
public void Mutate_WhenRecordTypeMutation_ReturnsOnlyRecordType(DNSRecordType dnsRecordType)
{
DNSRecordCollection dnsRecords = GetDNSRecords();
IDNSRecordCollectionMutator mutator = new DNSRecordCollectionMutator();
DNSRecordCollection mudatedDnsRecords = mutator.Mutate(dnsRecords, new WithRecordType(dnsRecordType));
Assert.DoesNotContain(mudatedDnsRecords, d => d.Type != dnsRecordType);
}
public void Mutate_WhenZeroMutations_HasNoChange()
{
DNSRecordCollection dnsRecords = GetDNSRecords();
IDNSRecordCollectionMutator mutator = new DNSRecordCollectionMutator();
DNSRecordCollection mutatedDnsRecords = mutator.Mutate(dnsRecords);
Assert.Equal(dnsRecords, mutatedDnsRecords, DNSRecordEqualityComparer.Instance);
}
public void Mutate_WhenUpdatedIds_ReturnsWithUpdatedIds()
{
DNSRecordCollection dnsRecords = GetDNSRecords();
DNSRecordCollection dnsRecordsWithIds = GetDNSRecordsWithIds();
IDNSRecordCollectionMutator mutator = new DNSRecordCollectionMutator();
DNSRecordCollection mudatedDnsRecords = mutator.Mutate(dnsRecords, new WithUpdatedIds(dnsRecordsWithIds));
Assert.False(mudatedDnsRecords.All(d => string.IsNullOrEmpty(d.Id)));
}
public void Mutate_WhenUpdatedData_ReturnsWithUpdatedData()
{
string updatedData = "updated-data";
DNSRecordCollection dnsRecords = GetDNSRecords();
IDNSRecordCollectionMutator mutator = new DNSRecordCollectionMutator();
DNSRecordCollection mudatedDnsRecords = mutator.Mutate(dnsRecords, new WithUpdatedData(updatedData));
Assert.True(mudatedDnsRecords.All(d => string.Equals(d.Data, updatedData)));
}
public async Task <Result> CreateAsync(string domainName, DNSRecordCollection records, GoDaddyAuthenticationDetails authentication, CancellationToken cancellation)
{
if (records.Any())
{
IEnumerable <GoDaddyCreateDNSRecordRequest> recordRequests = _mapper.Map <IEnumerable <GoDaddyCreateDNSRecordRequest> >(records);
GoDaddyCreateDNSRecordsRequest request = new GoDaddyCreateDNSRecordsRequest(authentication.ApiKey, authentication.ApiSecret, recordRequests, domainName);
return(await _client.CreateDNSRecordsAsync(request, cancellation));
}
return(Result.Ok());
}
public async Task <Result> CreateAsync(string domainName, DNSRecordCollection dnsRecords, string token, CancellationToken cancellation)
{
Result result = Result.Ok();
IEnumerable <DigitalOceanCreateDomainRecordRequest> requests = _mapper.Map <IEnumerable <DigitalOceanCreateDomainRecordRequest> >(dnsRecords);
foreach (DigitalOceanCreateDomainRecordRequest request in requests)
{
Result createResult = await _digitalOceanClient.CreateDNSRecordAsync(domainName, request, token, cancellation);
result = result.Merge(createResult);
}
return(result);
}
public async Task <Result> UpdateAsync(string domainName, DNSRecordCollection records, GoDaddyAuthenticationDetails authentication, CancellationToken cancellation)
{
Result result = Result.Ok();
foreach (DNSRecord record in records)
{
GoDaddyUpdateDNSRecord mappedRecord = _mapper.Map <GoDaddyUpdateDNSRecord>(record);
GoDaddyUpdateDNSRecordsRequest request = new GoDaddyUpdateDNSRecordsRequest(authentication.ApiKey, authentication.ApiSecret, domainName, record.Type, record.Name, mappedRecord);
Result updateResult = await _client.UpdateDNSRecordAsync(request, cancellation);
result = result.Merge(updateResult);
}
return(result);
}
public async Task Returns_Success_When_All_Records_Update()
{
IGoDaddyClient client = A.Fake <IGoDaddyClient>();
A.CallTo(() => client.UpdateDNSRecordAsync(A <GoDaddyUpdateDNSRecordsRequest> .Ignored, A <CancellationToken> .Ignored)).Returns(Result.Ok());
GoDaddyDNSRecordUpdater updater = new GoDaddyDNSRecordUpdater(client, _mapper);
DNSRecordCollection records = new DNSRecordCollection(CreateValidDNSRecord(1), CreateValidDNSRecord(2));
GoDaddyAuthenticationDetails authicationDetails = new GoDaddyAuthenticationDetails("apiKey", "apiSecret");
Result result = await updater.UpdateAsync("aDomain.com", records, authicationDetails, CancellationToken.None);
Assert.True(result.IsSuccess);
}
public async Task No_Records_Are_Successfully_Created_If_Client_Fails()
{
IGoDaddyClient client = A.Fake <IGoDaddyClient>();
A.CallTo(() => client.UpdateDNSRecordAsync(A <GoDaddyUpdateDNSRecordsRequest> .Ignored, A <CancellationToken> .Ignored)).Returns(Result.Fail("Error"));
GoDaddyDNSRecordUpdater updater = new GoDaddyDNSRecordUpdater(client, _mapper);
DNSRecordCollection records = new DNSRecordCollection(CreateValidDNSRecord(1), CreateValidDNSRecord(2));
GoDaddyAuthenticationDetails authicationDetails = new GoDaddyAuthenticationDetails("apiKey", "apiSecret");
Result result = await updater.UpdateAsync("aDomain.com", records, authicationDetails, CancellationToken.None);
Assert.True(result.IsFailed);
Assert.Equal(2, result.Errors.Count);
}
public async Task Record_Is_Successfully_Retrieved()
{
string ipAddress = "100.100.100.100";
string name = "test";
int TTL = 1800;
DNSRecordType type = DNSRecordType.A;
DigitalOceanDomain domain = new DigitalOceanDomain();
DigitalOceanGetDomainRecordsResponse clientResponse = new DigitalOceanGetDomainRecordsResponse
{
DomainRecords = new List <DigitalOceanGetDomainRecordResponse>
{
new DigitalOceanGetDomainRecordResponse
{
Data = ipAddress,
Name = name,
Ttl = TTL,
Type = type
}
}
};
Result <DigitalOceanGetDomainRecordsResponse> clientResponeResult = Result.Ok(clientResponse);
IDigitalOceanClient client = A.Fake <IDigitalOceanClient>();
IDigitalOceanDNSRecordReader reader = new DigitalOceanDNSRecordReader(client, _mappingHelper.Mapper);
A.CallTo(() => client.GetDNSRecordsAsync(A <DigitalOceanDomain> .Ignored, A <string> .Ignored, A <CancellationToken> .Ignored)).Returns(clientResponeResult);
Result <DNSRecordCollection> result = await reader.ReadAsync(domain, string.Empty, CancellationToken.None);
Assert.True(result.IsSuccess);
DNSRecordCollection dnsRecords = result.Value;
Assert.True(dnsRecords.Count == 1);
DNSRecord dnsRecord = result.Value.First();
Assert.Equal(dnsRecord.Data, ipAddress);
Assert.Equal(dnsRecord.Name, name);
Assert.Equal(dnsRecord.TTL, TTL);
Assert.Equal(dnsRecord.Type, type);
}
public void NewRecords()
{
DNSRecord record1 = new DNSRecord {
Data = "192.168.10.1", Name = "record1", Type = DNSRecordType.A
};
DNSRecord record2 = new DNSRecord {
Data = "192.168.10.2", Name = "record2", Type = DNSRecordType.A
};
DNSRecord record3 = new DNSRecord {
Data = "192.168.10.1", Name = "record1", Type = DNSRecordType.A
};
DNSRecord record4 = new DNSRecord {
Data = "192.168.10.2", Name = "record2", Type = DNSRecordType.A
};
DNSRecord record5 = new DNSRecord {
Data = "192.168.10.5", Name = "record5", Type = DNSRecordType.A
};
DNSRecord record6 = new DNSRecord {
Data = "192.168.10.6", Name = "record6", Type = DNSRecordType.A
};
DNSRecordCollection compareWith = new DNSRecordCollection(new[]
{
record1, record2
});
DNSRecordCollection compareTo = new DNSRecordCollection(new[]
{
record3, record4, record5, record6
});
DNSRecordCollection newRecords = compareWith.WhereNew(compareTo);
Assert.Contains(record5, newRecords, DNSRecordEqualityComparer.Instance);
Assert.Contains(record6, newRecords, DNSRecordEqualityComparer.Instance);
Assert.DoesNotContain(record1, newRecords, DNSRecordEqualityComparer.Instance);
Assert.DoesNotContain(record2, newRecords, DNSRecordEqualityComparer.Instance);
Assert.DoesNotContain(record3, newRecords, DNSRecordEqualityComparer.Instance);
Assert.DoesNotContain(record4, newRecords, DNSRecordEqualityComparer.Instance);
}
public async Task <Result> ProcessAsync(DigitalOceanDomain domain, ExternalAddress externalAddress, string token, CancellationToken cancellation)
{
Result <DNSRecordCollection> activeDnsRecordsResult = await _dnsRecordReader.ReadAsync(domain, token, cancellation);
if (activeDnsRecordsResult.IsFailed)
{
return(activeDnsRecordsResult);
}
IDNSRecordCollectionMutation[] mutations = GetMutations(externalAddress, activeDnsRecordsResult.Value);
DNSRecordCollection configurationRecords = new DNSRecordCollection(domain.Records);
DNSRecordCollection hydratedDnsRecords = _dnsRecordMutator.Mutate(configurationRecords, mutations);
DNSRecordCollection newRecords = activeDnsRecordsResult.Value.WhereNew(hydratedDnsRecords);
DNSRecordCollection updatedRecords = activeDnsRecordsResult.Value.WhereUpdated(hydratedDnsRecords);
Result create = await _dnsRecordCreator.CreateAsync(domain.Name, newRecords, token, cancellation);
Result update = await _dnsRecordUpdater.UpdateAsync(domain.Name, updatedRecords, token, cancellation);
return(activeDnsRecordsResult.Merge(create, update));
}
public async Task No_Records_Are_Successfully_Created_Returns_Failure()
{
IGoDaddyClient fakeClient = A.Fake <IGoDaddyClient>();
A.CallTo(() => fakeClient.CreateDNSRecordsAsync(A <GoDaddyCreateDNSRecordsRequest> .Ignored, A <CancellationToken> .Ignored)).Returns(Result.Fail("oops"));
GoDaddyDNSRecordCreator creator = new GoDaddyDNSRecordCreator(fakeClient, _mapper);
DNSRecordCollection dnsRecords = new DNSRecordCollection(
new DNSRecord
{
Type = DNSRecordType.A
},
new DNSRecord
{
Type = DNSRecordType.A
});
GoDaddyAuthenticationDetails authicationDetails = new GoDaddyAuthenticationDetails(string.Empty, string.Empty);
Result result = await creator.CreateAsync(string.Empty, dnsRecords, authicationDetails, CancellationToken.None);
Assert.True(result.IsFailed);
}
public async Task Records_Are_Created_And_Successful_Result_Returned()
{
IGoDaddyClient fakeClient = A.Fake <IGoDaddyClient>();
A.CallTo(() => fakeClient.CreateDNSRecordsAsync(A <GoDaddyCreateDNSRecordsRequest> .Ignored, A <CancellationToken> .Ignored)).Returns(Result.Ok());
GoDaddyDNSRecordCreator creator = new GoDaddyDNSRecordCreator(fakeClient, _mapper);
DNSRecordCollection dnsRecords = new DNSRecordCollection(
new DNSRecord
{
Type = DNSRecordType.A
},
new DNSRecord
{
Type = DNSRecordType.A
});
GoDaddyAuthenticationDetails authicationDetails = new GoDaddyAuthenticationDetails(string.Empty, string.Empty);
Result result = await creator.CreateAsync(string.Empty, dnsRecords, authicationDetails, CancellationToken.None);
Assert.True(result.IsSuccess);
A.CallTo(() => fakeClient.CreateDNSRecordsAsync(A <GoDaddyCreateDNSRecordsRequest> .Ignored, A <CancellationToken> .Ignored)).MustHaveHappenedOnceExactly();
}
public async Task ProcessAsync_ReadFails_ReturnsFailureResult()
{
IGoDaddyDNSRecordCreator dnsCreator = A.Fake <IGoDaddyDNSRecordCreator>();
A.CallTo(() => dnsCreator.CreateAsync(A <string> .Ignored, A <DNSRecordCollection> .Ignored, A <GoDaddyAuthenticationDetails> .Ignored, A <CancellationToken> .Ignored))
.Returns(Result.Ok());
IDNSRecordCollectionMutator mutator = A.Fake <IDNSRecordCollectionMutator>();
A.CallTo(() => mutator.Mutate(A <DNSRecordCollection> .Ignored, A <IDNSRecordCollectionMutation> .Ignored))
.Returns(DNSRecordCollection.Empty());
IGoDaddyDNSRecordReader dnsReader = A.Fake <IGoDaddyDNSRecordReader>();
A.CallTo(() => dnsReader.ReadAsync(A <string> .Ignored, A <GoDaddyAuthenticationDetails> .Ignored, A <CancellationToken> .Ignored))
.Returns(Result.Fail("Reader Failure"));
IGoDaddyDNSRecordUpdater dnsUpdater = A.Fake <IGoDaddyDNSRecordUpdater>();
A.CallTo(() => dnsUpdater.UpdateAsync(A <string> .Ignored, A <DNSRecordCollection> .Ignored, A <GoDaddyAuthenticationDetails> .Ignored, A <CancellationToken> .Ignored))
.Returns(Result.Ok());
IGoDaddyDomainProcessor domainProcessor = new GoDaddyDomainProcessor(dnsCreator, mutator, dnsReader, dnsUpdater);
GoDaddyDomain domain = new GoDaddyDomain()
{
Name = "GoDaddy Domain"
};
ExternalAddress externalAddress = A.Fake <ExternalAddress>();
GoDaddyAuthenticationDetails authenticationDetails = A.Fake <GoDaddyAuthenticationDetails>();
Result result = await domainProcessor.ProcessAsync(domain, externalAddress, authenticationDetails, new CancellationToken());
Assert.False(result.IsSuccess);
Assert.True(result.IsFailed);
}
private IDNSRecordCollectionMutation[] GetMutations(ExternalAddress externalAddress, DNSRecordCollection idsFrom)
{
return(new IDNSRecordCollectionMutation[]
{
new WithRecordType(DNSRecordType.A),
new WithUpdatedData(externalAddress.ToIPv4String() !),
new WithUpdatedIds(idsFrom)
});
public DNSRecordCollection Mutate(DNSRecordCollection dnsRecords)
{
return(dnsRecords.WithUpdatedDataFrom(_data));
}
public DNSRecordCollection Mutate(DNSRecordCollection dnsRecords)
{
return(dnsRecords.WithUpdatedIdsFrom(_idsFrom));
}
public WithUpdatedIds(DNSRecordCollection idsFrom)
{
_idsFrom = idsFrom;
}
public DNSRecordCollection Mutate(DNSRecordCollection dnsRecords)
{
return(dnsRecords.WithRecordType(_dnsRecordType));
}
