dnsimple-ruby 1.3.2 → 1.4.0

data/lib/dnsimple/template_record.rb

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

@@ -1,28 +1,34 @@
-class DNSimple::TransferOrder # Class representing a transfer order in DNSimple
-  attr_accessor :id
+module DNSimple
 
-  attr_accessor :status
+  # Represents a transfer order.
+  class TransferOrder < Base
 
-  def self.create(name, authinfo='', registrant={}, extended_attributes={}, options={})
-    body = {:domain => {:name => name}, :transfer_order => {:authinfo => authinfo}}
+    attr_accessor :id
 
-    if registrant[:id]
-      body[:domain][:registrant_id] = registrant[:id]
-    else
-      body.merge!(:contact => Contact.resolve_attributes(registrant))
-    end
+    attr_accessor :status
+
+    def self.create(name, authinfo='', registrant={}, extended_attributes={}, options={})
+      body = {:domain => {:name => name}, :transfer_order => {:authinfo => authinfo}}
 
-    body.merge!(:extended_attribute => extended_attributes)
+      if registrant[:id]
+        body[:domain][:registrant_id] = registrant[:id]
+      else
+        body.merge!(:contact => Contact.resolve_attributes(registrant))
+      end
 
-    options.merge!({:body => body})
+      body.merge!(:extended_attribute => extended_attributes)
 
-    response = DNSimple::Client.post 'domain_transfers.json', options
+      options.merge!({:body => body})
 
-    case response.code
-    when 201
-      return new(response["transfer_order"])
-    else
-      raise DNSimple::Error.new(name, response["errors"])
+      response = DNSimple::Client.post("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

@@ -1,30 +1,34 @@
-class DNSimple::User < DNSimple::Base
-  attr_accessor :id
+module DNSimple
+  class User < Base
 
-  attr_accessor :created_at
+    attr_accessor :id
 
-  attr_accessor :updated_at
+    attr_accessor :created_at
 
-  attr_accessor :email
+    attr_accessor :updated_at
 
-  attr_accessor :login_count
+    attr_accessor :email
 
-  attr_accessor :failed_login_count
+    attr_accessor :login_count
 
-  attr_accessor :domain_count
+    attr_accessor :failed_login_count
 
-  attr_accessor :domain_limit
+    attr_accessor :domain_count
 
-  def self.me(options={})
-    response = DNSimple::Client.get("users/me.json", options)
+    attr_accessor :domain_limit
 
-    case response.code
-    when 200
-      return new(response["user"])
-    when 404
-      raise DNSimple::UserNotFound, "Could not find user"
-    else
-      raise DNSimple::Error, "Error: #{response.code} #{response.message}"
+    def self.me(options={})
+      response = DNSimple::Client.get("users/me", options)
+
+      case response.code
+      when 200
+        new(response["user"])
+      when 404
+        raise RecordNotFound, "Could not find account with current credentials"
+      else
+        raise RequestError.new("Error finding account", response)
+      end
     end
+
   end
 end

data/lib/dnsimple/version.rb

@@ -1,3 +1,3 @@
 module DNSimple
-  VERSION = '1.3.2'
+  VERSION = '1.4.0'
 end

data/spec/README

@@ -6,5 +6,5 @@ Before running the DNSimple Ruby Client specifications, you must do the followin
 
 username: YOUR_USERNAME
 password: YOUR_PASSWORD
-site: https://test.dnsimple.com
+host: test.dnsimple.com
 

data/spec/ci/.dnsimple.test

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

data/spec/commands/{purchase_certificate_spec.rb → certificate_purchase_spec.rb}

@@ -1,9 +1,8 @@
 require 'spec_helper'
 require 'dnsimple/certificate'
-require 'dnsimple/commands/purchase_certificate'
+require 'dnsimple/commands/certificate_purchase'
 
-describe DNSimple::Commands::PurchaseCertificate do
-  let(:out)         { StringIO.new }
+describe DNSimple::Commands::CertificatePurchase do
   let(:domain_name) { 'example.com' }
   let(:domain)      { stub('domain') }
   let(:contact)     { stub('contact') }
@@ -19,7 +18,7 @@ describe DNSimple::Commands::PurchaseCertificate do
         with(domain, 'certname', contact).
         returns(stub("certificate", :fqdn => domain_name))
 
-      DNSimple::Commands::PurchaseCertificate.new(out).
+      DNSimple::Commands::CertificatePurchase.new.
         execute([domain_name, 'certname', stub('contact id')])
     end
   end

data/spec/commands/{submit_certificate_spec.rb → certificate_submit_spec.rb}

@@ -1,8 +1,7 @@
 require 'spec_helper'
-require 'dnsimple/commands/submit_certificate'
+require 'dnsimple/commands/certificate_submit'
 
-describe DNSimple::Commands::SubmitCertificate do
-  let(:out) { StringIO.new }
+describe DNSimple::Commands::CertificateSubmit do
   let(:domain) { DNSimple::Domain.new(:name => domain_name) }
   let(:domain_name) { 'example.com' }
   let(:name) { 'www' }
@@ -14,6 +13,6 @@ describe DNSimple::Commands::SubmitCertificate 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::SubmitCertificate.new(out).execute([domain_name, certificate_id, approver_email])
+    DNSimple::Commands::CertificateSubmit.new.execute([domain_name, certificate_id, approver_email])
   end
 end

data/spec/commands/{create_record_spec.rb → record_create_spec.rb}

@@ -1,14 +1,14 @@
 require 'spec_helper'
 require 'dnsimple/domain'
 require 'dnsimple/record'
-require 'dnsimple/commands/create_record'
+require 'dnsimple/commands/record_create'
 
-describe DNSimple::Commands::CreateRecord do
-  let(:out) { StringIO.new }
+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)
@@ -16,7 +16,7 @@ describe DNSimple::Commands::CreateRecord do
       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::CreateRecord.new(out).execute([domain_name, record_name, record_type, domain_name, ttl])
+      DNSimple::Commands::RecordCreate.new.execute([domain_name, record_name, record_type, domain_name, ttl])
     end
   end
 end

data/spec/commands/{list_records_spec.rb → records_list_spec.rb}

@@ -1,7 +1,7 @@
 require 'spec_helper'
-require 'dnsimple/commands/list_records'
+require 'dnsimple/commands/record_list'
 
-describe DNSimple::Commands::ListRecords do
+describe DNSimple::Commands::RecordList do
   before do
     DNSimple::Record.expects(:all).with(instance_of(DNSimple::Domain)).returns(records)
   end
@@ -18,17 +18,6 @@ describe DNSimple::Commands::ListRecords do
   let(:args) { [ domain_name ] }
   let(:domain_name) { 'example.com' }
   let(:domain) { DNSimple::Domain.new(:name => domain_name) }
-  let(:out) { StringIO.new }
 
-  it 'should retrieve all records and print them' do
-    described_class.new(out).execute(args)
-
-    out.string.should include(ttl)
-    out.string.should include(id)
-    out.string.should include(record_type)
-    out.string.should include(name)
-    out.string.should include(domain_name)
-    out.string.should include(content)
-  end
 end
 

data/spec/commands/{add_service_spec.rb → service_add_spec.rb}

@@ -1,12 +1,9 @@
 require 'spec_helper'
-require 'dnsimple/commands/add_service'
-
-describe DNSimple::Commands::AddService do
-  let(:out) { StringIO.new }
+require 'dnsimple/commands/service_add'
 
+describe DNSimple::Commands::ServiceAdd do
   let(:domain_name) { 'example.com' }
   let(:short_name) { 'service-name' }
-  let(:args) { [domain_name, short_name] }
 
   let(:domain) { DNSimple::Domain.new(:name => domain_name) }
   let(:service) { stub("service", :name => "Service") }
@@ -18,12 +15,6 @@ describe DNSimple::Commands::AddService do
 
   it "adds a service to a domain" do
     domain.expects(:add_service).with(short_name)
-    DNSimple::Commands::AddService.new(out).execute(args)
-  end
-
-  it "reports to the caller" do
-    domain.stubs(:add_service)
-    DNSimple::Commands::AddService.new(out).execute(args)
-    out.string.should eq("Added #{service.name} to #{domain_name}\n")
+    DNSimple::Commands::ServiceAdd.new.execute([domain_name, short_name])
   end
 end

data/spec/dnsimple/client_spec.rb

@@ -1,15 +1,21 @@
 require 'spec_helper'
 
 describe DNSimple::Client do
+
+  let(:klass) { described_class }
+
   before :each do
-    @username, @password, @api_token = DNSimple::Client.username,
-      DNSimple::Client.password, DNSimple::Client.api_token
+    @_username  = DNSimple::Client.username
+    @_password  = DNSimple::Client.password
+    @_api_token = DNSimple::Client.api_token
+    @_base_uri  = DNSimple::Client.base_uri
   end
 
-  after :each do
-    DNSimple::Client.username  = @username
-    DNSimple::Client.password  = @password
-    DNSimple::Client.api_token = @api_token
+  after do
+    DNSimple::Client.username   = @_username
+    DNSimple::Client.password   = @_password
+    DNSimple::Client.api_token  = @_api_token
+    DNSimple::Client.base_uri   = @_base_uri
   end
 
   [:get, :post, :put, :delete].each do |method|
@@ -17,12 +23,13 @@ describe DNSimple::Client do
       let(:response) { stub('response', :code => 200) }
 
       it "uses HTTP authentication if there's a password provided" do
-        DNSimple::Client.username  = 'user'
-        DNSimple::Client.password  = 'pass'
-        DNSimple::Client.api_token = nil
+        DNSimple::Client.username   = 'user'
+        DNSimple::Client.password   = 'pass'
+        DNSimple::Client.api_token  = nil
+        DNSimple::Client.base_uri   = 'https://test.example.com'
 
         HTTParty.expects(method).
-          with('http://localhost:3000/domains',
+          with('https://test.example.com/domains',
             :format => :json, :headers => {'Accept' => 'application/json'},
             :basic_auth => {:username => 'user', :password => 'pass'}).
           returns(response)
@@ -31,12 +38,13 @@ describe DNSimple::Client do
       end
 
       it "uses header authentication if there's an api token provided" do
-        DNSimple::Client.username  = 'user'
-        DNSimple::Client.password  = nil
-        DNSimple::Client.api_token = 'token'
+        DNSimple::Client.username   = 'user'
+        DNSimple::Client.password   = nil
+        DNSimple::Client.api_token  = 'token'
+        DNSimple::Client.base_uri   = 'https://test.example.com'
 
         HTTParty.expects(method).
-          with('http://localhost:3000/domains',
+          with('https://test.example.com/domains',
             :format => :json, :headers => {'Accept' => 'application/json',
             'X-DNSimple-Token' => 'user:token'}).
           returns(response)
@@ -45,14 +53,33 @@ describe DNSimple::Client do
       end
 
       it "raises an error if there's no password or api token provided" do
-        DNSimple::Client.username  = 'user'
-        DNSimple::Client.password  = nil
-        DNSimple::Client.api_token = nil
+        DNSimple::Client.username   = 'user'
+        DNSimple::Client.password   = nil
+        DNSimple::Client.api_token  = nil
+        DNSimple::Client.base_uri   = 'https://test.example.com'
 
         lambda {
           DNSimple::Client.send(method, 'domains')
-        }.should raise_error(RuntimeError, 'A password or API token is required for all API requests.')
+        }.should raise_error(DNSimple::Error, 'A password or API token is required for all API requests.')
       end
     end
   end
+
+
+  describe ".base_uri" do
+    it "returns the qualified API uri" do
+      klass.base_uri = "http://api.dnsimple.com"
+      klass.base_uri.should eq("http://api.dnsimple.com")
+    end
+  end
+
+  describe ".base_uri=" do
+    it "sets the base_uri" do
+      klass.base_uri = "http://api1.dnsimple.com/"
+      klass.base_uri.should eq("http://api1.dnsimple.com")
+      klass.base_uri = "http://api2.dnsimple.com"
+      klass.base_uri.should eq("http://api2.dnsimple.com")
+    end
+  end
+
 end