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()); }); }