public void UpdateZoneRecord(long accountId, string zoneId,
long recordId, string expectedUrl)
{
var client = new MockDnsimpleClient(UpdateZoneRecordFixture);
var data = new ZoneRecord
{
Name = "",
Content = "mxb.example.com",
Ttl = 3600,
Priority = 20
};
var record =
client.Zones.UpdateRecord(accountId, zoneId, recordId, data)
.Data;
Assert.Multiple(() =>
{
Assert.AreEqual(recordId, record.Id);
Assert.AreEqual(zoneId, record.ZoneId);
Assert.IsNull(record.ParentId);
Assert.IsEmpty(record.Name);
Assert.AreEqual("mxb.example.com", record.Content);
Assert.AreEqual(3600, record.Ttl);
Assert.AreEqual(20, record.Priority);
Assert.AreEqual(ZoneRecordType.MX, record.Type);
Assert.Contains("global", record.Regions);
Assert.IsFalse(record.SystemRecord);
Assert.AreEqual(expectedUrl, client.RequestSentTo());
Assert.AreEqual(Method.PATCH, client.HttpMethodUsed());
});
}
public void CreateContact(long accountId, string expectedUrl)
{
var client = new MockDnsimpleClient(CreateContactFixture);
var contact = new Contact
{
FirstName = "First",
LastName = "User",
Address1 = "Italian Street, 10",
City = "Roma",
StateProvince = "RM",
PostalCode = "00100",
Country = "IT",
Email = "*****@*****.**",
Phone = "+18001234567",
Fax = "+18011234567"
};
var created =
client.Contacts.CreateContact(accountId, contact).Data;
Assert.Multiple(() =>
{
Assert.AreEqual(1, created.Id);
Assert.AreEqual(contact.Email, created.Email);
Assert.AreEqual(expectedUrl, client.RequestSentTo());
Assert.AreEqual(Method.POST, client.HttpMethodUsed());
});
}
public void CreateZoneRecord(string fixture, long accountId,
string name, string expectedUrl)
{
var client = new MockDnsimpleClient(fixture);
var record = new ZoneRecord
{
Name = name,
Type = ZoneRecordType.A,
Content = "127.0.0.1",
Ttl = 600,
};
var created = client.Zones
.CreateRecord(accountId, "example.com", record)
.Data;
Assert.Multiple(() =>
{
Assert.AreEqual(1, created.Id);
Assert.AreEqual("example.com", created.ZoneId);
Assert.AreEqual(name, created.Name);
Assert.AreEqual("127.0.0.1", created.Content);
Assert.AreEqual(600, created.Ttl);
Assert.AreEqual(ZoneRecordType.A, created.Type);
Assert.Contains("global", created.Regions);
Assert.AreEqual(Method.POST, client.HttpMethodUsed());
Assert.AreEqual(expectedUrl, client.RequestSentTo());
});
}
public void GetZoneRecord(long accountId, string zoneId, long recordId,
string expectedUrl)
{
var client = new MockDnsimpleClient(GetZoneRecordFixture);
var record = client.Zones.GetRecord(accountId, zoneId, recordId)
.Data;
Assert.Multiple(() =>
{
Assert.AreEqual(recordId, record.Id);
Assert.AreEqual(zoneId, record.ZoneId);
Assert.IsNull(record.ParentId);
Assert.IsEmpty(record.Name);
Assert.AreEqual("mxa.example.com", record.Content);
Assert.AreEqual(600, record.Ttl);
Assert.AreEqual(10, record.Priority);
Assert.AreEqual(ZoneRecordType.MX, record.Type);
Assert.Contains("SV1", record.Regions);
Assert.Contains("IAD", record.Regions);
Assert.IsFalse(record.SystemRecord);
Assert.AreEqual(Method.GET, client.HttpMethodUsed());
Assert.AreEqual(expectedUrl, client.RequestSentTo());
});
}
public void CreateTemplate(long accountId, string expectedUrl)
{
var client = new MockDnsimpleClient(CreateTemplateFixture);
var templateData = new Template
{
Name = "Beta",
Sid = "beta",
Description = "A beta template."
};
var template =
client.Templates.CreateTemplate(accountId, templateData).Data;
Assert.Multiple(() =>
{
Assert.AreEqual(1, template.Id);
Assert.AreEqual(accountId, template.AccountId);
Assert.AreEqual(templateData.Name, template.Name);
Assert.AreEqual(templateData.Sid, template.Sid);
Assert.AreEqual(templateData.Description, template.Description);
Assert.AreEqual(Method.POST, client.HttpMethodUsed());
Assert.AreEqual(expectedUrl, client.RequestSentTo());
});
}
public void PurchaseLetsEncryptCertificateRenewal(long accountId,
string domainName, long certificateId, string expectedUrl)
{
var client =
new MockDnsimpleClient(
PurchaseRenewalLetsEncryptCertificateFixture);
var certificateAttributes = new LetsencryptCertificateAttributes
{
AutoRenew = false
};
var renewalPurchased =
client.Certificates.PurchaseLetsEncryptCertificateRenewal(
accountId, domainName, certificateId, certificateAttributes).Data;
Assert.Multiple(() =>
{
Assert.AreEqual(65082, renewalPurchased.Id);
Assert.AreEqual(101967, renewalPurchased.OldCertificateId);
Assert.AreEqual(101972, renewalPurchased.NewCertificateId);
Assert.AreEqual("new", renewalPurchased.State);
Assert.IsFalse(renewalPurchased.AutoRenew);
Assert.AreEqual(Convert.ToDateTime("2020-06-18T19:56:20Z"), renewalPurchased.CreatedAt);
Assert.AreEqual(Convert.ToDateTime("2020-06-18T19:56:20Z"), renewalPurchased.UpdatedAt);
Assert.AreEqual(Method.POST, client.HttpMethodUsed());
Assert.AreEqual(expectedUrl, client.RequestSentTo());
});
}
public void IssueLetsEncryptCertificate(long accountId,
string domainName, long certificateId, string expectedUrl)
{
var client =
new MockDnsimpleClient(IssueLetsEncryptCertificateFixture);
var certificate = client.Certificates
.IssueLetsEncryptCertificate(accountId, domainName,
certificateId).Data;
Assert.Multiple(() =>
{
Assert.AreEqual(101967, certificate.Id);
Assert.AreEqual(289333, certificate.DomainId);
Assert.AreEqual(2511, certificate.ContactId);
Assert.AreEqual("www.bingo.pizza", certificate.CommonName);
Assert.AreEqual(1, certificate.Years);
Assert.IsNull(certificate.Csr);
Assert.AreEqual("requesting", certificate.State);
Assert.IsFalse(certificate.AutoRenew);
CollectionAssert.IsEmpty(certificate.AlternateNames);
Assert.AreEqual("letsencrypt", certificate.AuthorityIdentifier);
Assert.AreEqual(Method.POST, client.HttpMethodUsed());
Assert.AreEqual(expectedUrl, client.RequestSentTo());
});
}
public void DoesNotCreateIfRequiredFieldsAreMissing(string firstName,
string lastName, string email, string phone, string fax,
string address1, string city, string stateProvince,
string postalCode, string country)
{
var client = new MockDnsimpleClient(CreateContactFixture);
var contact = new Contact
{
FirstName = firstName,
LastName = lastName,
Address1 = address1,
City = city,
StateProvince = stateProvince,
PostalCode = postalCode,
Country = country,
Email = email,
Phone = phone,
Fax = fax
};
Assert.Throws <Newtonsoft.Json.JsonSerializationException>(delegate
{
client.Contacts.CreateContact(1010, contact);
});
}
public void TransferDomainErrorInDnsimple(long accountId,
string domainName)
{
var client =
new MockDnsimpleClient(TransferDomainErrorInDnsimpleFixture);
client.StatusCode(HttpStatusCode.BadRequest);
var transfer = new DomainTransferInput
{
RegistrantId = 2,
AuthCode = "gimmegoogle"
};
Assert.Throws(Is.TypeOf <DnsimpleValidationException>()
.And
.Message
.EqualTo(
"The domain google.com is already in DNSimple and cannot be added"),
delegate
{
client.Registrar.TransferDomain(accountId, domainName,
transfer);
});
}
public void IssueLetsEncryptCertificateRenewal(long accountId, string domainName, long certificateId, long certificateRenewalId, string expectedUrl)
{
var client = new MockDnsimpleClient(IssueRenewalLetsEncryptCertificateFixture);
var renewalIssued =
client.Certificates.IssueLetsEncryptCertificateRenewal(
accountId, domainName, certificateId, certificateRenewalId).Data;
Assert.Multiple(() =>
{
Assert.AreEqual(300, renewalIssued.Id);
Assert.AreEqual(300, renewalIssued.DomainId);
Assert.AreEqual(100, renewalIssued.ContactId);
Assert.AreEqual("www", renewalIssued.Name);
Assert.AreEqual("www.example.com", renewalIssued.CommonName);
Assert.AreEqual(1, renewalIssued.Years);
Assert.IsNull(renewalIssued.Csr);
Assert.AreEqual("requesting", renewalIssued.State);
Assert.IsFalse(renewalIssued.AutoRenew);
CollectionAssert.IsEmpty(renewalIssued.AlternateNames);
Assert.AreEqual("letsencrypt", renewalIssued.AuthorityIdentifier);
Assert.AreEqual(Method.POST, client.HttpMethodUsed());
Assert.AreEqual(expectedUrl, client.RequestSentTo());
});
}
public void ListCertificatesWithOptions(long accountId,
string domainName, string expectedUrl)
{
var client = new MockDnsimpleClient(ListCertificatesFixture);
var options = new CertificatesListOptions
{
Pagination = new Pagination
{
PerPage = 42,
Page = 7
}
}.SortById(Order.asc)
.SortByCommonName(Order.desc)
.SortByExpiresOn(Order.asc);
var response =
client.Certificates.ListCertificates(accountId, domainName,
options);
Assert.Multiple(() =>
{
Assert.AreEqual(2, response.Data.Count);
Assert.AreEqual(1, response.PaginationData.CurrentPage);
Assert.AreEqual(expectedUrl, client.RequestSentTo());
});
}
public void ListZonesWithOptions(long accountId, string expectedUrl)
{
var client = new MockDnsimpleClient(ListZonesFixture);
var options = new ZonesListOptions
{
Pagination = new Pagination
{
PerPage = 42,
Page = 7
}
}.FilterByName("example.com")
.SortById(Order.asc)
.SortByName(Order.desc);
var response = client.Zones.ListZones(accountId, options);
Assert.Multiple(() =>
{
Assert.AreEqual(2, response.Data.Count);
Assert.AreEqual(1, response.PaginationData.CurrentPage);
Assert.AreEqual(expectedUrl, client.RequestSentTo());
});
}
public void ChangeDomainDelegationToVanity(long accountId, string domain, string expectedUrl)
{
var client = new MockDnsimpleClient(ChangeDomainDelegationToVanityFixture);
var delegation = new List <string>
{
"ns1.dnsimple.com", "ns2.dnsimple.com"
};
var vanityDelegation =
client.Registrar.ChangeDomainDelegationToVanity(accountId,
domain, delegation).Data.Delegations;
Assert.Multiple(() =>
{
Assert.AreEqual(2, vanityDelegation.Count);
Assert.AreEqual(1, vanityDelegation.First().Id);
Assert.AreEqual("ns1.example.com", vanityDelegation.First().Name);
Assert.AreEqual("127.0.0.1", vanityDelegation.First().Ipv4);
Assert.AreEqual("::1", vanityDelegation.First().Ipv6);
Assert.AreEqual(CreatedAt, vanityDelegation.First().CreatedAt);
Assert.AreEqual(UpdatedAt, vanityDelegation.First().UpdatedAt);
Assert.AreEqual(expectedUrl, client.RequestSentTo());
Assert.AreEqual(Method.PUT, client.HttpMethodUsed());
});
}
public void PurchaseLetsEncryptCertificate(long accountId,
string domainName, string expectedUrl)
{
var client =
new MockDnsimpleClient(PurchaseLetsEncryptCertificateFixture);
var certificateAttributes = new LetsencryptCertificateAttributes
{
ContactId = 11,
AutoRenew = false,
Name = "SuperCertificate",
AlternateNames = new List <string> {
"docs.bingo.pizza", "status.bingo.pizza"
}
};
var certificateOrdered =
client.Certificates.PurchaseLetsEncryptCertificate(accountId,
domainName, certificateAttributes).Data;
Assert.Multiple(() =>
{
Assert.AreEqual(101967, certificateOrdered.Id);
Assert.AreEqual(101967, certificateOrdered.CertificateId);
Assert.AreEqual("new", certificateOrdered.State);
Assert.IsFalse(certificateOrdered.AutoRenew);
Assert.AreEqual(Convert.ToDateTime("2020-06-18T18:54:17Z"), certificateOrdered.CreatedAt);
Assert.AreEqual(Convert.ToDateTime("2020-06-18T18:54:17Z"), certificateOrdered.UpdatedAt);
Assert.AreEqual(Method.POST, client.HttpMethodUsed());
Assert.AreEqual(expectedUrl, client.RequestSentTo());
});
}
public void PurchaseLetsEncryptCertificate(long accountId,
string domainName, string expectedUrl)
{
var client =
new MockDnsimpleClient(PurchaseLetsEncryptCertificateFixture);
var certificatePurchase = new CertificateOrder
{
ContactId = 11,
AutoRenew = false,
Name = "SuperCertificate",
AlternateNames = new List <string>
{
"docs.rubycodes.com", "status.rubycodes.com"
}
};
var certificateOrdered =
client.Certificates.PurchaseLetsEncryptCertificate(accountId,
domainName, certificatePurchase).Data;
Assert.Multiple(() =>
{
Assert.AreEqual(300, certificateOrdered.Id);
Assert.AreEqual(300, certificateOrdered.CertificateId);
Assert.AreEqual("requesting", certificateOrdered.State);
Assert.IsFalse(certificateOrdered.AutoRenew);
Assert.AreEqual(LetsEncryptCreatedAt,
certificateOrdered.CreatedAt);
Assert.AreEqual(LetsEncryptUpdatedAt,
certificateOrdered.UpdatedAt);
Assert.AreEqual(Method.POST, client.HttpMethodUsed());
Assert.AreEqual(expectedUrl, client.RequestSentTo());
});
}
public void FailToCreateDelegationSignerRecord(long accountId, string domainIdentifier)
{
var client = new MockDnsimpleClient(FailToCreateRecordsFixture);
client.StatusCode(HttpStatusCode.BadRequest);
try
{
client.Domains.CreateDelegationSignerRecord(accountId,
domainIdentifier, _record);
}
catch (DnSimpleValidationException exception)
{
Assert.Multiple(() =>
{
Assert.AreEqual("can't be blank",
exception.Validation["algorithm"]?.First?.ToString());
Assert.AreEqual("can't be blank",
exception.Validation["digest"]?.First?.ToString());
Assert.AreEqual("can't be blank",
exception.Validation["digest_type"]?.First?.ToString());
Assert.AreEqual("can't be blank",
exception.Validation["keytag"]?.First?.ToString());
});
}
}
public void RegisterDomain(long accountId, string domainName,
string expectedUrl)
{
var client = new MockDnsimpleClient(RegisterDomainFixture);
var domain = new DomainRegistrationInput
{
RegistrantId = 2,
WhoisPrivacy = false,
AutoRenew = false,
PremiumPrice = ""
};
var registeredDomain =
client.Registrar.RegisterDomain(accountId, domainName, domain)
.Data;
Assert.Multiple(() =>
{
Assert.AreEqual(1, registeredDomain.Id);
Assert.AreEqual(999, registeredDomain.DomainId);
Assert.AreEqual(2, registeredDomain.RegistrantId);
Assert.AreEqual(1, registeredDomain.Period);
Assert.AreEqual("new", registeredDomain.State);
Assert.IsFalse(registeredDomain.AutoRenew);
Assert.IsFalse(registeredDomain.WhoisPrivacy);
Assert.AreEqual(CreatedAt, registeredDomain.CreatedAt);
Assert.AreEqual(UpdatedAt, registeredDomain.UpdatedAt);
Assert.AreEqual(expectedUrl, client.RequestSentTo());
});
}
public void GetDomainPremiumPriceFailure(long accountId,
string domainName, PremiumPriceCheckAction action,
string expectedUrl)
{
var client =
new MockDnsimpleClient(GetDomainPremiumPriceFailureFixture);
client.StatusCode(HttpStatusCode.BadRequest);
Assert.Multiple(() =>
{
Assert.Throws(
Is.TypeOf <DnsimpleValidationException>().And.Message
.EqualTo(
"`example.com` is not a premium domain for registration"),
delegate
{
client.Registrar
.GetDomainPremiumPrice(accountId, domainName,
action);
});
Assert.AreEqual(expectedUrl, client.RequestSentTo());
});
}
public void PurchaseLetsEncryptCertificateRenewal(long accountId,
string domainName, long certificateId, string expectedUrl)
{
var client = new MockDnsimpleClient(PurchaseRenewalLetsEncryptCertificateFixture);
var renewal = new LetsEncryptRenewal
{
AutoRenew = false
};
var renewalPurchased =
client.Certificates.PurchaseLetsEncryptCertificateRenewal(
accountId, domainName, certificateId, renewal).Data;
Assert.Multiple(() =>
{
Assert.AreEqual(999, renewalPurchased.Id);
Assert.AreEqual(200, renewalPurchased.OldCertificateId);
Assert.AreEqual(300, renewalPurchased.NewCertificateId);
Assert.AreEqual("new", renewalPurchased.State);
Assert.IsFalse(renewalPurchased.AutoRenew);
Assert.AreEqual(LetsEncryptRenewalCreatedAt, renewalPurchased.CreatedAt);
Assert.AreEqual(LetsEncryptRenewalUpdatedAt, renewalPurchased.UpdatedAt);
Assert.AreEqual(Method.POST, client.HttpMethodUsed());
Assert.AreEqual(expectedUrl, client.RequestSentTo());
});
}
public void CreateTemplateRecord(long accountId, string template, string expectedUrl)
{
var client = new MockDnsimpleClient(CreateTemplateRecordFixture);
var templateRecord = new TemplateRecord
{
Name = "",
Type = "MX",
Content = "mx.example.com",
Ttl = 600,
Priority = 10
};
var record =
client.Templates.CreateTemplateRecord(accountId, template,
templateRecord).Data;
Assert.Multiple(() =>
{
Assert.AreEqual(300, record.Id);
Assert.AreEqual(268, record.TemplateId);
Assert.AreEqual(templateRecord.Name, record.Name);
Assert.AreEqual(templateRecord.Type, record.Type);
Assert.AreEqual(templateRecord.Content, record.Content);
Assert.AreEqual(templateRecord.Ttl, record.Ttl);
Assert.AreEqual(templateRecord.Priority, record.Priority);
Assert.AreEqual(Method.POST, client.HttpMethodUsed());
Assert.AreEqual(expectedUrl, client.RequestSentTo());
});
}
public void GetService(string serviceId, string expectedUrl)
{
var client = new MockDnsimpleClient(GetServiceFixture);
var service = client.Services.GetService(serviceId).Data;
var setting = service.Settings.First();
Assert.Multiple(() =>
{
Assert.AreEqual(1, service.Id);
Assert.AreEqual("Service 1", service.Name);
Assert.AreEqual("service1", service.Sid);
Assert.AreEqual("First service example.", service.Description);
Assert.IsNull(service.SetupDescription);
Assert.IsTrue(service.RequiresSetup);
Assert.IsNull(service.DefaultSubdomain);
Assert.AreEqual(CreatedAt, service.CreatedAt);
Assert.AreEqual(UpdatedAt, service.UpdatedAt);
Assert.AreEqual("username", setting.Name);
Assert.AreEqual("Service 1 Account Username", setting.Label);
Assert.AreEqual(".service1.com", setting.Append);
Assert.AreEqual("Your Service 1 username is used to connect services to your account.", setting.Description);
Assert.AreEqual("username", setting.Example);
Assert.IsFalse(setting.Password);
});
}
public void CheckZoneDistributionFailure(long accountId,
string zoneName)
{
var client =
new MockDnsimpleClient(CheckZoneDistributionFailureFixture);
var zone =
client.Zones.CheckZoneDistribution(accountId, zoneName);
Assert.IsFalse(zone.Data.Distributed);
}
public void InitiatePushValidationFail(string email)
{
var client = new MockDnsimpleClient(InitiatePushFixture);
Assert.Throws(Is.TypeOf <ArgumentException>().And.Message.EqualTo("Email cannot be null or empty"),
delegate
{
client.Domains.InitiatePush(1010, "100", email);
});
}
public void GetZoneNotFound(long accountId, string zoneName)
{
var client = new MockDnsimpleClient(GetZoneNotFoundFixture);
client.StatusCode(HttpStatusCode.NotFound);
Assert.Throws <NotFoundException>(
delegate { client.Zones.GetZone(accountId, zoneName); },
"Zone `0` not found");
}
public void GetDomainNotFound(string domainIdentifier)
{
var client = new MockDnsimpleClient(GetDomainNotFoundFixture);
client.StatusCode(HttpStatusCode.NotFound);
Assert.Throws(
Is.TypeOf <NotFoundException>().And.Message
.EqualTo("Domain `0` not found"),
delegate { client.Domains.GetDomain(1010, domainIdentifier); });
}
public void ListDomainsWithOptions(string expectedUrl)
{
var client = new MockDnsimpleClient(ListDomainsFixture);
var listOptions = new DomainListOptions();
listOptions.FilterByName("example.com");
listOptions.SortById(Order.asc);
client.Domains.ListDomains(1010, listOptions);
Assert.AreEqual(expectedUrl, client.RequestSentTo());
}
public void ListWebhooks(long accountId, string expectedUrl)
{
var client = new MockDnsimpleClient(ListWebhooksFixture);
var webhooks = client.Webhooks.ListWebhooks(accountId).Data;
Assert.Multiple(() =>
{
Assert.AreEqual(2, webhooks.Count);
Assert.AreEqual(expectedUrl, client.RequestSentTo());
});
}
public void DisableDnssecNotEnabled(long accountId, string domainIdentifier)
{
var client = new MockDnsimpleClient("disableDnssec/not-enabled.http");
client.StatusCode(HttpStatusCode.NotImplemented);
Assert.Throws <DnsimpleException>(delegate
{
client.Domains.DisableDnssec(accountId, domainIdentifier);
}, "DNSSEC cannot be disabled because it is not enabled");
}
public void GetEmptyDomainDelegation(long accountId, string domain)
{
var client =
new MockDnsimpleClient(GetDomainDelegationEmptyFixture);
var domainNameServers =
client.Registrar.GetDomainDelegation(accountId, domain)
.Data;
Assert.AreEqual(new List <string>(), domainNameServers);
}
public void ListDomains(string expectedUrl)
{
var client = new MockDnsimpleClient(ListDomainsFixture);
var domains = client.Domains.ListDomains(1010);
Assert.Multiple(() =>
{
Assert.AreEqual(2, domains.Data.Count);
Assert.AreEqual(expectedUrl, client.RequestSentTo());
});
}
