sparqcode-dnsimple-ruby 1.2.6

data/lib/dnsimple/transfer_order.rb

@@ -0,0 +1,45 @@
+module DNSimple #:nodoc:
+  # Class representing a transfer order in DNSimple
+  class TransferOrder
+    include HTTParty
+
+    attr_accessor :id
+
+    attr_accessor :status
+
+    def initialize(attributes)
+      attributes.each do |key, value|
+        m = "#{key}=".to_sym
+        self.send(m, value) if self.respond_to?(m)
+      end
+    end
+
+    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})
+      options.merge!({:basic_auth => Client.credentials})
+
+      response = self.post("#{Client.base_uri}/domain_transfers.json", options)
+
+      pp response if Client.debug?
+
+      case response.code
+      when 201
+        return TransferOrder.new(response["transfer_order"])
+      when 401
+        raise RuntimeError, "Authentication failed"
+      else
+        raise DNSimple::Error.new(name, response["errors"])
+      end
+    end
+  end
+end

data/lib/dnsimple/user.rb

@@ -0,0 +1,44 @@
+module DNSimple
+  class User
+    include HTTParty
+
+    attr_accessor :id
+
+    attr_accessor :created_at
+
+    attr_accessor :updated_at
+
+    attr_accessor :email
+
+    attr_accessor :login_count
+
+    attr_accessor :failed_login_count
+
+    attr_accessor :domain_count
+
+    attr_accessor :domain_limit
+
+    def initialize(attributes)
+      attributes.each do |key, value|
+        m = "#{key}=".to_sym
+        self.send(m, value) if self.respond_to?(m)
+      end
+    end
+
+    def self.me(options={})
+      options.merge!({:basic_auth => Client.credentials})
+      response = self.get("#{Client.base_uri}/users/me.json", options)
+
+      case response.code
+      when 200
+        return User.new(response["user"])
+      when 401
+        raise DNSimple::AuthenticationFailed, "Authentication failed"
+      when 404
+        raise DNSimple::UserNotFound, "Could not find user"
+      else
+        raise DNSimple::Error, "Error: #{response.code} #{response.message}"
+      end
+    end
+  end
+end

data/spec/README

@@ -0,0 +1,10 @@
+Before running the DNSimple Ruby Client specifications, you must do the following:
+
+1.) If you haven't already create a new account at https://test.dnsimple.com and activate it using the credit card number of "1"
+
+2.) Create a file in your home directory called .dnsimple.test and include the following:
+
+username: YOUR_USERNAME
+password: YOUR_PASSWORD
+site: https://test.dnsimple.com
+

data/spec/certificate_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe DNSimple::Certificate do
+  let(:domain_name) { 'example.com' }
+  let(:domain) { DNSimple::Domain.new(:name => domain_name) }
+
+  describe "#fqdn" do
+    it "joins the name and domain name" do
+      certificate = DNSimple::Certificate.new(:name => 'www')
+      certificate.domain = domain
+      certificate.fqdn.should eq("www.#{domain_name}")
+    end
+    it "strips blank parts from name" do
+      certificate = DNSimple::Certificate.new(:name => '')
+      certificate.domain = domain
+      certificate.fqdn.should eq(domain_name)
+    end
+  end
+
+  describe ".purchase" do
+    let(:contact) { DNSimple::Contact.new(:id => 1) }
+    use_vcr_cassette
+    it "purchases a certificate" do
+      certificate = DNSimple::Certificate.purchase(domain, 'www', contact)
+      certificate.fqdn.should eq("www.#{domain_name}")
+    end
+  end
+
+  describe ".all" do
+    use_vcr_cassette
+    it "returns all certificates for the specific domain" do
+      certificates = DNSimple::Certificate.all(domain)
+      certificates.length.should eq(1)
+      certificates.first.fqdn.should eq('www.example.com')
+    end
+  end
+
+  describe "#submit" do
+    use_vcr_cassette
+    let(:certificate) { DNSimple::Certificate.new(:id => 1, :domain => domain) }
+    it "submits a certificate for purchase" do
+      certificate.submit("admin@example.com")
+    end
+  end
+
+end

data/spec/command_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+require 'dnsimple/command'
+
+class FakeCommand < DNSimple::Command
+  def execute
+    say "done"
+  end
+end
+
+describe DNSimple::Command do
+  describe "#say" do
+    it "writes to the output" do
+      s = StringIO.new
+      command = FakeCommand.new(s)
+      command.execute
+      s.string.should eq("done\n")
+    end
+  end
+end

data/spec/commands/add_service_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+require 'dnsimple/commands/add_service'
+
+describe DNSimple::Commands::AddService do
+  let(:out) { StringIO.new }
+
+  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") }
+
+  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::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")
+  end
+end

data/spec/commands/create_record_spec.rb

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

data/spec/commands/list_records_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+require 'dnsimple/commands/list_records'
+
+describe DNSimple::Commands::ListRecords 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) }
+  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/purchase_certificate_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+require 'dnsimple/certificate'
+require 'dnsimple/commands/purchase_certificate'
+
+describe DNSimple::Commands::PurchaseCertificate do
+  
+  let(:out) { StringIO.new }
+  let(:domain_name) { 'example.com' }
+  let(:domain) { DNSimple::Domain.new(:name => domain_name) }
+  let(:contact_id) { 123 }
+  let(:contact) { DNSimple::Contact.new(:first_name => 'John', :last_name => 'Doe') }
+  let(:name) { "John Doe" }
+  
+  context "with one argument" do
+    it "purchases the certificate" do
+      
+      DNSimple::Domain.expects(:find).with(domain_name).returns(domain)
+      DNSimple::Contact.expects(:find).with(contact_id).returns(contact)
+      DNSimple::Certificate.expects(:purchase).with(domain, name, contact).returns(stub("certificate", :fqdn => domain_name))
+      
+      DNSimple::Commands::PurchaseCertificate.new(out).execute([domain_name, name, contact_id])
+    end
+  end
+end

data/spec/commands/submit_certificate_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+require 'dnsimple/commands/submit_certificate'
+
+describe DNSimple::Commands::SubmitCertificate do
+  let(:out) { StringIO.new }
+  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::SubmitCertificate.new(out).execute([domain_name, certificate_id, approver_email])
+  end
+end

data/spec/contact_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe DNSimple::Contact do
+  
+  describe "a new contact" do
+    use_vcr_cassette
+
+    let(:contact_attributes) {
+      {
+        :first_name => 'John',
+        :last_name => 'Doe',
+        :address1 => '1 SW 1st Street',
+        :city => 'Miami',
+        :state_province => 'FL',
+        :postal_code => '33143',
+        :country => 'US',
+        :email_address => 'john.doe@example.com',
+        :phone => '305 111 2222'
+      }
+    }
+    it "has specific attributes" do
+      contact = DNSimple::Contact.create(contact_attributes)
+      contact.first_name.should eql(contact_attributes[:first_name])
+      contact.id.should_not be_nil
+    end
+  end
+
+  describe "an existing contact" do
+    use_vcr_cassette
+    it "can be found by id" do
+      contact = DNSimple::Contact.find(1)
+      contact.should_not be_nil
+    end
+  end
+end

data/spec/domain_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+
+describe DNSimple::Domain do
+  let(:domain_name) { "example.com" }
+  let(:contact_id) { 1 }
+
+  describe "creating a new domain" do
+    use_vcr_cassette
+    it "has specific attributes" do 
+      @domain = DNSimple::Domain.create(domain_name)
+      @domain.name.should eql(domain_name)
+      @domain.id.should_not be_nil
+    end
+  end
+  describe "finding an existing domain" do
+    context "by id" do
+      use_vcr_cassette
+      it "can be found" do
+        domain = DNSimple::Domain.find(39)
+        domain.name.should eql(domain_name)
+        domain.id.should_not be_nil
+      end
+    end
+    context "by name" do
+      use_vcr_cassette
+      it "can be found" do
+        domain = DNSimple::Domain.find(domain_name)
+        domain.name.should eql(domain_name)
+        domain.id.should_not be_nil
+      end
+    end
+  end
+
+  context "registration" do
+
+    context "with an existing contact" do
+      let(:domain_name) { "dnsimple-example-1321042237.com" }
+      use_vcr_cassette
+      it "can be registered" do
+        domain = DNSimple::Domain.register(domain_name, {:id => contact_id})
+        domain.name.should eql(domain_name)
+      end
+    end
+    
+    context "with a new registrant contact" do
+      let(:domain_name) { "dnsimple-example-1321042288.com" }
+      use_vcr_cassette
+      it "can be registered" do
+        registrant = {
+          :first_name => 'John',
+          :last_name => 'Smith',
+          :address1 => '123 SW 1st Street',
+          :city => 'Miami',
+          :state_or_province => 'FL',
+          :country => 'US',
+          :postal_code => '33143',
+          :phone => '321 555 1212'
+        }
+        domain = DNSimple::Domain.register(domain_name, registrant)
+        domain.name.should eql(domain_name)
+      end
+    end
+  end
+
+  describe ".all" do
+    use_vcr_cassette
+    before do
+      @domains = []
+      2.times do |n|
+        @domains << DNSimple::Domain.create("example#{n}.com")
+      end
+    end
+    it "returns a list of domains" do
+      domains = DNSimple::Domain.all
+      domains.map { |d| d.name }.should include(*@domains.map { |d| d.name })
+    end
+  end
+
+  describe "applying templates" do
+    use_vcr_cassette
+    let(:domain) { DNSimple::Domain.find("example.com") }
+    it "applies a named template" do
+      DNSimple::Record.all(domain).should be_empty
+      domain.apply("googleapps")
+      DNSimple::Record.all(domain).should_not be_empty
+    end
+  end
+  
+  describe "setting name servers" do
+    use_vcr_cassette
+    let(:domain) { DNSimple::Domain.new(:name => 'example.com') }
+    
+    it "overwrites name servers" do
+      domain.update_name_servers(["n1.fake.com", "ns2.fake.com"])
+    end
+  end
+end

data/spec/extended_attributes_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe DNSimple::ExtendedAttribute do
+
+  describe "list extended attributes" do
+    context "for com" do
+      use_vcr_cassette
+      it "is an empty array" do
+        DNSimple::ExtendedAttribute.find('com').should be_empty
+      end
+    end
+    context "for ca" do
+      use_vcr_cassette
+      it "is not empty" do
+        DNSimple::ExtendedAttribute.find('ca').should_not be_empty
+      end
+    end
+  end
+end