dnsimple 2.2.0 → 3.0.0.pre.beta1

data/spec/dnsimple/client/domains_spec.rb

@@ -2,138 +2,201 @@ require 'spec_helper'
 
 describe Dnsimple::Client, ".domains" do
 
-  subject { described_class.new(api_endpoint: "https://api.zone", username: "user", api_token: "token").domains }
+  subject { described_class.new(base_url: "https://api.dnsimple.test", access_token: "a1b2c3").domains }
 
 
   describe "#domains" do
+    let(:account_id) { 1010 }
+
     before do
-      stub_request(:get, %r[/v1/domains$]).
-          to_return(read_fixture("domains/domains/success.http"))
+      stub_request(:get, %r[/v2/#{account_id}/domains])
+          .to_return(read_http_fixture("listDomains/success.http"))
     end
 
     it "builds the correct request" do
-      subject.domains
+      subject.domains(account_id)
+
+      expect(WebMock).to have_requested(:get, "https://api.dnsimple.test/v2/#{account_id}/domains")
+          .with(headers: { 'Accept' => 'application/json' })
+    end
+
+    it "supports pagination" do
+      subject.domains(account_id, query: { page: 2 })
+
+      expect(WebMock).to have_requested(:get, "https://api.dnsimple.test/v2/#{account_id}/domains?page=2")
+    end
+
+    it "supports extra request options" do
+      subject.domains(account_id, query: { foo: "bar" })
 
-      expect(WebMock).to have_requested(:get, "https://api.zone/v1/domains").
-                             with(headers: { 'Accept' => 'application/json' })
+      expect(WebMock).to have_requested(:get, "https://api.dnsimple.test/v2/#{account_id}/domains?foo=bar")
     end
 
     it "returns the domains" do
-      results = subject.domains
+      response = subject.domains(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::Domain)
         expect(result.id).to be_a(Fixnum)
       end
     end
+
+    it "exposes the pagination information" do
+      response = subject.domains(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_domains" do
+    let(:account_id) { 1010 }
+
+    it "delegates to client.paginate" do
+      expect(subject).to receive(:paginate).with(:domains, account_id, { foo: "bar" })
+      subject.all_domains(account_id, { foo: "bar" })
+    end
   end
 
   describe "#create_domain" do
+    let(:account_id) { 1010 }
+
     before do
-      stub_request(:post, %r[/v1/domains$]).
-          to_return(read_fixture("domains/create_domain/created.http"))
+      stub_request(:post, %r[/v2/#{account_id}/domains$])
+          .to_return(read_http_fixture("createDomain/created.http"))
     end
 
     let(:attributes) { { name: "example.com" } }
 
     it "builds the correct request" do
-      subject.create_domain(attributes)
+      subject.create_domain(account_id, attributes)
 
-      expect(WebMock).to have_requested(:post, "https://api.zone/v1/domains").
-                             with(body: { domain: attributes }).
-                             with(headers: { 'Accept' => 'application/json' })
+      expect(WebMock).to have_requested(:post, "https://api.dnsimple.test/v2/#{account_id}/domains")
+          .with(body: attributes)
+          .with(headers: { 'Accept' => 'application/json' })
     end
 
     it "returns the domain" do
-      result = subject.create_domain(attributes)
+      response = subject.create_domain(account_id, attributes)
+      expect(response).to be_a(Dnsimple::Response)
 
+      result = response.data
       expect(result).to be_a(Dnsimple::Struct::Domain)
       expect(result.id).to be_a(Fixnum)
     end
   end
 
   describe "#domain" do
+    let(:account_id) { 1010 }
+
     before do
-      stub_request(:get, %r[/v1/domains/.+$]).
-          to_return(read_fixture("domains/domain/success.http"))
+      stub_request(:get, %r[/v2/#{account_id}/domains/.+$])
+          .to_return(read_http_fixture("getDomain/success.http"))
     end
 
     it "builds the correct request" do
-      subject.domain("example.com")
+      subject.domain(account_id, domain = "example.com")
 
-      expect(WebMock).to have_requested(:get, "https://api.zone/v1/domains/example.com").
-                             with(headers: { 'Accept' => 'application/json' })
+      expect(WebMock).to have_requested(:get, "https://api.dnsimple.test/v2/#{account_id}/domains/#{domain}")
+          .with(headers: { 'Accept' => 'application/json' })
     end
 
     it "returns the domain" do
-      result = subject.domain("example.com")
+      response = subject.domain(account_id, "example.com")
+      expect(response).to be_a(Dnsimple::Response)
 
+      result = response.data
       expect(result).to be_a(Dnsimple::Struct::Domain)
       expect(result.id).to eq(1)
-      expect(result.user_id).to eq(21)
-      expect(result.registrant_id).to eq(321)
-      expect(result.name).to eq("example.com")
-      expect(result.state).to eq("registered")
-      expect(result.auto_renew).to eq(true)
-      expect(result.whois_protected).to eq(false)
-      expect(result.expires_on).to eq("2015-09-27")
-      expect(result.created_at).to eq("2012-09-27T14:25:57.646Z")
-      expect(result.updated_at).to eq("2014-12-15T20:27:04.552Z")
-    end
-
-    context "when something does not exist" do
+      expect(result.account_id).to eq(1010)
+      expect(result.registrant_id).to eq(nil)
+      expect(result.name).to eq("example-alpha.com")
+      expect(result.state).to eq("hosted")
+      expect(result.auto_renew).to eq(false)
+      expect(result.private_whois).to eq(false)
+      expect(result.expires_on).to eq(nil)
+      expect(result.created_at).to eq("2014-12-06T15:56:55.573Z")
+      expect(result.updated_at).to eq("2015-12-09T00:20:56.056Z")
+    end
+
+    context "when the domain does not exist" do
       it "raises NotFoundError" do
-        stub_request(:get, %r[/v1]).
-            to_return(read_fixture("domains/notfound-domain.http"))
+        stub_request(:get, %r[/v2])
+            .to_return(read_http_fixture("notfound-domain.http"))
 
         expect {
-          subject.domain("example.com")
+          subject.domain(account_id, "example.com")
         }.to raise_error(Dnsimple::NotFoundError)
       end
     end
   end
 
   describe "#delete_domain" do
+    let(:account_id) { 1010 }
+
     before do
-      stub_request(:delete, %r[/v1/domains/.+$]).
-          to_return(read_fixture("domains/delete_domain/success.http"))
+      stub_request(:delete, %r[/v2/#{account_id}/domains/.+$])
+          .to_return(read_http_fixture("deleteDomain/success.http"))
     end
 
     it "builds the correct request" do
-      subject.delete_domain("example.com")
+      subject.delete_domain(account_id, domain = "example.com")
 
-      expect(WebMock).to have_requested(:delete, "https://api.zone/v1/domains/example.com").
-                             with(headers: { 'Accept' => 'application/json' })
+      expect(WebMock).to have_requested(:delete, "https://api.dnsimple.test/v2/#{account_id}/domains/#{domain}")
+          .with(headers: { 'Accept' => 'application/json' })
     end
 
     it "returns nothing" do
-      result = subject.delete_domain("example.com")
+      response = subject.delete_domain(account_id, "example.com")
+      expect(response).to be_a(Dnsimple::Response)
 
-      expect(result).to be_truthy
+      result = response.data
+      expect(result).to be_nil
     end
 
-    it "supports HTTP 204" do
-      stub_request(:delete, %r[/v1]).
-          to_return(read_fixture("domains/delete_domain/success-204.http"))
-
-      result = subject.delete_domain("example.com")
-
-      expect(result).to be_truthy
-    end
-
-    context "when something does not exist" do
+    context "when the domain does not exist" do
       it "raises NotFoundError" do
-        stub_request(:delete, %r[/v1]).
-            to_return(read_fixture("domains/notfound-domain.http"))
+        stub_request(:delete, %r[/v2])
+            .to_return(read_http_fixture("notfound-domain.http"))
 
         expect {
-          subject.delete_domain("example.com")
+          subject.delete_domain(account_id, "example.com")
         }.to raise_error(Dnsimple::NotFoundError)
       end
     end
   end
 
+  describe "#reset_domain_token" do
+    let(:account_id) { 1010 }
+    let(:domain_id) { "example.com" }
+
+    before do
+      stub_request(:post, %r[/v2/#{account_id}/domains/#{domain_id}/token])
+          .to_return(read_http_fixture("resetDomainToken/success.http"))
+    end
+
+    it "builds the correct request" do
+      subject.reset_domain_token(account_id, domain_id)
+
+      expect(WebMock).to have_requested(:post, "https://api.dnsimple.test/v2/#{account_id}/domains/#{domain_id}/token")
+          .with(headers: { 'Accept' => 'application/json' })
+    end
+
+    it "returns the domain" do
+      response = subject.reset_domain_token(account_id, domain_id)
+      expect(response).to be_a(Dnsimple::Response)
+
+      result = response.data
+      expect(result).to be_a(Dnsimple::Struct::Domain)
+      expect(result.id).to be_a(Fixnum)
+    end
+  end
+
 end

data/spec/dnsimple/client/identity_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+describe Dnsimple::Client, ".identity" do
+
+  subject { described_class.new(base_url: "https://api.dnsimple.test", access_token: "a1b2c3").identity }
+
+
+  describe "#whoami" do
+    before do
+      stub_request(:get, %r[/v2/whoami$])
+          .to_return(read_http_fixture("whoami/success.http"))
+    end
+
+    it "builds the correct request" do
+      subject.whoami
+
+      expect(WebMock).to have_requested(:get, "https://api.dnsimple.test/v2/whoami")
+          .with(headers: { 'Accept' => 'application/json' })
+    end
+
+    it "returns a response" do
+      response = subject.whoami
+      expect(response).to be_a(Dnsimple::Response)
+
+      result = response.data
+      expect(result).to be_a(Hash)
+    end
+
+    context "when authenticated as account" do
+      before do
+        stub_request(:get, %r[/v2/whoami$])
+            .to_return(read_http_fixture("whoami/success_account.http"))
+      end
+
+      it "sets the account" do
+        result = subject.whoami.data
+        expect(result[:account]).to be_a(Dnsimple::Struct::Account)
+        expect(result[:user]).to be_nil
+      end
+    end
+
+    context "when authenticated as user" do
+      before do
+        stub_request(:get, %r[/v2/whoami$])
+            .to_return(read_http_fixture("whoami/success_user.http"))
+      end
+
+      it "sets the user" do
+        result = subject.whoami.data
+        expect(result[:account]).to be_nil
+        expect(result[:user]).to be_a(Dnsimple::Struct::User)
+      end
+    end
+  end
+
+end

data/spec/dnsimple/client/oauth_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe Dnsimple::Client, ".oauth" do
+
+  subject { described_class.new(base_url: "https://api.dnsimple.test", access_token: "a1b2c3").oauth }
+
+
+  describe "#exchange_authorization_for_token" do
+    let(:client_id) { "super-client" }
+    let(:client_secret) { "super-secret" }
+    let(:code) { "super-code" }
+
+    before do
+      stub_request(:post, %r[/v2/oauth/access_token$])
+          .to_return(read_http_fixture("oauthAccessToken/success.http"))
+    end
+
+    it "builds the correct request" do
+      subject.exchange_authorization_for_token(code, client_id, client_secret)
+
+      expect(WebMock).to have_requested(:post, "https://api.dnsimple.test/v2/oauth/access_token")
+          .with(body: { client_id: client_id, client_secret: client_secret, code: code, grant_type: "authorization_code" })
+          .with(headers: { 'Accept' => 'application/json' })
+    end
+
+    it "returns oauth token" do
+      result = subject.exchange_authorization_for_token(code, client_id, client_secret)
+
+      expect(result).to be_a(Dnsimple::Struct::OauthToken)
+      expect(result.access_token).to eq("zKQ7OLqF5N1gylcJweA9WodA000BUNJD")
+      expect(result.token_type).to eq("Bearer")
+      expect(result.account_id).to eq(1)
+    end
+  end
+
+  describe "#authorize_url" do
+    it "builds the correct url" do
+      url = subject.authorize_url("great-app")
+      expect(url).to eq("https://dnsimple.test/oauth/authorize?client_id=great-app&response_type=code")
+    end
+
+    it "exposes the options in the query string" do
+      url = subject.authorize_url("great-app", secret: "1", redirect_uri: "http://example.com")
+      expect(url).to eq("https://dnsimple.test/oauth/authorize?client_id=great-app&secret=1&redirect_uri=http://example.com&response_type=code")
+    end
+  end
+
+end

data/spec/dnsimple/client/registrar_auto_renewal_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+
+describe Dnsimple::Client, ".registrar" do
+
+  subject { described_class.new(base_url: "https://api.dnsimple.test", access_token: "a1b2c3").registrar }
+
+  describe "#enable_auto_renewal" do
+    let(:account_id) { 1010 }
+    let(:domain_id) { "example.com" }
+
+    before do
+      stub_request(:put, %r[/v2/#{account_id}/registrar/domains/#{domain_id}])
+          .to_return(read_http_fixture("enableAutoRenewal/success.http"))
+    end
+
+
+    it "builds the correct request" do
+      subject.enable_auto_renewal(account_id, domain_id)
+
+      expect(WebMock).to have_requested(:put, "https://api.dnsimple.test/v2/#{account_id}/registrar/domains/#{domain_id}/auto_renewal")
+          .with(headers: { 'Accept' => 'application/json' })
+    end
+
+    it "returns nothing" do
+      response = subject.enable_auto_renewal(account_id, domain_id)
+      expect(response).to be_a(Dnsimple::Response)
+
+      result = response.data
+      expect(result).to be_nil
+    end
+
+    context "when the domain does not exist" do
+      it "raises NotFoundError" do
+        stub_request(:put, %r[/v2])
+            .to_return(read_http_fixture("notfound-domain.http"))
+
+        expect {
+          subject.enable_auto_renewal(account_id, domain_id)
+        }.to raise_error(Dnsimple::NotFoundError)
+      end
+    end
+  end
+  
+  describe "#disable_auto_renewal" do
+    let(:account_id) { 1010 }
+    let(:domain_id) { "example.com" }
+
+    before do
+      stub_request(:delete, %r[/v2/#{account_id}/registrar/domains/#{domain_id}])
+          .to_return(read_http_fixture("disableAutoRenewal/success.http"))
+    end
+
+
+    it "builds the correct request" do
+      subject.disable_auto_renewal(account_id, domain_id)
+
+      expect(WebMock).to have_requested(:delete, "https://api.dnsimple.test/v2/#{account_id}/registrar/domains/#{domain_id}/auto_renewal")
+          .with(headers: { 'Accept' => 'application/json' })
+    end
+
+    it "returns nothing" do
+      response = subject.disable_auto_renewal(account_id, domain_id)
+      expect(response).to be_a(Dnsimple::Response)
+
+      result = response.data
+      expect(result).to be_nil
+    end
+
+    context "when the domain does not exist" do
+      it "raises NotFoundError" do
+        stub_request(:delete, %r[/v2])
+            .to_return(read_http_fixture("notfound-domain.http"))
+
+        expect {
+          subject.disable_auto_renewal(account_id, domain_id)
+        }.to raise_error(Dnsimple::NotFoundError)
+      end
+    end
+  end
+end

data/spec/dnsimple/client/registrar_spec.rb

@@ -2,200 +2,187 @@ require 'spec_helper'
 
 describe Dnsimple::Client, ".registrar" do
 
-  subject { described_class.new(api_endpoint: "https://api.zone", username: "user", api_token: "token").registrar }
+  subject { described_class.new(base_url: "https://api.dnsimple.test", access_token: "a1b2c3").registrar }
 
 
-  describe "#check" do
+  describe "#check_domain" do
+    let(:account_id) { 1010 }
+
     before do
-      stub_request(:get, %r[/v1/domains/.+/check$]).
-          to_return(read_fixture("registrar/check/registered.http"))
+      stub_request(:get, %r[/v2/#{account_id}/registrar/domains/.+/check$])
+          .to_return(read_http_fixture("checkDomain/success.http"))
     end
 
     it "builds the correct request" do
-      subject.check("example.com")
-
-      expect(WebMock).to have_requested(:get, "https://api.zone/v1/domains/example.com/check").
-                             with(headers: { 'Accept' => 'application/json' })
-    end
-
-    context "the domain is registered" do
-      before do
-        stub_request(:get, %r[/v1/domains/.+/check$]).
-            to_return(read_fixture("registrar/check/registered.http"))
-      end
-
-      it "returns the result" do
-        result = subject.check("example.com")
+      subject.check_domain(account_id, domain_name = "example.com")
 
-        expect(result).to be_a(Hash)
-        expect(result['status']).to eq("unavailable")
-      end
+      expect(WebMock).to have_requested(:get, "https://api.dnsimple.test/v2/#{account_id}/registrar/domains/#{domain_name}/check")
+          .with(headers: { "Accept" => "application/json" })
     end
 
-    context "the domain is available" do
-      before do
-        stub_request(:get, %r[/v1/domains/.+/check$]).
-            to_return(read_fixture("registrar/check/available.http"))
-      end
-
-      it "returns the result" do
-        result = subject.check("example.com")
+    it "returns the availability" do
+      response = subject.check_domain(account_id, "example.com")
+      expect(response).to be_a(Dnsimple::Response)
 
-        expect(result).to be_a(Hash)
-        expect(result['status']).to eq("available")
-      end
+      result = response.data
+      expect(result).to be_a(Dnsimple::Struct::DomainCheck)
+      expect(result.domain).to eq("example.com")
+      expect(result.available).to be_truthy
+      expect(result.premium).to be_falsey
     end
   end
 
-  describe "#available?" do
+  describe "#register_domain" do
+    let(:account_id) { 1010 }
+
     before do
-      stub_request(:get, %r[/v1/domains/.+/check$]).
-          to_return(read_fixture("registrar/check/registered.http"))
+      stub_request(:post, %r[/v2/#{account_id}/registrar/domains/.+/registration$])
+          .to_return(read_http_fixture("registerDomain/success.http"))
     end
 
+    let(:attributes) { { registrant_id: "10" } }
+
     it "builds the correct request" do
-      subject.check("example.com")
+      subject.register_domain(account_id, domain_name = "example.com", attributes)
 
-      expect(WebMock).to have_requested(:get, "https://api.zone/v1/domains/example.com/check").
-                             with(headers: { 'Accept' => 'application/json' })
+      expect(WebMock).to have_requested(:post, "https://api.dnsimple.test/v2/#{account_id}/registrar/domains/#{domain_name}/registration")
+          .with(body: attributes)
+          .with(headers: { "Accept" => "application/json" })
     end
 
-    context "the domain is registered" do
-      before do
-        stub_request(:get, %r[/v1/domains/.+/check$]).
-            to_return(read_fixture("registrar/check/registered.http"))
-      end
+    it "returns the domain" do
+      response = subject.register_domain(account_id, "example.com", attributes)
+      expect(response).to be_a(Dnsimple::Response)
 
-      it "returns false" do
-        expect(subject.available?("example.com")).to be_falsey
-      end
+      result = response.data
+      expect(result).to be_a(Dnsimple::Struct::Domain)
+      expect(result.id).to be_a(Fixnum)
     end
 
-    context "the domain is available" do
-      before do
-        stub_request(:get, %r[/v1/domains/.+/check$]).
-            to_return(read_fixture("registrar/check/available.http"))
-      end
-
-      it "returns true" do
-        expect(subject.available?("example.com")).to be_truthy
+    context "when the attributes are incomplete" do
+      it "raises ArgumentError" do
+        expect { subject.register_domain(account_id, "example.com") }.to raise_error(ArgumentError)
       end
     end
   end
 
-  describe "#register" do
+  describe "#renew_domain" do
+    let(:account_id) { 1010 }
+
     before do
-      stub_request(:post, %r[/v1/domain_registrations]).
-          to_return(read_fixture("registrar/register/success.http"))
+      stub_request(:post, %r[/v2/#{account_id}/registrar/domains/.+/renew$])
+          .to_return(read_http_fixture("renewDomain/success.http"))
     end
 
+    let(:attributes) { { period: "3" } }
+
     it "builds the correct request" do
-      subject.register("example.com", 10)
+      subject.renew_domain(account_id, domain_name = "example.com", attributes)
 
-      expect(WebMock).to have_requested(:post, "https://api.zone/v1/domain_registrations").
-                             with(body: { domain: { name: "example.com", registrant_id: "10" }}).
-                             with(headers: { 'Accept' => 'application/json' })
+      expect(WebMock).to have_requested(:post, "https://api.dnsimple.test/v2/#{account_id}/registrar/domains/#{domain_name}/renew")
+          .with(body: attributes)
+          .with(headers: { "Accept" => "application/json" })
     end
 
     it "returns the domain" do
-      result = subject.register("example.com", 10)
+      response = subject.renew_domain(account_id, "example.com", attributes)
+      expect(response).to be_a(Dnsimple::Response)
 
+      result = response.data
       expect(result).to be_a(Dnsimple::Struct::Domain)
       expect(result.id).to be_a(Fixnum)
     end
+
+    context "when it is too son for the domain to be renewed" do
+      it "raises a BadRequestError" do
+        stub_request(:post, %r[/v2/#{account_id}/registrar/domains/.+/renew$])
+            .to_return(read_http_fixture("renewDomain/error-tooearly.http"))
+
+        expect {
+          subject.renew_domain(account_id, "example.com", attributes)
+        }.to raise_error(Dnsimple::RequestError)
+      end
+    end
   end
 
-  describe "#renew" do
+  describe "#transfer_domain" do
+    let(:account_id) { 1010 }
+
     before do
-      stub_request(:post, %r[/v1/domain_renewals]).
-          to_return(read_fixture("registrar/renew/success.http"))
+      stub_request(:post, %r[/v2/#{account_id}/registrar/domains/.+/transfer$])
+          .to_return(read_http_fixture("transferDomain/success.http"))
     end
 
+    let(:attributes) { { registrant_id: "10", auth_info: "x1y2z3" } }
+
     it "builds the correct request" do
-      subject.renew("example.com")
+      subject.transfer_domain(account_id, domain_name = "example.com", attributes)
 
-      expect(WebMock).to have_requested(:post, "https://api.zone/v1/domain_renewals").
-                             with(headers: { 'Accept' => 'application/json' })
+      expect(WebMock).to have_requested(:post, "https://api.dnsimple.test/v2/#{account_id}/registrar/domains/#{domain_name}/transfer")
+          .with(body: attributes)
+          .with(headers: { "Accept" => "application/json" })
     end
 
     it "returns the domain" do
-      result = subject.renew("example.com")
+      response = subject.transfer_domain(account_id, "example.com", attributes)
+      expect(response).to be_a(Dnsimple::Response)
 
+      result = response.data
       expect(result).to be_a(Dnsimple::Struct::Domain)
-      expect(result.id).to be_a(Fixnum)
+      expect(result.name).to eq("example.com")
+      expect(result.registrant_id).to eq(10)
     end
 
-    context "when something does not exist" do
-      it "raises NotFoundError" do
-        stub_request(:post, %r[/v1]).
-            to_return(read_fixture("domains/notfound-domain.http"))
-
-        expect {
-          subject.renew("example.com")
-        }.to raise_error(Dnsimple::NotFoundError)
+    context "when the attributes are incomplete" do
+      it "raises ArgumentError" do
+        expect { subject.transfer_domain(account_id, "example.com", auth_info: "x1y2z3") }.to raise_error(ArgumentError)
       end
     end
-  end
-
-
-  describe "#extended_attributes" do
-    before do
-      stub_request(:get, %r[/v1/extended_attributes/.+$]).
-          to_return(read_fixture("registrar/extended_attributes/success.http"))
-    end
 
-    it "builds the correct request" do
-      subject.extended_attributes("uk")
+    context "when the domain is already in DNSimple" do
+      it "raises a BadRequestError" do
+        stub_request(:post, %r[/v2/#{account_id}/registrar/domains/.+/transfer$])
+            .to_return(read_http_fixture("transferDomain/error-indnsimple.http"))
 
-      expect(WebMock).to have_requested(:get, "https://api.zone/v1/extended_attributes/uk").
-                             with(headers: { 'Accept' => 'application/json' })
+        expect {
+          subject.transfer_domain(account_id, "example.com", attributes)
+        }.to raise_error(Dnsimple::RequestError)
+      end
     end
 
-    it "returns the extended attributes" do
-      results = subject.extended_attributes("uk")
-
-      expect(results).to be_a(Array)
-      expect(results.size).to eq(4)
+    context "when :auth_info wasn't provided and is required by the TLD" do
+      it "raises a BadRequestError" do
+        stub_request(:post, %r[/v2/#{account_id}/registrar/domains/.+/transfer$])
+            .to_return(read_http_fixture("transferDomain/error-missing-authcode.http"))
 
-      result = results[0]
-      expect(result).to be_a(Dnsimple::Struct::ExtendedAttribute)
-      expect(result.name).to eq("uk_legal_type")
-      expect(result.description).to eq("Legal type of registrant contact")
-      expect(result.required).to eq(false)
-      expect(result.options).to be_a(Array)
-      expect(result.options.size).to eq(17)
-
-      option = result.options[0]
-      expect(option.title).to eq("UK Individual")
-      expect(option.value).to eq("IND")
-      expect(option.description).to eq("UK Individual (our default value)")
+        expect {
+          subject.transfer_domain(account_id, "example.com", registrant_id: 10)
+        }.to raise_error(Dnsimple::RequestError)
+      end
     end
   end
 
+  describe "#transfer_domain_out" do
+    let(:account_id) { 1010 }
 
-  describe "#prices" do
     before do
-      stub_request(:get, %r[/v1/prices$]).
-          to_return(read_fixture("registrar/prices/success.http"))
+      stub_request(:post, %r[/v2/#{account_id}/registrar/domains/.+/transfer_out$])
+          .to_return(read_http_fixture("transferDomainOut/success.http"))
     end
 
     it "builds the correct request" do
-      subject.prices
+      subject.transfer_domain_out(account_id, domain_name = "example.com")
 
-      expect(WebMock).to have_requested(:get, "https://api.zone/v1/prices").
-                             with(headers: { 'Accept' => 'application/json' })
+      expect(WebMock).to have_requested(:post, "https://api.dnsimple.test/v2/#{account_id}/registrar/domains/#{domain_name}/transfer_out")
+          .with(headers: { "Accept" => "application/json" })
     end
 
-    it "returns the prices" do
-      results = subject.prices
+    it "returns nothing" do
+      response = subject.transfer_domain_out(account_id, "example.com")
+      expect(response).to be_a(Dnsimple::Response)
 
-      expect(results).to be_a(Array)
-      expect(results.size).to be > 0
-
-      results.each do |result|
-        expect(result).to be_a(Dnsimple::Struct::Price)
-        expect(result.tld).to be_a(String)
-      end
+      result = response.data
+      expect(result).to be_nil
     end
   end