dnsimple 2.2.0 → 3.0.0.pre.beta1

data/spec/dnsimple/client/contacts_spec.rb

@@ -2,175 +2,205 @@ require 'spec_helper'
 
 describe Dnsimple::Client, ".contacts" do
 
-  subject { described_class.new(api_endpoint: "https://api.zone", username: "user", api_token: "token").contacts }
+  subject { described_class.new(base_url: "https://api.dnsimple.test", access_token: "a1b2c3").contacts }
 
 
   describe "#contacts" do
+    let(:account_id) { 1010 }
+
     before do
-      stub_request(:get, %r[/v1/contacts$]).
-          to_return(read_fixture("contacts/contacts/success.http"))
+      stub_request(:get, %r[/v2/#{account_id}/contacts])
+          .to_return(read_http_fixture("listContacts/success.http"))
     end
 
     it "builds the correct request" do
-      subject.contacts
+      subject.contacts(account_id)
+
+      expect(WebMock).to have_requested(:get, "https://api.dnsimple.test/v2/#{account_id}/contacts")
+          .with(headers: { 'Accept' => 'application/json' })
+    end
+
+    it "supports pagination" do
+      subject.contacts(account_id, query: { page: 2 })
+
+      expect(WebMock).to have_requested(:get, "https://api.dnsimple.test/v2/#{account_id}/contacts?page=2")
+    end
+
+    it "supports extra request options" do
+      subject.contacts(account_id, query: { foo: "bar" })
 
-      expect(WebMock).to have_requested(:get, "https://api.zone/v1/contacts").
-                         with(headers: { 'Accept' => 'application/json' })
+      expect(WebMock).to have_requested(:get, "https://api.dnsimple.test/v2/#{account_id}/contacts?foo=bar")
     end
 
     it "returns the contacts" do
-      results = subject.contacts
+      response = subject.contacts(account_id)
 
-      expect(results).to be_a(Array)
-      expect(results.size).to eq(2)
+      expect(response).to be_a(Dnsimple::PaginatedResponse)
+      expect(response.data).to be_a(Array)
+      expect(response.data.size).to eq(2)
 
-      results.each do |result|
+      response.data.each do |result|
         expect(result).to be_a(Dnsimple::Struct::Contact)
         expect(result.id).to be_a(Fixnum)
       end
     end
+
+    it "exposes the pagination information" do
+      response = subject.contacts(account_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
+  end
+
+  describe "#all_contacts" do
+    let(:account_id) { 1010 }
+
+    it "delegates to client.paginate" do
+      expect(subject).to receive(:paginate).with(:contacts, account_id, { foo: "bar" })
+      subject.all_contacts(account_id, { foo: "bar" })
+    end
   end
 
   describe "#create_contact" do
+    let(:account_id) { 1010 }
+
     before do
-      stub_request(:post, %r[/v1/contacts$]).
-          to_return(read_fixture("contacts/create_contact/created.http"))
+      stub_request(:post, %r[/v2/#{account_id}/contacts$])
+          .to_return(read_http_fixture("createContact/created.http"))
     end
 
-    let(:attributes) { { first_name: "Simone", last_name: "Carletti", address1: "", city: "Rome", state_province: "RM", postal_code: "00171", country: "IT", email_address: "", phone: "" } }
+    let(:attributes) { { first_name: "Simone", last_name: "Carletti", address1: "Italian Street", city: "Rome", state_province: "RM", postal_code: "00171", country: "IT", email_address: "example@example.com", phone: "+393391234567" } }
 
     it "builds the correct request" do
-      subject.create_contact(attributes)
+      subject.create_contact(account_id, attributes)
 
-      expect(WebMock).to have_requested(:post, "https://api.zone/v1/contacts").
-                             with(body: { contact: attributes }).
-                             with(headers: { 'Accept' => 'application/json' })
+      expect(WebMock).to have_requested(:post, "https://api.dnsimple.test/v2/#{account_id}/contacts")
+          .with(body: attributes)
+          .with(headers: { 'Accept' => 'application/json' })
     end
 
     it "returns the contact" do
-      result = subject.create_contact(attributes)
+      response = subject.create_contact(account_id, attributes)
+      expect(response).to be_a(Dnsimple::Response)
 
+      result = response.data
       expect(result).to be_a(Dnsimple::Struct::Contact)
       expect(result.id).to be_a(Fixnum)
     end
   end
 
   describe "#contact" do
+    let(:account_id) { 1010 }
+
     before do
-      stub_request(:get, %r[/v1/contacts/.+$]).
-          to_return(read_fixture("contacts/contact/success.http"))
+      stub_request(:get, %r[/v2/#{account_id}/contacts/.+$])
+          .to_return(read_http_fixture("getContact/success.http"))
     end
 
     it "builds the correct request" do
-      subject.contact(1)
+      subject.contact(account_id, contact = 1)
 
-      expect(WebMock).to have_requested(:get, "https://api.zone/v1/contacts/1").
-                         with(headers: { 'Accept' => 'application/json' })
+      expect(WebMock).to have_requested(:get, "https://api.dnsimple.test/v2/#{account_id}/contacts/#{contact}")
+          .with(headers: { 'Accept' => 'application/json' })
     end
 
     it "returns the contact" do
-      result = subject.contact(1)
+      response = subject.contact(account_id, 0)
+      expect(response).to be_a(Dnsimple::Response)
 
+      result = response.data
       expect(result).to be_a(Dnsimple::Struct::Contact)
       expect(result.id).to eq(1)
-      expect(result.label).to eq("Default")
-      expect(result.first_name).to eq("Simone")
-      expect(result.last_name).to eq("Carletti")
-      expect(result.job_title).to eq("Underwater Programmer")
-      expect(result.organization_name).to eq("DNSimple")
-      expect(result.email_address).to eq("simone.carletti@dnsimple.com")
-      expect(result.phone).to eq("+1 111 4567890")
-      expect(result.fax).to eq("+1 222 4567890")
-      expect(result.address1).to eq("Awesome Street")
-      expect(result.address2).to eq("c/o Someone")
-      expect(result.city).to eq("Rome")
-      expect(result.state_province).to eq("RM")
-      expect(result.postal_code).to eq("00171")
-      expect(result.country).to eq("IT")
-      expect(result.created_at).to eq("2014-01-15T22:08:07.390Z")
-      expect(result.updated_at).to eq("2014-01-15T22:08:07.390Z")
-    end
-
-    context "when something does not exist" do
+      expect(result.account_id).to eq(1010)
+      expect(result.created_at).to eq("2016-01-19T20:50:26.066Z")
+      expect(result.updated_at).to eq("2016-01-19T20:50:26.066Z")
+    end
+
+    context "when the contact does not exist" do
       it "raises NotFoundError" do
-        stub_request(:get, %r[/v1]).
-            to_return(read_fixture("contacts/notfound-contact.http"))
+        stub_request(:get, %r[/v2])
+            .to_return(read_http_fixture("notfound-contact.http"))
 
         expect {
-          subject.contact(1)
+          subject.contact(account_id, 0)
         }.to raise_error(Dnsimple::NotFoundError)
       end
     end
   end
 
   describe "#update_contact" do
+    let(:account_id) { 1010 }
+
     before do
-      stub_request(:put, %r[/v1/contacts/.+$]).
-          to_return(read_fixture("contacts/update_contact/success.http"))
+      stub_request(:patch, %r[/v2/#{account_id}/contacts/.+$])
+          .to_return(read_http_fixture("updateContact/success.http"))
     end
 
+    let(:attributes) { { first_name: "Updated" } }
+
     it "builds the correct request" do
-      subject.update(1, { label: "Updated" })
+      subject.update_contact(account_id, contact_id = 1, attributes)
 
-      expect(WebMock).to have_requested(:put, "https://api.zone/v1/contacts/1").
-                         with(body: { contact: { label: "Updated" } }).
-                         with(headers: { 'Accept' => 'application/json' })
+      expect(WebMock).to have_requested(:patch, "https://api.dnsimple.test/v2/#{account_id}/contacts/#{contact_id}")
+          .with(body: attributes)
+          .with(headers: { 'Accept' => 'application/json' })
     end
 
     it "returns the contact" do
-      result = subject.update_contact(1, {})
+      response = subject.update_contact(account_id, 1, attributes)
+      expect(response).to be_a(Dnsimple::Response)
 
+      result = response.data
       expect(result).to be_a(Dnsimple::Struct::Contact)
-      expect(result.id).to be_a(Fixnum)
+      expect(result.id).to eq(1)
     end
 
-    context "when something does not exist" do
+    context "when the contact does not exist" do
       it "raises NotFoundError" do
-        stub_request(:put, %r[/v1]).
-            to_return(read_fixture("contacts/notfound-contact.http"))
+        stub_request(:patch, %r[/v2])
+            .to_return(read_http_fixture("notfound-contact.http"))
 
         expect {
-          subject.update_contact(1, {})
+          subject.update_contact(account_id, 0, {})
         }.to raise_error(Dnsimple::NotFoundError)
       end
     end
   end
 
   describe "#delete_contact" do
+    let(:account_id) { 1010 }
+
     before do
-      stub_request(:delete, %r[/v1/contacts/1$]).
-          to_return(read_fixture("contacts/delete_contact/success.http"))
+      stub_request(:delete, %r[/v2/#{account_id}/contacts/.+$])
+          .to_return(read_http_fixture("deleteContact/success.http"))
     end
 
     it "builds the correct request" do
-      subject.delete_contact(1)
+      subject.delete_contact(account_id, domain = "example.com")
 
-      expect(WebMock).to have_requested(:delete, "https://api.zone/v1/contacts/1").
-                         with(headers: { 'Accept' => 'application/json' })
+      expect(WebMock).to have_requested(:delete, "https://api.dnsimple.test/v2/#{account_id}/contacts/#{domain}")
+          .with(headers: { 'Accept' => 'application/json' })
     end
 
     it "returns nothing" do
-      result = subject.delete_contact(1)
-
-      expect(result).to be_truthy
-    end
-
-    it "supports HTTP 204" do
-      stub_request(:delete, %r[/v1]).
-          to_return(read_fixture("contacts/delete_contact/success-204.http"))
-
-      result = subject.delete_contact(1)
+      response = subject.delete_contact(account_id, 1)
+      expect(response).to be_a(Dnsimple::Response)
 
-      expect(result).to be_truthy
+      result = response.data
+      expect(result).to be_nil
     end
 
-    context "when something does not exist" do
+    context "when the contact does not exist" do
       it "raises NotFoundError" do
-        stub_request(:delete, %r[/v1]).
-            to_return(read_fixture("contacts/notfound-contact.http"))
+        stub_request(:delete, %r[/v2])
+            .to_return(read_http_fixture("notfound-contact.http"))
 
         expect {
-          subject.delete_contact(1)
+          subject.delete_contact(account_id, 0)
         }.to raise_error(Dnsimple::NotFoundError)
       end
     end

data/spec/dnsimple/client/domains_email_forwards_spec.rb

@@ -0,0 +1,190 @@
+require 'spec_helper'
+
+describe Dnsimple::Client, ".domains" do
+
+  subject { described_class.new(base_url: "https://api.dnsimple.test", access_token: "a1b2c3").domains }
+
+
+  describe "#email_forwards" do
+    let(:account_id) { 1010 }
+    let(:domain_id) { "example.com" }
+
+    before do
+      stub_request(:get, %r[/v2/#{account_id}/domains/#{domain_id}/email_forwards])
+          .to_return(read_http_fixture("listEmailForwards/success.http"))
+    end
+
+    it "builds the correct request" do
+      subject.email_forwards(account_id, domain_id)
+
+      expect(WebMock).to have_requested(:get, "https://api.dnsimple.test/v2/#{account_id}/domains/#{domain_id}/email_forwards")
+          .with(headers: { 'Accept' => 'application/json' })
+    end
+
+    it "supports pagination" do
+      subject.email_forwards(account_id, domain_id, query: { page: 2 })
+
+      expect(WebMock).to have_requested(:get, "https://api.dnsimple.test/v2/#{account_id}/domains/#{domain_id}/email_forwards?page=2")
+    end
+
+    it "supports extra request options" do
+      subject.email_forwards(account_id, domain_id, query: { foo: "bar" })
+
+      expect(WebMock).to have_requested(:get, "https://api.dnsimple.test/v2/#{account_id}/domains/#{domain_id}/email_forwards?foo=bar")
+    end
+
+    it "returns the email forwards" do
+      response = subject.email_forwards(account_id, domain_id)
+
+      expect(response).to be_a(Dnsimple::PaginatedResponse)
+      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::EmailForward)
+        expect(result.id).to be_a(Fixnum)
+      end
+    end
+
+    it "exposes the pagination information" do
+      response = subject.email_forwards(account_id, domain_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 domain does not exist" do
+      it "raises NotFoundError" do
+        stub_request(:get, %r[/v2])
+            .to_return(read_http_fixture("notfound-domain.http"))
+
+        expect {
+          subject.email_forwards(account_id, domain_id)
+        }.to raise_error(Dnsimple::NotFoundError)
+      end
+    end
+  end
+
+  describe "#all_email_forwards" do
+    let(:account_id) { 1010 }
+    let(:domain_id) { "example.com" }
+
+    it "delegates to client.paginate" do
+      expect(subject).to receive(:paginate).with(:email_forwards, account_id, domain_id, { foo: "bar" })
+      subject.all_email_forwards(account_id, domain_id, { foo: "bar" })
+    end
+  end
+
+  describe "#create_email_forward" do
+    let(:account_id) { 1010 }
+    let(:domain_id) { "example.com" }
+
+    before do
+      stub_request(:post, %r[/v2/#{account_id}/domains/#{domain_id}/email_forwards$])
+          .to_return(read_http_fixture("createEmailForward/created.http"))
+    end
+
+    let(:attributes) { { from: "jim", to: "jim@another.com" } }
+
+    it "builds the correct request" do
+      subject.create_email_forward(account_id, domain_id, attributes)
+
+      expect(WebMock).to have_requested(:post, "https://api.dnsimple.test/v2/#{account_id}/domains/#{domain_id}/email_forwards")
+          .with(body: attributes)
+          .with(headers: { 'Accept' => 'application/json' })
+    end
+
+    it "returns the email forward" do
+      response = subject.create_email_forward(account_id, domain_id, attributes)
+      expect(response).to be_a(Dnsimple::Response)
+
+      result = response.data
+      expect(result).to be_a(Dnsimple::Struct::EmailForward)
+      expect(result.id).to be_a(Fixnum)
+    end
+  end
+
+  describe "#email_forward" do
+    let(:account_id) { 1010 }
+    let(:domain_id) { "example.com" }
+    let(:email_forward_id) { 17706 }
+
+    before do
+      stub_request(:get, %r[/v2/#{account_id}/domains/#{domain_id}/email_forwards.+$])
+          .to_return(read_http_fixture("getEmailForward/success.http"))
+    end
+
+    it "builds the correct request" do
+      subject.email_forward(account_id, domain_id, email_forward_id)
+
+      expect(WebMock).to have_requested(:get, "https://api.dnsimple.test/v2/#{account_id}/domains/#{domain_id}/email_forwards/#{email_forward_id}")
+          .with(headers: { 'Accept' => 'application/json' })
+    end
+
+    it "returns the email forward" do
+      response = subject.email_forward(account_id, domain_id, email_forward_id)
+      expect(response).to be_a(Dnsimple::Response)
+
+      result = response.data
+      expect(result).to be_a(Dnsimple::Struct::EmailForward)
+      expect(result.id).to eq(17706)
+      expect(result.domain_id).to eq(228963)
+      expect(result.from).to eq("jim@a-domain.com")
+      expect(result.to).to eq("jim@another.com")
+      expect(result.created_at).to eq("2016-02-04T14:26:50.282Z")
+      expect(result.updated_at).to eq("2016-02-04T14:26:50.282Z")
+    end
+
+    context "when the email forward does not exist" do
+      it "raises NotFoundError" do
+        stub_request(:get, %r[/v2])
+            .to_return(read_http_fixture("notfound-emailforward.http"))
+
+        expect {
+          subject.email_forward(account_id, domain_id, email_forward_id)
+        }.to raise_error(Dnsimple::NotFoundError)
+      end
+    end
+  end
+
+  describe "#delete_email_forward" do
+    let(:account_id) { 1010 }
+    let(:domain_id) { "example.com" }
+    let(:email_forward_id) { 1 }
+
+    before do
+      stub_request(:delete, %r[/v2/#{account_id}/domains/#{domain_id}/email_forwards/#{email_forward_id}$])
+          .to_return(read_http_fixture("deleteEmailForward/success.http"))
+    end
+
+    it "builds the correct request" do
+      subject.delete_email_forward(account_id, domain_id, email_forward_id)
+
+      expect(WebMock).to have_requested(:delete, "https://api.dnsimple.test/v2/#{account_id}/domains/#{domain_id}/email_forwards/#{email_forward_id}")
+          .with(headers: { 'Accept' => 'application/json' })
+    end
+
+    it "returns nothing" do
+      response = subject.delete_email_forward(account_id, domain_id, email_forward_id)
+      expect(response).to be_a(Dnsimple::Response)
+
+      result = response.data
+      expect(result).to be_nil
+    end
+
+    context "when the email forward does not exist" do
+      it "raises NotFoundError" do
+        stub_request(:delete, %r[/v2])
+            .to_return(read_http_fixture("notfound-emailforward.http"))
+
+        expect {
+          subject.delete_email_forward(account_id, domain_id, email_forward_id)
+        }.to raise_error(Dnsimple::NotFoundError)
+      end
+    end
+  end
+
+end