dnsimple 2.2.0 → 3.0.0.pre.beta1

data/spec/dnsimple/client/registrar_whois_privacy_spec.rb

@@ -0,0 +1,119 @@
+require 'spec_helper'
+
+describe Dnsimple::Client, ".registrar" do
+
+  subject { described_class.new(base_url: "https://api.dnsimple.test", access_token: "a1b2c3").registrar }
+
+
+  describe "#whois_privacy" do
+    let(:account_id) { 1010 }
+
+    before do
+      stub_request(:get, %r[/v2/#{account_id}/registrar/domains/.+/whois_privacy$])
+          .to_return(read_http_fixture("getWhoisPrivacy/success.http"))
+    end
+
+    it "builds the correct request" do
+      subject.whois_privacy(account_id, domain_name = "example.com")
+
+      expect(WebMock).to have_requested(:get, "https://api.dnsimple.test/v2/#{account_id}/registrar/domains/#{domain_name}/whois_privacy")
+          .with(headers: { "Accept" => "application/json" })
+    end
+
+    it "returns the whois privacy" do
+      response = subject.whois_privacy(account_id, "example.com")
+      expect(response).to be_a(Dnsimple::Response)
+
+      result = response.data
+      expect(result).to be_a(Dnsimple::Struct::WhoisPrivacy)
+      expect(result.domain_id).to be_kind_of(Fixnum)
+      expect(result.enabled).to be_truthy
+      expect(result.expires_on).to be_kind_of(String)
+    end
+  end
+
+  describe "#enable_whois_privacy" do
+    let(:account_id) { 1010 }
+
+    context "when the whois privacy had already been purchased" do
+      before do
+        stub_request(:put, %r[/v2/#{account_id}/registrar/domains/.+/whois_privacy$])
+            .to_return(read_http_fixture("enableWhoisPrivacy/success.http"))
+      end
+
+      it "builds the correct request" do
+        subject.enable_whois_privacy(account_id, domain_name = "example.com")
+
+        expect(WebMock).to have_requested(:put, "https://api.dnsimple.test/v2/#{account_id}/registrar/domains/#{domain_name}/whois_privacy")
+            .with(headers: { "Accept" => "application/json" })
+      end
+
+      it "returns the whois privacy" do
+        response = subject.enable_whois_privacy(account_id, "example.com")
+        expect(response).to be_a(Dnsimple::Response)
+        expect(response.http_response.code).to eq(200)
+
+        result = response.data
+        expect(result).to be_a(Dnsimple::Struct::WhoisPrivacy)
+        expect(result.domain_id).to be_kind_of(Fixnum)
+        expect(result.enabled).to be_truthy
+        expect(result.expires_on).to be_kind_of(String)
+      end
+    end
+
+    context "when the whois privacy is newly purchased" do
+      before do
+        stub_request(:put, %r[/v2/#{account_id}/registrar/domains/.+/whois_privacy$])
+            .to_return(read_http_fixture("enableWhoisPrivacy/created.http"))
+      end
+
+      it "builds the correct request" do
+        subject.enable_whois_privacy(account_id, domain_name = "example.com")
+
+        expect(WebMock).to have_requested(:put, "https://api.dnsimple.test/v2/#{account_id}/registrar/domains/#{domain_name}/whois_privacy")
+            .with(headers: { "Accept" => "application/json" })
+      end
+
+      it "returns the whois privacy" do
+        response = subject.enable_whois_privacy(account_id, "example.com")
+        expect(response).to be_a(Dnsimple::Response)
+        expect(response.http_response.code).to eq(201)
+
+        result = response.data
+        expect(result).to be_a(Dnsimple::Struct::WhoisPrivacy)
+        expect(result.domain_id).to be_kind_of(Fixnum)
+        expect(result.enabled).to be_nil
+        expect(result.expires_on).to be_nil
+      end
+    end
+  end
+
+
+  describe "#disable_whois_privacy" do
+    let(:account_id) { 1010 }
+
+    before do
+      stub_request(:delete, %r[/v2/#{account_id}/registrar/domains/.+/whois_privacy$])
+          .to_return(read_http_fixture("disableWhoisPrivacy/success.http"))
+    end
+
+    it "builds the correct request" do
+      subject.disable_whois_privacy(account_id, domain_name = "example.com")
+
+      expect(WebMock).to have_requested(:delete, "https://api.dnsimple.test/v2/#{account_id}/registrar/domains/#{domain_name}/whois_privacy")
+          .with(headers: { "Accept" => "application/json" })
+    end
+
+    it "returns the whois privacy" do
+      response = subject.disable_whois_privacy(account_id, "example.com")
+      expect(response).to be_a(Dnsimple::Response)
+
+      result = response.data
+      expect(result).to be_a(Dnsimple::Struct::WhoisPrivacy)
+      expect(result.domain_id).to be_kind_of(Fixnum)
+      expect(result.enabled).to be_falsey
+      expect(result.expires_on).to be_kind_of(String)
+    end
+  end
+
+end

data/spec/dnsimple/client/tlds_spec.rb

@@ -0,0 +1,139 @@
+require 'spec_helper'
+
+describe Dnsimple::Client, ".tlds" do
+  subject { described_class.new(base_url: "https://api.dnsimple.test", access_token: "a1b2c3").tlds }
+
+  describe "#tlds" do
+    before do
+      stub_request(:get, %r[/v2/tlds])
+          .to_return(read_http_fixture("listTlds/success.http"))
+    end
+
+    it "builds the correct request" do
+      subject.tlds
+
+      expect(WebMock).to have_requested(:get, "https://api.dnsimple.test/v2/tlds")
+          .with(headers: { 'Accept' => 'application/json' })
+    end
+
+    it "supports pagination" do
+      subject.tlds(query: { page: 2 })
+
+      expect(WebMock).to have_requested(:get, "https://api.dnsimple.test/v2/tlds?page=2")
+    end
+
+    it "supports additional options" do
+      subject.tlds(query: { foo: "bar" })
+
+      expect(WebMock).to have_requested(:get, "https://api.dnsimple.test/v2/tlds?foo=bar")
+    end
+
+    it "returns the tlds" do
+      response = subject.tlds
+
+      expect(response).to be_a(Dnsimple::PaginatedResponse)
+      expect(response.data).to be_an(Array)
+      expect(response.data.size).to eq(2)
+
+      response.data.each do |result|
+        expect(result).to be_a(Dnsimple::Struct::Tld)
+        expect(result.tld_type).to be_a(Fixnum)
+        expect(result.tld).to be_a(String)
+      end
+    end
+
+    it "exposes the pagination information" do
+      response = subject.tlds
+
+      expect(response.respond_to?(:page)).to be_truthy
+      expect(response.page).to eq(1)
+      expect(response.per_page).to be_a(Fixnum)
+      expect(response.total_entries).to be_a(Fixnum)
+      expect(response.total_pages).to be_a(Fixnum)
+    end
+  end
+
+  describe "#all_tlds" do
+    it "delegates to client.paginate" do
+      expect(subject).to receive(:paginate).with(:tlds, { foo: "bar" })
+      subject.all_tlds({ foo: "bar" })
+    end
+  end
+
+  describe "#tld" do
+    before do
+      stub_request(:get, %r[/v2/tlds/.+$])
+          .to_return(read_http_fixture("getTld/success.http"))
+    end
+
+    it "builds the correct request" do
+      subject.tld(tld = "com")
+
+      expect(WebMock).to have_requested(:get, "https://api.dnsimple.test/v2/tlds/#{tld}")
+          .with(headers: { 'Accept' => 'application/json' })
+    end
+
+    it "returns the tld" do
+      response = subject.tld("com")
+      expect(response).to be_a(Dnsimple::Response)
+
+      result = response.data
+      expect(result).to be_a(Dnsimple::Struct::Tld)
+      expect(result.tld).to eq('com')
+      expect(result.tld_type).to eq(1)
+      expect(result.whois_privacy).to eq(true)
+      expect(result.auto_renew_only).to eq(false)
+      expect(result.idn).to eq(true)
+    end
+  end
+
+  describe "#extended_attributes" do
+    before do
+      stub_request(:get, %r[/v2/tlds/uk/extended_attributes$])
+          .to_return(read_http_fixture("getTldExtendedAttributes/success.http"))
+    end
+
+    it "builds the correct request" do
+      subject.extended_attributes(tld = "uk")
+
+      expect(WebMock).to have_requested(:get, "https://api.dnsimple.test/v2/tlds/#{tld}/extended_attributes")
+          .with(headers: { 'Accept' => 'application/json' })
+    end
+
+    it "returns the extended attributes" do
+      response = subject.extended_attributes("uk")
+      expect(response).to be_a(Dnsimple::CollectionResponse)
+
+      response.data.each do |result|
+        expect(result).to be_a(Dnsimple::Struct::ExtendedAttribute)
+        expect(result.name).to be_a(String)
+        expect(result.description).to be_a(String)
+        expect(result).to respond_to(:required)
+
+        if !result.options.empty?
+          result.options.each do |option|
+            expect(option).to be_a(Dnsimple::Struct::ExtendedAttribute::Option)
+            expect(option.title).to be_a(String)
+            expect(option.value).to be_a(String)
+            expect(option.description).to be_a(String)
+          end
+        end
+      end
+    end
+
+    context "when there are no extended attributes for a TLD" do
+      before do
+        stub_request(:get, %r[/v2/tlds/com/extended_attributes$])
+            .to_return(read_http_fixture("getTldExtendedAttributes/success-noattributes.http"))
+      end
+
+      it "returns an empty CollectionResponse" do
+        response = subject.extended_attributes("com")
+        expect(response).to be_a(Dnsimple::CollectionResponse)
+
+        result = response.data
+        expect(result).to be_empty
+      end
+    end
+  end
+end

data/spec/dnsimple/client/webhooks_spec.rb

@@ -0,0 +1,142 @@
+require 'spec_helper'
+
+describe Dnsimple::Client, ".webhooks" do
+
+  subject { described_class.new(base_url: "https://api.dnsimple.test", access_token: "a1b2c3").webhooks }
+
+  describe "#webhooks" do
+    let(:account_id) { 1010 }
+
+    before do
+      stub_request(:get, %r[/v2/#{account_id}/webhooks])
+          .to_return(read_http_fixture("listWebhooks/success.http"))
+    end
+
+    it "builds the correct request" do
+      subject.webhooks(account_id)
+
+      expect(WebMock).to have_requested(:get, "https://api.dnsimple.test/v2/#{account_id}/webhooks")
+          .with(headers: { 'Accept' => 'application/json' })
+    end
+
+    it "supports extra request options" do
+      subject.webhooks(account_id, query: { foo: "bar" })
+
+      expect(WebMock).to have_requested(:get, "https://api.dnsimple.test/v2/#{account_id}/webhooks?foo=bar")
+    end
+
+    it "returns the webhooks" do
+      response = subject.webhooks(account_id)
+
+      expect(response).to be_a(Dnsimple::CollectionResponse)
+      expect(response.data).to be_a(Array)
+      expect(response.data.size).to eq(2)
+
+      response.data.each do |result|
+        expect(result).to be_a(Dnsimple::Struct::Webhook)
+        expect(result.id).to be_a(Fixnum)
+      end
+    end
+  end
+
+  describe "#create_webhook" do
+    let(:account_id) { 1010 }
+
+    before do
+      stub_request(:post, %r[/v2/#{account_id}/webhooks$])
+          .to_return(read_http_fixture("createWebhook/created.http"))
+    end
+
+    let(:attributes) { {url: "https://webhook.test"} }
+
+    it "builds the correct request" do
+      subject.create_webhook(account_id, attributes)
+
+      expect(WebMock).to have_requested(:post, "https://api.dnsimple.test/v2/#{account_id}/webhooks")
+          .with(body: attributes)
+          .with(headers: { 'Accept' => 'application/json' })
+    end
+
+    it "returns the webhook" do
+      response = subject.create_webhook(account_id, attributes)
+      expect(response).to be_a(Dnsimple::Response)
+
+      result = response.data
+      expect(result).to be_a(Dnsimple::Struct::Webhook)
+      expect(result.id).to be_a(Fixnum)
+    end
+  end
+
+  describe "#webhook" do
+    let(:account_id) { 1010 }
+
+    before do
+      stub_request(:get, %r[/v2/#{account_id}/webhooks/.+$])
+          .to_return(read_http_fixture("getWebhook/success.http"))
+    end
+
+    it "builds the correct request" do
+      subject.webhook(account_id, webhook_id = "1")
+
+      expect(WebMock).to have_requested(:get, "https://api.dnsimple.test/v2/#{account_id}/webhooks/#{webhook_id}")
+          .with(headers: { 'Accept' => 'application/json' })
+    end
+
+    it "returns the webhook" do
+      response = subject.webhook(account_id, 1)
+      expect(response).to be_a(Dnsimple::Response)
+
+      result = response.data
+      expect(result).to be_a(Dnsimple::Struct::Webhook)
+      expect(result.id).to  eq(1)
+      expect(result.url).to eq("https://webhook.test")
+    end
+
+    context "when the webhook does not exist" do
+      it "raises NotFoundError" do
+        stub_request(:get, %r[/v2])
+            .to_return(read_http_fixture("notfound-webhook.http"))
+
+        expect {
+          subject.webhook(account_id, 0)
+        }.to raise_error(Dnsimple::NotFoundError)
+      end
+    end
+  end
+
+  describe "#delete_webhook" do
+    let(:account_id) { 1010 }
+
+    before do
+      stub_request(:delete, %r[/v2/#{account_id}/webhooks/.+$])
+          .to_return(read_http_fixture("deleteWebhook/success.http"))
+    end
+
+    it "builds the correct request" do
+      subject.delete_webhook(account_id, webhook_id = "1")
+
+      expect(WebMock).to have_requested(:delete, "https://api.dnsimple.test/v2/#{account_id}/webhooks/#{webhook_id}")
+          .with(headers: { 'Accept' => 'application/json' })
+    end
+
+    it "returns nothing" do
+      response = subject.delete_webhook(account_id, 1)
+      expect(response).to be_a(Dnsimple::Response)
+
+      result = response.data
+      expect(result).to be_nil
+    end
+
+    context "when the webhook does not exist" do
+      it "raises NotFoundError" do
+        stub_request(:delete, %r[/v2])
+            .to_return(read_http_fixture("notfound-webhook.http"))
+
+        expect {
+          subject.delete_webhook(account_id, 0)
+        }.to raise_error(Dnsimple::NotFoundError)
+      end
+    end
+  end
+
+end

data/spec/dnsimple/client/zones_records_spec.rb

@@ -0,0 +1,277 @@
+require 'spec_helper'
+
+describe Dnsimple::Client, ".zones" do
+
+  subject { described_class.new(base_url: "https://api.dnsimple.test", access_token: "a1b2c3").zones }
+
+
+  describe "#records" do
+    let(:account_id) { 1010 }
+    let(:zone_id) { "example.com" }
+
+    before do
+      stub_request(:get, %r[/v2/#{account_id}/zones/#{zone_id}/records])
+          .to_return(read_http_fixture("listZoneRecords/success.http"))
+    end
+
+    it "builds the correct request" do
+      subject.records(account_id, zone_id)
+
+      expect(WebMock).to have_requested(:get, "https://api.dnsimple.test/v2/#{account_id}/zones/#{zone_id}/records")
+          .with(headers: { 'Accept' => 'application/json' })
+    end
+
+    it "supports pagination" do
+      subject.records(account_id, zone_id, query: { page: 2 })
+
+      expect(WebMock).to have_requested(:get, "https://api.dnsimple.test/v2/#{account_id}/zones/#{zone_id}/records?page=2")
+    end
+
+    it "supports extra request options" do
+      subject.records(account_id, zone_id, query: { foo: "bar" })
+
+      expect(WebMock).to have_requested(:get, "https://api.dnsimple.test/v2/#{account_id}/zones/#{zone_id}/records?foo=bar")
+    end
+
+    it "returns the records" do
+      response = subject.records(account_id, zone_id)
+
+      expect(response).to be_a(Dnsimple::PaginatedResponse)
+      expect(response.data).to be_a(Array)
+      expect(response.data.size).to eq(5)
+
+      response.data.each do |result|
+        expect(result).to be_a(Dnsimple::Struct::Record)
+        expect(result.id).to be_a(Fixnum)
+      end
+    end
+
+    it "exposes the pagination information" do
+      response = subject.records(account_id, zone_id)
+
+      expect(response.respond_to?(:page)).to be_truthy
+      expect(response.page).to eq(1)
+      expect(response.per_page).to be_a(Fixnum)
+      expect(response.total_entries).to be_a(Fixnum)
+      expect(response.total_pages).to be_a(Fixnum)
+    end
+
+    context "when the zone does not exist" do
+      it "raises NotFoundError" do
+        stub_request(:get, %r[/v2])
+            .to_return(read_http_fixture("notfound-zone.http"))
+
+        expect {
+          subject.records(account_id, zone_id)
+        }.to raise_error(Dnsimple::NotFoundError)
+      end
+    end
+  end
+
+  describe "#all_records" do
+    let(:account_id) { 1010 }
+    let(:zone_id) { "example.com" }
+
+    it "delegates to client.paginate" do
+      expect(subject).to receive(:paginate).with(:records, account_id, zone_id, { foo: "bar" })
+      subject.all_records(account_id, zone_id, { foo: "bar" })
+    end
+  end
+
+  describe "#create_record" do
+    let(:account_id) { 1010 }
+    let(:zone_id) { "example.com" }
+
+    before do
+      stub_request(:post, %r[/v2/#{account_id}/zones/#{zone_id}/records$])
+          .to_return(read_http_fixture("createZoneRecord/created.http"))
+    end
+
+    let(:attributes) { { type: "A", name: "www", content: "127.0.0.1" } }
+
+    it "builds the correct request" do
+      subject.create_record(account_id, zone_id, attributes)
+
+      expect(WebMock).to have_requested(:post, "https://api.dnsimple.test/v2/#{account_id}/zones/#{zone_id}/records")
+          .with(body: attributes)
+          .with(headers: { 'Accept' => 'application/json' })
+    end
+
+    it "returns the record" do
+      response = subject.create_record(account_id, zone_id, attributes)
+      expect(response).to be_a(Dnsimple::Response)
+
+      result = response.data
+      expect(result).to be_a(Dnsimple::Struct::Record)
+      expect(result.id).to eq(64784)
+    end
+
+    context "when the zone does not exist" do
+      it "raises NotFoundError" do
+        stub_request(:post, %r[/v2])
+            .to_return(read_http_fixture("notfound-zone.http"))
+
+        expect {
+          subject.create_record(account_id, zone_id, attributes)
+        }.to raise_error(Dnsimple::NotFoundError)
+      end
+    end
+  end
+
+  describe "#record" do
+    let(:account_id) { 1010 }
+    let(:zone_id) { "example.com" }
+
+    before do
+      stub_request(:get, %r[/v2/#{account_id}/zones/#{zone_id}/records/.+$])
+          .to_return(read_http_fixture("getZoneRecord/success.http"))
+    end
+
+    it "builds the correct request" do
+      subject.record(account_id, zone_id, record_id = 2)
+
+      expect(WebMock).to have_requested(:get, "https://api.dnsimple.test/v2/#{account_id}/zones/#{zone_id}/records/#{record_id}")
+          .with(headers: { 'Accept' => 'application/json' })
+    end
+
+    it "returns the record" do
+      response = subject.record(account_id, zone_id, 2)
+      expect(response).to be_a(Dnsimple::Response)
+
+      result = response.data
+      expect(result).to be_a(Dnsimple::Struct::Record)
+      expect(result.id).to eq(64784)
+      expect(result.zone_id).to eq("example.com")
+      expect(result.parent_id).to eq(nil)
+      expect(result.type).to eq("A")
+      expect(result.name).to eq("www")
+      expect(result.content).to eq("127.0.0.1")
+      expect(result.ttl).to eq(600)
+      expect(result.priority).to eq(nil)
+      expect(result.system_record).to eq(false)
+      expect(result.created_at).to eq("2016-01-07T17:45:13.653Z")
+      expect(result.updated_at).to eq("2016-01-07T17:45:13.653Z")
+    end
+
+    context "when the zone does not exist" do
+      it "raises NotFoundError" do
+        stub_request(:get, %r[/v2])
+            .to_return(read_http_fixture("notfound-zone.http"))
+
+        expect {
+          subject.record(account_id, zone_id, "0")
+        }.to raise_error(Dnsimple::NotFoundError)
+      end
+    end
+
+    context "when the record does not exist" do
+      it "raises NotFoundError" do
+        stub_request(:get, %r[/v2])
+            .to_return(read_http_fixture("notfound-record.http"))
+
+        expect {
+          subject.record(account_id, zone_id, "0")
+        }.to raise_error(Dnsimple::NotFoundError)
+      end
+    end
+  end
+
+  describe "#update_record" do
+    let(:account_id) { 1010 }
+    let(:zone_id) { "example.com" }
+
+    before do
+      stub_request(:patch, %r[/v2/#{account_id}/zones/#{zone_id}/records/.+$])
+          .to_return(read_http_fixture("updateZoneRecord/success.http"))
+    end
+
+    let(:attributes) { { content: "127.0.0.1", priority: "1" } }
+
+    it "builds the correct request" do
+      subject.update_record(account_id, zone_id, record_id = 2, attributes)
+
+      expect(WebMock).to have_requested(:patch, "https://api.dnsimple.test/v2/#{account_id}/zones/#{zone_id}/records/#{record_id}")
+          .with(body: attributes)
+          .with(headers: { 'Accept' => 'application/json' })
+    end
+
+    it "returns the record" do
+      response = subject.update_record(account_id, zone_id, 2, attributes)
+      expect(response).to be_a(Dnsimple::Response)
+
+      result = response.data
+      expect(result).to be_a(Dnsimple::Struct::Record)
+      expect(result.id).to eq(64784)
+    end
+
+    context "when the zone does not exist" do
+      it "raises NotFoundError" do
+        stub_request(:patch, %r[/v2])
+            .to_return(read_http_fixture("notfound-zone.http"))
+
+        expect {
+          subject.update_record(account_id, zone_id, "0", {})
+        }.to raise_error(Dnsimple::NotFoundError)
+      end
+    end
+
+    context "when the record does not exist" do
+      it "raises NotFoundError" do
+        stub_request(:patch, %r[/v2])
+            .to_return(read_http_fixture("notfound-record.http"))
+
+        expect {
+          subject.update_record(account_id, zone_id, "0", {})
+        }.to raise_error(Dnsimple::NotFoundError)
+      end
+    end
+  end
+
+  describe "#delete_record" do
+    let(:account_id) { 1010 }
+    let(:zone_id) { "example.com" }
+
+    before do
+      stub_request(:delete, %r[/v2/#{account_id}/zones/#{zone_id}/records/.+$])
+          .to_return(read_http_fixture("deleteZoneRecord/success.http"))
+    end
+
+    it "builds the correct request" do
+      subject.delete_record(account_id, zone_id, record_id = 2)
+
+      expect(WebMock).to have_requested(:delete, "https://api.dnsimple.test/v2/#{account_id}/zones/#{zone_id}/records/#{record_id}")
+          .with(headers: { 'Accept' => 'application/json' })
+    end
+
+    it "returns nothing" do
+      response = subject.delete_record(account_id, zone_id, 2)
+      expect(response).to be_a(Dnsimple::Response)
+
+      result = response.data
+      expect(result).to be_nil
+    end
+
+    context "when the zone does not exist" do
+      it "raises NotFoundError" do
+        stub_request(:delete, %r[/v2])
+            .to_return(read_http_fixture("notfound-zone.http"))
+
+        expect {
+          subject.delete_record(account_id, zone_id, "0")
+        }.to raise_error(Dnsimple::NotFoundError)
+      end
+    end
+
+    context "when the record does not exist" do
+      it "raises NotFoundError" do
+        stub_request(:delete, %r[/v2])
+            .to_return(read_http_fixture("notfound-record.http"))
+
+        expect {
+          subject.delete_record(account_id, zone_id, "0")
+        }.to raise_error(Dnsimple::NotFoundError)
+      end
+    end
+  end
+
+end