dnsimple-ruby 1.7.1 → 2.0.0

data/lib/dnsimple/version.rb

@@ -1,3 +0,0 @@
-module DNSimple
-  VERSION = '1.7.1'
-end

data/spec/ci/.dnsimple.test

@@ -1,3 +0,0 @@
-username: username
-password: password
-base_uri: https://api.ci.dnsimple.com

data/spec/commands/certificate_purchase_spec.rb

@@ -1,25 +0,0 @@
-require 'spec_helper'
-require 'dnsimple/certificate'
-require 'dnsimple/commands/certificate_purchase'
-
-describe DNSimple::Commands::CertificatePurchase do
-  let(:domain_name) { 'example.com' }
-  let(:domain)      { stub('domain') }
-  let(:contact)     { stub('contact') }
-
-  context "with one argument" do
-    before :each do
-      DNSimple::Domain.stubs(:find).returns(domain)
-      DNSimple::Contact.stubs(:find).returns(contact)
-    end
-
-    it "purchases the certificate" do
-      DNSimple::Certificate.expects(:purchase).
-        with(domain, 'certname', contact).
-        returns(stub("certificate", :fqdn => domain_name))
-
-      DNSimple::Commands::CertificatePurchase.new.
-        execute([domain_name, 'certname', stub('contact id')])
-    end
-  end
-end

data/spec/commands/certificate_submit_spec.rb

@@ -1,18 +0,0 @@
-require 'spec_helper'
-require 'dnsimple/commands/certificate_submit'
-
-describe DNSimple::Commands::CertificateSubmit do
-  let(:domain) { DNSimple::Domain.new(:name => domain_name) }
-  let(:domain_name) { 'example.com' }
-  let(:name) { 'www' }
-  let(:certificate) { DNSimple::Certificate.new(:id => certificate_id, :domain => domain) }
-  let(:certificate_id) { 1 }
-  let(:approver_email) { 'admin@example.com' }
-
-  it "submits the certificate" do
-    DNSimple::Domain.stubs(:find).with(domain_name).returns(domain)
-    DNSimple::Certificate.expects(:find).with(domain, certificate_id).returns(certificate)
-    certificate.expects(:submit).with(approver_email)
-    DNSimple::Commands::CertificateSubmit.new.execute([domain_name, certificate_id, approver_email])
-  end
-end

data/spec/commands/record_create_spec.rb

@@ -1,23 +0,0 @@
-require 'spec_helper'
-require 'dnsimple/domain'
-require 'dnsimple/record'
-require 'dnsimple/commands/record_create'
-
-describe DNSimple::Commands::RecordCreate do
-  let(:domain_name) { 'example.com' }
-  let(:record_name) { 'www' }
-  let(:record_type) { 'CNAME' }
-  let(:ttl) { "3600" }
-
-  context "with one argument" do
-    it "purchases the certificate" do
-      domain_stub = stub("domain", :name => domain_name)
-      record_stub = stub("record", :id => 1, :record_type => record_type)
-      DNSimple::Domain.expects(:find).with(domain_name).returns(domain_stub)
-      DNSimple::Record.expects(:create).with(domain_stub, record_name, record_type, domain_name, :ttl => ttl, :prio => nil).returns(record_stub)
-
-      DNSimple::Commands::RecordCreate.new.execute([domain_name, record_name, record_type, domain_name, ttl])
-    end
-  end
-end
-

data/spec/commands/record_list_spec.rb

@@ -1,23 +0,0 @@
-require 'spec_helper'
-require 'dnsimple/commands/record_list'
-
-describe DNSimple::Commands::RecordList do
-  before do
-    DNSimple::Record.expects(:all).with(instance_of(DNSimple::Domain)).returns(records)
-  end
-
-  let(:records) { [ record ] }
-  let(:record) { stub(:ttl => ttl, :id => id, :record_type => record_type, :name => name, :domain => domain, :content => content) }
-
-  let(:ttl) { 'ttl' }
-  let(:id) { 'id' }
-  let(:record_type) { 'A' }
-  let(:name) { 'name' }
-  let(:content) { 'content' }
-
-  let(:args) { [ domain_name ] }
-  let(:domain_name) { 'example.com' }
-  let(:domain) { DNSimple::Domain.new(:name => domain_name) }
-
-end
-

data/spec/commands/service_add_spec.rb

@@ -1,20 +0,0 @@
-require 'spec_helper'
-require 'dnsimple/commands/service_add'
-
-describe DNSimple::Commands::ServiceAdd do
-  let(:domain_name) { 'example.com' }
-  let(:short_name) { 'service-name' }
-
-  let(:domain) { DNSimple::Domain.new(:name => domain_name) }
-  let(:service) { stub("service", :name => "Service") }
-
-  before do
-    DNSimple::Domain.expects(:find).with(domain_name).returns(domain)
-    DNSimple::Service.expects(:find).with(short_name).returns(service)
-  end
-
-  it "adds a service to a domain" do
-    domain.expects(:add_service).with(short_name)
-    DNSimple::Commands::ServiceAdd.new.execute([domain_name, short_name])
-  end
-end

data/spec/dnsimple/certificate_spec.rb

@@ -1,59 +0,0 @@
-require 'spec_helper'
-
-describe DNSimple::Certificate do
-
-  let(:domain) { DNSimple::Domain.new(:name => "example.com") }
-
-
-  describe ".find" do
-    before do
-      stub_request(:get, %r[/v1/domains/example.com/certificates/2]).
-          to_return(read_fixture("certificates/show/success.http"))
-    end
-
-    it "builds the correct request" do
-      described_class.find(domain, "2")
-
-      expect(WebMock).to have_requested(:get, "https://#{CONFIG['username']}:#{CONFIG['password']}@#{CONFIG['host']}/v1/domains/example.com/certificates/2").
-          with(:headers => { 'Accept' => 'application/json' })
-    end
-
-    context "when the certificate exists" do
-      it "returns the certificate" do
-        result = described_class.find(domain, "2")
-
-        expect(result.id).to eq(4576)
-        expect(result.domain_id).to eq(79569)
-        expect(result.contact_id).to eq(11549)
-        expect(result.name).to eq("www")
-        expect(result.state).to eq("cancelled")
-        expect(result.csr).to eq("-----BEGIN NEW CERTIFICATE REQUEST-----\nRHr2akB4KMba6FMAsvlStnO/2ika16hNx+d3smPNsER+HA==\n-----END NEW CERTIFICATE REQUEST-----\n")
-        expect(result.ssl_certificate).to eq("-----BEGIN CERTIFICATE-----\nXwTkw5UCPpaVyUYcwHlvaprOe9ZbwIyEHm2AT1rW+70=\n-----END CERTIFICATE-----\n")
-        expect(result.private_key).to eq("-----BEGIN RSA PRIVATE KEY-----\nUeXbFi7o+nuPfRhpBFQEKwacKFc3Hnc1hH6UsnC0KY25cUif7yz38A==\n-----END RSA PRIVATE KEY-----\n")
-        expect(result.approver_email).to eq("example@example.net")
-        expect(result.created_at).to eq("2013-09-17T21:54:42Z")
-        expect(result.updated_at).to eq("2013-09-17T22:25:36Z")
-        expect(result.configured_at).to eq("2013-09-17T22:25:01Z")
-        expect(result.expires_on).to eq("2014-09-17")
-
-        expect(result.domain).to eq(domain)
-      end
-    end
-  end
-
-
-  describe "#fqdn" do
-    it "joins the name and domain name" do
-      certificate = described_class.new(:name => 'www')
-      certificate.domain = domain
-      expect(certificate.fqdn).to eq("www.#{domain.name}")
-    end
-
-    it "strips blank parts from name" do
-      certificate = described_class.new(:name => '')
-      certificate.domain = domain
-      expect(certificate.fqdn).to eq(domain.name)
-    end
-  end
-
-end

data/spec/dnsimple/client_spec.rb

@@ -1,154 +0,0 @@
-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
-
-  [: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
-    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
-    end
-
-    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/'
-
-      HTTParty.expects(:get).
-        with('https://api.example.com/domains', has_entries(:basic_auth => { :username => 'user', :password => 'pass' })).
-        returns(response)
-
-      described_class.request(:get, '/domains', {})
-    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/'
-
-      HTTParty.expects(:get).
-        with('https://api.example.com/domains', has_entries(:headers => has_entries({ 'X-DNSimple-Domain-Token' => 'domaintoken' }))).
-        returns(response)
-
-      described_class.request(:get, '/domains', {})
-    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/'
-
-      HTTParty.expects(:get).
-        with('https://api.example.com/domains', has_entries(:headers => has_entries({ 'X-DNSimple-Token' => 'user:token' }))).
-        returns(response)
-
-      described_class.request(:get, '/domains', {})
-    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/'
-
-      HTTParty.expects(:get).
-          with('https://api.example.com/domains', has_entries(:basic_auth => { :username => 'exchange-token', :password => 'x-2fa-basic' })).
-          returns(response)
-
-      described_class.request(:get, '/domains', {})
-    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/'
-
-      expect {
-        described_class.request(:get, '/domains', {})
-      }.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'
-
-      HTTParty.expects(:get).
-        with(is_a(String), has_entries(:headers => has_entries({ 'User-Agent' => "dnsimple-ruby/#{DNSimple::VERSION}" }))).
-        returns(response)
-
-      described_class.request(:get, '/foo', {})
-    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', {})
-    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")
-    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")
-    end
-  end
-
-
-  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 "raises a TwoFactorAuthenticationRequired error" do
-        expect {
-          described_class.get('/foo', {})
-        }.to raise_error(DNSimple::TwoFactorAuthenticationRequired)
-      end
-    end
-  end
-
-end

data/spec/dnsimple/contact_spec.rb

@@ -1,45 +0,0 @@
-require 'spec_helper'
-
-describe DNSimple::Contact do
-
-  describe ".find" do
-    before do
-      stub_request(:get, %r[/v1/contacts/2]).
-          to_return(read_fixture("contacts/show/success.http"))
-    end
-
-    it "builds the correct request" do
-      described_class.find("2")
-
-      expect(WebMock).to have_requested(:get, "https://#{CONFIG['username']}:#{CONFIG['password']}@#{CONFIG['host']}/v1/contacts/2").
-          with(:headers => { 'Accept' => 'application/json' })
-    end
-
-    context "when the contact exists" do
-      it "returns the contact" do
-        result = described_class.find("2")
-
-        expect(result).to be_a(described_class)
-        expect(result.id).to eq(2)
-        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("example@example.com")
-        expect(result.phone).to eq("+1 111 000000")
-        expect(result.fax).to eq("+1 222 000000")
-        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("2013-11-08T17:23:15Z")
-        expect(result.updated_at).to eq("2013-11-08T17:23:15Z")
-
-        expect(result.phone_ext).to be_nil
-      end
-    end
-  end
-
-end

data/spec/dnsimple/domain_spec.rb

@@ -1,133 +0,0 @@
-require 'spec_helper'
-
-describe DNSimple::Domain do
-
-  let(:contact_id) { 1001 }
-
-  describe ".find" do
-    before do
-      stub_request(:get, %r[/v1/domains/example.com]).
-          to_return(read_fixture("domains/show/success.http"))
-    end
-
-    it "builds the correct request" do
-      described_class.find("example.com")
-
-      expect(WebMock).to have_requested(:get, "https://#{CONFIG['username']}:#{CONFIG['password']}@#{CONFIG['host']}/v1/domains/example.com").
-          with(:headers => { 'Accept' => 'application/json' })
-    end
-
-    context "when the domain exists" do
-      it "returns the domain" do
-        result = described_class.find("example.com")
-
-        expect(result).to be_a(described_class)
-        expect(result.id).to eq(6)
-        expect(result.name).to eq("test-1383931357.com")
-        expect(result.expires_on).to eq('2015-11-08')
-        expect(result.created_at).to eq("2013-11-08T17:22:48Z")
-        expect(result.updated_at).to eq("2014-01-14T18:27:04Z")
-        expect(result.state).to eq("registered")
-        expect(result.registrant_id).to eq(2)
-        expect(result.user_id).to eq(2)
-        expect(result.lockable).to eq(true)
-        expect(result.auto_renew).to eq(true)
-        expect(result.whois_protected).to eq(false)
-
-        expect(result.name_server_status).to be_nil
-      end
-    end
-  end
-
-  describe "#enable_auto_renew" do
-    let(:domain) { described_class.new(:name => 'example.com', :auto_renew => false) }
-
-    context "when response is not 200" do
-      before do
-        stub_request(:post, %r[/v1/domains/example.com/auto_renewal]).
-            to_return(read_fixture("domains/auto_renewal_enable/notfound.http"))
-      end
-
-      it "raises a RequestError" do
-        expect { domain.enable_auto_renew }.to raise_error(DNSimple::RequestError)
-      end
-    end
-
-    context "when auto_renew is true" do
-      let(:domain) { described_class.new(:name => 'example.com', :auto_renew => true) }
-
-      it "does not send a web request" do
-        domain.enable_auto_renew
-        expect(WebMock).to have_not_been_made
-      end
-    end
-
-    context "when auto_renew is false" do
-      let(:domain) { described_class.new(:name => 'example.com', :auto_renew => false) }
-
-      before do
-        stub_request(:post, %r[/v1/domains/example.com/auto_renewal]).
-            to_return(read_fixture("domains/auto_renewal_enable/success.http"))
-      end
-
-      it "builds the correct request to enable auto_renew" do
-        domain.enable_auto_renew
-
-        expect(WebMock).to have_requested(:post, "https://#{CONFIG['username']}:#{CONFIG['password']}@#{CONFIG['host']}/v1/domains/example.com/auto_renewal").
-            with(:headers => { 'Accept' => 'application/json' })
-      end
-
-      it "sets auto_renew to true on the domain" do
-        domain.enable_auto_renew
-        expect(domain.auto_renew).to be_truthy
-      end
-    end
-
-  end
-
-  describe "#disable_auto_renew" do
-    let(:domain) { described_class.new(:name => 'example.com', :auto_renew => true) }
-
-    context "when response is not 200" do
-      before do
-        stub_request(:delete, %r[/v1/domains/example.com/auto_renewal]).
-            to_return(read_fixture("domains/auto_renewal_disable/notfound.http"))
-      end
-
-      it "raises a RequestError" do
-        expect { domain.disable_auto_renew }.to raise_error(DNSimple::RequestError)
-      end
-    end
-
-    context "when auto_renew is false" do
-      let(:domain) { described_class.new(:name => 'example.com', :auto_renew => false) }
-
-      it "does not send a web request" do
-        domain.disable_auto_renew
-        expect(WebMock).to have_not_been_made
-      end
-    end
-
-    context "when auto_renew is true" do
-      let(:domain) { described_class.new(:name => 'example.com', :auto_renew => true) }
-
-      before do
-        stub_request(:delete, %r[/v1/domains/example.com/auto_renewal]).
-            to_return(read_fixture("domains/auto_renewal_disable/success.http"))
-      end
-
-      it "builds the correct request to disable auto_renew" do
-        domain.disable_auto_renew
-
-        expect(WebMock).to have_requested(:delete, "https://#{CONFIG['username']}:#{CONFIG['password']}@#{CONFIG['host']}/v1/domains/example.com/auto_renewal").
-            with(:headers => { 'Accept' => 'application/json' })
-      end
-
-      it "sets auto_renew to false on the domain" do
-        domain.disable_auto_renew
-        expect(domain.auto_renew).to be_falsey
-      end
-    end
-
-  end
-end