dnsimple 2.0.0.alpha2 → 2.0.0.alpha3

data/spec/dnsimple/client/templates_service_spec.rb

@@ -0,0 +1,371 @@
+require 'spec_helper'
+
+describe Dnsimple::Client, ".templates" do
+
+  subject { described_class.new(api_endpoint: "https://api.zone", username: "user", api_token: "token").templates }
+
+
+  describe "#list" do
+    before do
+      stub_request(:get, %r[/v1/templates$]).
+          to_return(read_fixture("templates/index/success.http"))
+    end
+
+    it "builds the correct request" do
+      subject.list
+
+      expect(WebMock).to have_requested(:get, "https://api.zone/v1/templates").
+                         with(headers: { 'Accept' => 'application/json' })
+    end
+
+    it "returns the templates" do
+      results = subject.list
+
+      expect(results).to be_a(Array)
+      expect(results.size).to eq(1)
+
+      results.each do |result|
+        expect(result).to be_a(Dnsimple::Struct::Template)
+        expect(result.id).to be_a(Fixnum)
+      end
+    end
+  end
+
+  describe "#create" do
+    before do
+      stub_request(:post, %r[/v1/templates]).
+          to_return(read_fixture("templates/create/created.http"))
+    end
+
+    let(:attributes) { { name: "", short_name: "" } }
+
+    it "builds the correct request" do
+      subject.create(attributes)
+
+      expect(WebMock).to have_requested(:post, "https://api.zone/v1/templates").
+                         with(body: { dns_template: attributes }).
+                         with(headers: { 'Accept' => 'application/json' })
+    end
+
+    it "returns the template" do
+      result = subject.create(attributes)
+
+      expect(result).to be_a(Dnsimple::Struct::Template)
+      expect(result.id).to be_a(Fixnum)
+    end
+  end
+
+  describe "#find" do
+    before do
+      stub_request(:get, %r[/v1/templates/.+$]).
+          to_return(read_fixture("templates/show/success.http"))
+    end
+
+    it "builds the correct request" do
+      subject.find(1)
+
+      expect(WebMock).to have_requested(:get, "https://api.zone/v1/templates/1").
+                             with(headers: { 'Accept' => 'application/json' })
+    end
+
+    it "returns the template" do
+      result = subject.find(1)
+
+      expect(result).to be_a(Dnsimple::Struct::Template)
+      expect(result.id).to eq(2651)
+      expect(result.name).to eq("Localhost")
+      expect(result.short_name).to eq("localhost")
+      expect(result.description).to eq("This is a test.")
+    end
+
+    context "when something does not exist" do
+      it "raises RecordNotFound" do
+        stub_request(:get, %r[/v1]).
+            to_return(read_fixture("templates/notfound.http"))
+
+        expect {
+          subject.find(1)
+        }.to raise_error(Dnsimple::RecordNotFound)
+      end
+    end
+  end
+
+  describe "#update" do
+    before do
+      stub_request(:put, %r[/v1/templates/.+$]).
+          to_return(read_fixture("templates/update/success.http"))
+    end
+
+    it "builds the correct request" do
+      subject.update(1, { name: "Updated" })
+
+      expect(WebMock).to have_requested(:put, "https://api.zone/v1/templates/1").
+                             with(body: { dns_template: { name: "Updated" } }).
+                             with(headers: { 'Accept' => 'application/json' })
+    end
+
+    it "returns the template" do
+      result = subject.update(1, {})
+
+      expect(result).to be_a(Dnsimple::Struct::Template)
+      expect(result.id).to be_a(Fixnum)
+    end
+
+    context "when something does not exist" do
+      it "raises RecordNotFound" do
+        stub_request(:put, %r[/v1]).
+            to_return(read_fixture("templates/notfound.http"))
+
+        expect {
+          subject.update(1, {})
+        }.to raise_error(Dnsimple::RecordNotFound)
+      end
+    end
+  end
+
+  describe "#delete" do
+    before do
+      stub_request(:delete, %r[/v1/templates/.+$]).
+          to_return(read_fixture("templates/delete/success.http"))
+    end
+
+    it "builds the correct request" do
+      subject.delete(1)
+
+      expect(WebMock).to have_requested(:delete, "https://api.zone/v1/templates/1").
+                         with(headers: { 'Accept' => 'application/json' })
+    end
+
+    it "returns nothing" do
+      result = subject.delete(1)
+
+      expect(result).to be_truthy
+    end
+
+    it "supports HTTP 204" do
+      stub_request(:delete, %r[/v1]).
+          to_return(read_fixture("templates/delete/success-204.http"))
+
+      result = subject.delete(1)
+
+      expect(result).to be_truthy
+    end
+
+    context "when something does not exist" do
+      it "raises RecordNotFound" do
+        stub_request(:delete, %r[/v1]).
+            to_return(read_fixture("templates/notfound.http"))
+
+        expect {
+          subject.delete(1)
+        }.to raise_error(Dnsimple::RecordNotFound)
+      end
+    end
+  end
+
+
+  describe "#apply" do
+    before do
+      stub_request(:post, %r[/v1/domains/.+/templates/.+/apply$]).
+          to_return(read_fixture("templates/apply/success.http"))
+    end
+
+    it "builds the correct request" do
+      subject.apply(1, 2)
+
+      expect(WebMock).to have_requested(:post, "https://api.zone/v1/domains/1/templates/2/apply").
+                             with(headers: { 'Accept' => 'application/json' })
+    end
+
+    it "returns nothing" do
+      result = subject.apply(1, 2)
+
+      expect(result).to be_truthy
+    end
+
+    context "when something does not exist" do
+      it "raises RecordNotFound" do
+        stub_request(:post, %r[/v1]).
+            to_return(read_fixture("templates/notfound.http"))
+
+        expect {
+          subject.apply(1, 2)
+        }.to raise_error(Dnsimple::RecordNotFound)
+      end
+    end
+  end
+
+
+  describe "#list_records" do
+    before do
+      stub_request(:get, %r[/v1/templates/.+/records$]).
+          to_return(read_fixture("templates_records/index/success.http"))
+    end
+
+    it "builds the correct request" do
+      subject.list_records(1)
+
+      expect(WebMock).to have_requested(:get, "https://api.zone/v1/templates/1/records").
+                             with(headers: { 'Accept' => 'application/json' })
+    end
+
+    it "returns the template records" do
+      results = subject.list_records(1)
+
+      expect(results).to be_a(Array)
+      expect(results.size).to eq(2)
+
+      results.each do |result|
+        expect(result).to be_a(Dnsimple::Struct::TemplateRecord)
+        expect(result.id).to be_a(Fixnum)
+      end
+    end
+  end
+
+  describe "#create_record" do
+    before do
+      stub_request(:post, %r[/v1/templates/.+/records$]).
+          to_return(read_fixture("templates_records/create/created.http"))
+    end
+
+    it "builds the correct request" do
+      subject.create_record(1, { name: "", record_type: "A", content: "127.0.0.1", prio: "1" })
+
+      expect(WebMock).to have_requested(:post, "https://api.zone/v1/templates/1/records").
+                             with(body: { dns_template_record: { name: "", record_type: "A", content: "127.0.0.1", prio: "1" } }).
+                             with(headers: { 'Accept' => 'application/json' })
+    end
+
+    it "returns the template record" do
+      result = subject.create_record(1, { name: "", record_type: "", content: "" })
+
+      expect(result).to be_a(Dnsimple::Struct::TemplateRecord)
+      expect(result.id).to be_a(Fixnum)
+    end
+
+    context "when something does not exist" do
+      it "raises RecordNotFound" do
+        stub_request(:post, %r[/v1]).
+            to_return(read_fixture("templates_records/notfound.http"))
+
+        expect {
+          subject.create_record(1, { name: "", record_type: "", content: "" })
+        }.to raise_error(Dnsimple::RecordNotFound)
+      end
+    end
+  end
+
+  describe "#find_record" do
+    before do
+      stub_request(:get, %r[/v1/templates/.+/records/.+$]).
+          to_return(read_fixture("templates_records/show/success.http"))
+    end
+
+    it "builds the correct request" do
+      subject.find_record(1, 2)
+
+      expect(WebMock).to have_requested(:get, "https://api.zone/v1/templates/1/records/2").
+                             with(headers: { 'Accept' => 'application/json' })
+    end
+
+    it "returns the record" do
+      result = subject.find_record(1, 2)
+
+      expect(result).to be_a(Dnsimple::Struct::TemplateRecord)
+      expect(result.id).to eq(8868)
+      expect(result.dns_template_id).to eq(2947)
+      expect(result.name).to eq("ww1")
+      expect(result.content).to eq("127.0.0.1")
+      expect(result.ttl).to eq(3600)
+      expect(result.prio).to be_nil
+      expect(result.record_type).to eq("ALIAS")
+      expect(result.created_at).to eq("2014-12-15T17:25:20.431Z")
+      expect(result.updated_at).to eq("2014-12-15T17:25:20.431Z")
+    end
+
+    context "when something does not exist" do
+      it "raises RecordNotFound" do
+        stub_request(:get, %r[/v1]).
+            to_return(read_fixture("templates_records/notfound.http"))
+
+        expect {
+          subject.find_record(1, 2)
+        }.to raise_error(Dnsimple::RecordNotFound)
+      end
+    end
+  end
+
+  describe "#update_record" do
+    before do
+      stub_request(:put, %r[/v1/templates/.+/records/.+$]).
+          to_return(read_fixture("templates_records/update/success.http"))
+    end
+
+    it "builds the correct request" do
+      subject.update_record(1, 2, { name: "www" })
+
+      expect(WebMock).to have_requested(:put, "https://api.zone/v1/templates/1/records/2").
+                             with(body: { dns_template_record: { name: "www" } }).
+                             with(headers: { 'Accept' => 'application/json' })
+    end
+
+    it "returns the template record" do
+      result = subject.update_record(1, 2, {})
+
+      expect(result).to be_a(Dnsimple::Struct::TemplateRecord)
+      expect(result.id).to be_a(Fixnum)
+    end
+
+    context "when something does not exist" do
+      it "raises RecordNotFound" do
+        stub_request(:put, %r[/v1]).
+            to_return(read_fixture("templates_records/notfound.http"))
+
+        expect {
+          subject.update_record(1, 2, {})
+        }.to raise_error(Dnsimple::RecordNotFound)
+      end
+    end
+  end
+
+  describe "#delete_record" do
+    before do
+      stub_request(:delete, %r[/v1/templates/.+/records/.+$]).
+          to_return(read_fixture("templates_records/delete/success.http"))
+    end
+
+    it "builds the correct request" do
+      subject.delete_record(1, 2)
+
+      expect(WebMock).to have_requested(:delete, "https://api.zone/v1/templates/1/records/2").
+                             with(headers: { 'Accept' => 'application/json' })
+    end
+
+    it "returns nothing" do
+      result = subject.delete_record(1, 2)
+
+      expect(result).to be_truthy
+    end
+
+    it "supports HTTP 204" do
+      stub_request(:delete, %r[/v1]).
+          to_return(read_fixture("templates_records/delete/success-204.http"))
+
+      result = subject.delete_record(1, 2)
+
+      expect(result).to be_truthy
+    end
+
+    context "when something does not exist" do
+      it "raises RecordNotFound" do
+        stub_request(:delete, %r[/v1]).
+            to_return(read_fixture("templates_records/notfound.http"))
+
+        expect {
+          subject.delete_record(1, 2)
+        }.to raise_error(Dnsimple::RecordNotFound)
+      end
+    end
+  end
+
+end

data/spec/dnsimple/client/users_service_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+describe Dnsimple::Client, ".users" do
+
+  subject { described_class.new(api_endpoint: "https://api.zone", username: "user", api_token: "token").users }
+
+
+  describe "#user" do
+    before do
+      stub_request(:get, %r[/v1/user]).
+          to_return(read_fixture("users/user/success.http"))
+    end
+
+    it "builds the correct request" do
+      subject.user
+
+      expect(WebMock).to have_requested(:get, "https://api.zone/v1/user").
+                             with(headers: { 'Accept' => 'application/json' })
+    end
+
+    it "returns the user" do
+      result = subject.user
+
+      expect(result).to be_a(Dnsimple::Struct::User)
+      expect(result.id).to eq(1)
+      expect(result.email).to eq("example@example.com")
+      expect(result.api_token).to eq("api-token")
+      expect(result.domain_count).to eq(32)
+      expect(result.domain_limit).to eq(1000)
+      expect(result.login_count).to eq(2)
+      expect(result.failed_login_count).to eq(1)
+      expect(result.created_at).to eq("2011-03-17T21:30:25.731Z")
+      expect(result.updated_at).to eq("2014-12-13T13:52:08.343Z")
+    end
+  end
+
+  describe "#exchange_token" do
+    before do
+      stub_request(:get, %r[/v1/user]).
+          to_return(read_fixture("2fa/exchange-token.http"))
+    end
+
+    it "builds the correct request" do
+      subject.exchange_token("123456")
+
+      expect(WebMock).to have_requested(:get, "https://api.zone/v1/user").
+                         with(headers: { "X-Dnsimple-Otp" => "123456" })
+    end
+
+    it "returns the exchange_token" do
+      result = subject.exchange_token("123456")
+
+      expect(result).to eq("0c622716aaa64124219963075bc1c870")
+    end
+
+    context "when the OTP token is invalid" do
+      before do
+        stub_request(:get, %r[/v1/user]).
+            to_return(read_fixture("2fa/error-badtoken.http"))
+      end
+
+      it "raises an AuthenticationFailed" do
+        expect {
+          subject.exchange_token("invalid-token")
+        }.to raise_error(Dnsimple::AuthenticationFailed, "Bad OTP token")
+      end
+    end
+  end
+
+end

data/spec/dnsimple/client_spec.rb

@@ -2,152 +2,161 @@ require 'spec_helper'
 
 describe Dnsimple::Client do
 
-  let(:klass) { described_class }
-  let(:response) { stub('response', :code => 200) }
-
-  before do
-    @_username  = described_class.username
-    @_password  = described_class.password
-    @_api_token = described_class.api_token
-    @_base_uri  = described_class.base_uri
-  end
-
-  after do
-    described_class.username   = @_username
-    described_class.password   = @_password
-    described_class.api_token  = @_api_token
-    described_class.base_uri   = @_base_uri
-  end
+  describe "initialization" do
+    it "accepts :api_endpoint option" do
+      subject = described_class.new(api_endpoint: "https://api.example.com/")
+      expect(subject.api_endpoint).to eq("https://api.example.com/")
+    end
 
-  [:get, :post, :put, :delete].each do |method|
-    describe ".#{method}" do
-      it "delegates to .request" do
-        described_class.expects(:request).with(method, '/domains', { :foo => 'bar' })
-        described_class.send(method, '/domains', { :foo => 'bar' })
-      end
+    it "normalizes :api_endpoint trailing slash" do
+      subject = described_class.new(api_endpoint: "https://api.example.com/missing/slash")
+      expect(subject.api_endpoint).to eq("https://api.example.com/missing/slash/")
     end
-  end
 
-  describe ".request" do
-    before do
-      [:username, :password, :exchange_token, :api_token, :domain_api_token].each do |attribute|
-        described_class.send("#{attribute}=", nil)
-      end
+    it "defaults :api_endpoint to production API" do
+      subject = described_class.new
+      expect(subject.api_endpoint).to eq("https://api.dnsimple.com/")
     end
+  end
 
+  describe "authentication" do
     it "uses HTTP authentication if there's a password provided" do
-      described_class.username   = 'user'
-      described_class.password   = 'pass'
-      described_class.base_uri   = 'https://api.example.com/'
+      stub_request(:any, %r[/test])
 
-      HTTParty.expects(:get).
-        with('https://api.example.com/domains', has_entries(:basic_auth => { :username => 'user', :password => 'pass' })).
-        returns(response)
+      subject = described_class.new(username: "user", password: "pass")
+      subject.request(:get, "test", {})
 
-      described_class.request(:get, '/domains', {})
+      expect(WebMock).to have_requested(:get, "https://user:pass@api.dnsimple.com/test")
     end
 
     it "uses header authentication if there's a domain api token provided" do
-      described_class.domain_api_token  = 'domaintoken'
-      described_class.base_uri   = 'https://api.example.com/'
+      stub_request(:any, %r[/test])
 
-      HTTParty.expects(:get).
-        with('https://api.example.com/domains', has_entries(:headers => has_entries({ 'X-DNSimple-Domain-Token' => 'domaintoken' }))).
-        returns(response)
+      subject = described_class.new(domain_api_token: "domaintoken")
+      subject.request(:get, "test", {})
 
-      described_class.request(:get, '/domains', {})
+      expect(WebMock).to have_requested(:get, "https://api.dnsimple.com/test").
+                         with { |req| req.headers["X-Dnsimple-Domain-Token"] == "domaintoken" }
     end
 
     it "uses header authentication if there's an api token provided" do
-      described_class.username   = 'user'
-      described_class.api_token  = 'token'
-      described_class.base_uri   = 'https://api.example.com/'
+      stub_request(:any, %r[/test])
 
-      HTTParty.expects(:get).
-        with('https://api.example.com/domains', has_entries(:headers => has_entries({ 'X-DNSimple-Token' => 'user:token' }))).
-        returns(response)
+      subject = described_class.new(username: "user", api_token: "token")
+      subject.request(:get, "test", {})
 
-      described_class.request(:get, '/domains', {})
+      expect(WebMock).to have_requested(:get, "https://api.dnsimple.com/test").
+                         with { |req| req.headers["X-Dnsimple-Token"] == "user:token" }
     end
 
     it "uses HTTP authentication via exchange token if there's an exchange token provided" do
-      described_class.username = 'user'
-      described_class.password = 'pass'
-      described_class.exchange_token = 'exchange-token'
-      described_class.base_uri = 'https://api.example.com/'
+      stub_request(:any, %r[/test])
 
-      HTTParty.expects(:get).
-          with('https://api.example.com/domains', has_entries(:basic_auth => { :username => 'exchange-token', :password => 'x-2fa-basic' })).
-          returns(response)
+      subject = described_class.new(username: "user", password: "pass", exchange_token: "exchange-token")
+      subject.request(:get, "test", {})
 
-      described_class.request(:get, '/domains', {})
+      expect(WebMock).to have_requested(:get, "https://exchange-token:x-2fa-basic@api.dnsimple.com/test")
     end
 
     it "raises an error if there's no password or api token provided" do
-      described_class.username   = 'user'
-      described_class.base_uri   = 'https://api.example.com/'
+      subject = described_class.new(username: "user")
 
       expect {
-        described_class.request(:get, '/domains', {})
+        subject.request(:get, "test", {})
       }.to raise_error(Dnsimple::Error, 'A password or API token is required for all API requests.')
     end
 
-    it "adds a custom user-agent" do
-      described_class.api_token  = 'token'
+    context "when 2FA is required" do
+      subject { described_class.new(username: "user", password: "pass") }
 
-      HTTParty.expects(:get).
-        with(is_a(String), has_entries(:headers => has_entries({ 'User-Agent' => "dnsimple-ruby/#{Dnsimple::VERSION}" }))).
-        returns(response)
+      before do
+        stub_request(:any, %r[/test]).
+            to_return(read_fixture("2fa/error-required.http"))
+      end
 
-      described_class.request(:get, '/foo', {})
+      it "raises a TwoFactorAuthenticationRequired error" do
+        expect {
+          subject.request(:get, "test", {})
+        }.to raise_error(Dnsimple::TwoFactorAuthenticationRequired)
+      end
     end
+  end
 
-    it "performs a request" do
-      described_class.username = 'user'
-      described_class.password = 'pass'
-
-      HTTParty.expects(:get).
-        with("#{described_class.base_uri}/foo",
-          :format => :json,
-          :basic_auth => { :username => described_class.username, :password => described_class.password },
-          :headers => { 'Accept' => 'application/json', 'User-Agent' => "dnsimple-ruby/#{Dnsimple::VERSION}" }
-        ).
-        returns(response)
-
-      described_class.request(:get, '/foo', {})
+  describe "#get" do
+    it "delegates to #request" do
+      expect(subject).to receive(:request).with(:get, "path", { foo: "bar" }).and_return(:returned)
+      expect(subject.get("path", foo: "bar")).to eq(:returned)
     end
   end
 
+  describe "#post" do
+    it "delegates to #request" do
+      expect(subject).to receive(:request).with(:post, "path", { foo: "bar" }).and_return(:returned)
+      expect(subject.post("path", foo: "bar")).to eq(:returned)
+    end
+  end
 
-  describe ".base_uri" do
-    it "returns the qualified API uri" do
-      klass.base_uri = "http://api.dnsimple.com"
-      expect(klass.base_uri).to eq("http://api.dnsimple.com")
+  describe "#put" do
+    it "delegates to #request" do
+      expect(subject).to receive(:request).with(:put, "path", { foo: "bar" }).and_return(:returned)
+      expect(subject.put("path", foo: "bar")).to eq(:returned)
     end
   end
 
-  describe ".base_uri=" do
-    it "sets the base_uri" do
-      klass.base_uri = "http://api1.dnsimple.com/"
-      expect(klass.base_uri).to eq("http://api1.dnsimple.com")
-      klass.base_uri = "http://api2.dnsimple.com"
-      expect(klass.base_uri).to eq("http://api2.dnsimple.com")
+  describe "#delete" do
+    it "delegates to #request" do
+      expect(subject).to receive(:request).with(:delete, "path", { foo: "bar" }).and_return(:returned)
+      expect(subject.delete("path", foo: "bar")).to eq(:returned)
     end
   end
 
+  describe "#request" do
+    subject { described_class.new(username: "user", password: "pass") }
 
-  describe "authentication" do
-    context "when 2FA is required" do
-      before do
-        stub_request(:get, %r[/foo]).
-            to_return(read_fixture("2fa/error-required.http"))
-      end
+    it "performs a request" do
+      stub_request(:get, %r[/foo])
 
-      it "raises a TwoFactorAuthenticationRequired error" do
-        expect {
-          described_class.get('/foo', {})
-        }.to raise_error(Dnsimple::TwoFactorAuthenticationRequired)
-      end
+      subject.request(:get, 'foo', {})
+
+      expect(WebMock).to have_requested(:get, "https://user:pass@api.dnsimple.com/foo").
+                         with(headers: { 'Accept' => 'application/json', 'User-Agent' => "dnsimple-ruby/#{Dnsimple::VERSION}" })
+    end
+
+    it "delegates to HTTParty" do
+      stub_request(:get, %r[/foo])
+
+      expect(HTTParty).to receive(:get).
+                          with("#{subject.api_endpoint}foo",
+                               format: :json,
+                               basic_auth: { username: "user", password: "pass" },
+                               headers: { 'Accept' => 'application/json', 'User-Agent' => "dnsimple-ruby/#{Dnsimple::VERSION}" }
+                          ).
+                          and_return(double('response', code: 200))
+
+      subject.request(:get, 'foo', {})
+    end
+
+    it "properly extracts options from data" do
+      expect(HTTParty).to receive(:put).
+                          with("#{subject.api_endpoint}foo",
+                               format: :json,
+                               body: { something: "else" },
+                               query: { foo: "bar" },
+                               basic_auth: { username: "user", password: "pass" },
+                               headers: { 'Accept' => 'application/json', 'User-Agent' => "dnsimple-ruby/#{Dnsimple::VERSION}", "Custom" => "Header" }
+                          ).
+                          and_return(double('response', code: 200))
+
+      subject.request(:put, 'foo', { something: "else", query: { foo: "bar" }, headers: { "Custom" => "Header" } })
+    end
+
+    it "raises RequestError in case of error" do
+      stub_request(:get, %r[/foo]).
+          to_return(status: [500, "Internal Server Error"])
+
+      expect {
+        subject.request(:get, "foo", {})
+      }.to raise_error(Dnsimple::RequestError, "500")
     end
   end