dnsimple 2.0.0.a

data/lib/dnsimple/service.rb

@@ -0,0 +1,42 @@
+module DNSimple
+
+  # Represents a service that can be applied to a domain.
+  class Service < Base
+
+    attr_accessor :id
+
+    attr_accessor :name
+
+    attr_accessor :short_name
+
+    attr_accessor :description
+
+    # Find a service by its ID or short name
+    def self.find(id_or_short_name, options={})
+      id = id_or_short_name
+      response = DNSimple::Client.get("/v1/services/#{id}", options)
+
+      case response.code
+      when 200
+        new(response["service"])
+      when 404
+        raise RecordNotFound, "Could not find service #{id}"
+      else
+        raise RequestError.new("Error finding service", response)
+      end
+    end
+
+    # Get all of the services that can be applied to a domain
+    def self.all(options={})
+      response = DNSimple::Client.get("/v1/services", options)
+
+      case response.code
+      when 200
+        response.map { |r| new(r["service"]) }
+      else
+        raise RequestError.new("Error listing services", response)
+      end
+    end
+
+  end
+end

data/lib/dnsimple/template.rb

@@ -0,0 +1,63 @@
+module DNSimple
+  class Template < Base
+
+    attr_accessor :id
+    attr_accessor :name
+    attr_accessor :short_name
+    attr_accessor :description
+
+
+    def self.create(name, short_name, description=nil, options={})
+      template_hash = {
+        :name        => name,
+        :short_name  => short_name,
+        :description => description
+      }
+
+      options.merge!(:body => {:dns_template => template_hash})
+
+      response = DNSimple::Client.post("/v1/templates", options)
+
+      case response.code
+      when 201
+        new(response["dns_template"])
+      else
+        raise RequestError.new("Error creating template", response)
+      end
+    end
+
+    def self.find(id_or_short_name, options={})
+      id = id_or_short_name
+      response = DNSimple::Client.get("/v1/templates/#{id}", options)
+
+      case response.code
+      when 200
+        new(response["dns_template"])
+      when 404
+        raise RecordNotFound, "Could not find template #{id}"
+      else
+        raise RequestError.new("Error finding template", response)
+      end
+    end
+
+    def self.all(options={})
+      response = DNSimple::Client.get("/v1/templates", options)
+
+      case response.code
+      when 200
+        response.map { |r| new(r["dns_template"]) }
+      else
+        raise RequestError.new("Error listing templates", response)
+      end
+    end
+
+
+    # Delete the template from DNSimple.
+    # WARNING: this cannot be undone.
+    def delete(options={})
+      DNSimple::Client.delete("/v1/templates/#{id}", options)
+    end
+    alias :destroy :delete
+
+  end
+end

data/lib/dnsimple/template_record.rb

@@ -0,0 +1,80 @@
+module DNSimple
+
+  # A single record in a template.
+  class TemplateRecord < Base
+
+    # The id of the template record
+    attr_accessor :id
+
+    # The template the record belongs to
+    attr_accessor :template
+
+    # The name the record points to. This may be blank.
+    attr_accessor :name
+
+    # The content for the record.
+    attr_accessor :content
+
+    # The record type
+    attr_accessor :record_type
+
+    # The time-to-live
+    attr_accessor :ttl
+
+    # The priority (only for MX records)
+    attr_accessor :prio
+
+    def delete(options={})
+      DNSimple::Client.delete("/v1/templates/#{template.id}/template_records/#{id}", options)
+    end
+    alias :destroy :delete
+
+    def self.create(short_name, name, record_type, content, options={})
+      template = DNSimple::Template.find(short_name)
+
+      record_hash = {:name => name, :record_type => record_type, :content => content}
+      record_hash[:ttl] = options.delete(:ttl) || 3600
+      record_hash[:prio] = options.delete(:prio) || ''
+
+      options.merge!({:query => {:dns_template_record => record_hash}})
+
+      response = DNSimple::Client.post("/v1/templates/#{template.id}/template_records", options)
+
+      case response.code
+      when 201
+        new({:template => template}.merge(response["dns_template_record"]))
+      else
+        raise RequestError.new("Error creating template record", response)
+      end
+    end
+
+    def self.find(short_name, id, options={})
+      template = DNSimple::Template.find(short_name)
+      response = DNSimple::Client.get("/v1/templates/#{template.id}/template_records/#{id}", options)
+
+      case response.code
+      when 200
+        new({:template => template}.merge(response["dns_template_record"]))
+      when 404
+        raise RecordNotFound, "Could not find template record #{id} for template #{template.id}"
+      else
+        raise RequestError.new("Error finding template record", response)
+      end
+    end
+
+    # Get all of the template records for the template with the
+    # given short name.
+    def self.all(short_name, options={})
+      template = DNSimple::Template.find(short_name)
+      response = DNSimple::Client.get("/v1/templates/#{template.id}/template_records", options)
+
+      case response.code
+      when 200
+        response.map { |r| new({:template => template}.merge(r["dns_template_record"])) }
+      else
+        raise RequestError.new("Error listing template records", response)
+      end
+    end
+
+  end
+end

data/lib/dnsimple/transfer_order.rb

@@ -0,0 +1,34 @@
+module DNSimple
+
+  # Represents a transfer order.
+  class TransferOrder < Base
+
+    attr_accessor :id
+
+    attr_accessor :status
+
+    def self.create(name, authinfo='', registrant={}, extended_attributes={}, options={})
+      body = {:domain => {:name => name}, :transfer_order => {:authinfo => authinfo}}
+
+      if registrant[:id]
+        body[:domain][:registrant_id] = registrant[:id]
+      else
+        body.merge!(:contact => Contact.resolve_attributes(registrant))
+      end
+
+      body.merge!(:extended_attribute => extended_attributes)
+
+      options.merge!({:body => body})
+
+      response = DNSimple::Client.post("/v1/domain_transfers", options)
+
+      case response.code
+      when 201
+        new(response["transfer_order"])
+      else
+        raise RequestError.new("Error creating transfer order", response)
+      end
+    end
+
+  end
+end

data/lib/dnsimple/user.rb

@@ -0,0 +1,26 @@
+module DNSimple
+  class User < Base
+
+    attr_accessor :id
+    attr_accessor :email
+    attr_accessor :domain_count
+    attr_accessor :domain_limit
+    attr_accessor :login_count
+    attr_accessor :failed_login_count
+    attr_accessor :created_at
+    attr_accessor :updated_at
+
+
+    def self.me
+      response = DNSimple::Client.get("/v1/user")
+
+      case response.code
+      when 200
+        new(response["user"])
+      else
+        raise RequestError.new("Error finding account", response)
+      end
+    end
+
+  end
+end

data/lib/dnsimple/version.rb

@@ -0,0 +1,3 @@
+module DNSimple
+  VERSION = '2.0.0.a'
+end

data/spec/ci/.dnsimple.test

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

data/spec/dnsimple/certificate_spec.rb

@@ -0,0 +1,56 @@
+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).to eq(domain)
+        expect(result.name).to eq("www")
+        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.available_approver_emails).to be_nil
+        expect(result.certificate_status).to be_nil
+      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

@@ -0,0 +1,107 @@
+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
+    it "uses HTTP authentication if there's a password provided" do
+      described_class.username   = 'user'
+      described_class.password   = 'pass'
+      described_class.api_token  = nil
+      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 an api token provided" do
+      described_class.username   = 'user'
+      described_class.password   = nil
+      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 "raises an error if there's no password or api token provided" do
+      described_class.username   = 'user'
+      described_class.password   = nil
+      described_class.api_token  = nil
+      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
+      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
+      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
+
+end

data/spec/dnsimple/contact_spec.rb

@@ -0,0 +1,45 @@
+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