name_dot_com_api 0.0.1

data/.gitignore

@@ -0,0 +1,6 @@
+._*
+\#*
+*~
+.#*
+.DS_Store
+Gemfile.lock

data/Gemfile

@@ -0,0 +1,10 @@
+source :gemcutter
+gemspec
+
+gem 'json'
+
+group :test do 
+  gem 'rake'
+  gem 'rspec', '1.3.1'
+  gem 'webmock', '1.6.1'
+end

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Nicholas Barthelemy
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,16 @@
+= NameDotComApi
+
+This gem allows you to interact with the name.com api via ruby.
+
+== Basic Usage
+
+	client = NameDotComApi::Client.new('< username >','< api_token >', < test_mode >)
+	response = client.check_domain('< domain_name >')
+
+* Please see lib/name_dot_com_api/client.rb and specs for additional details on usage
+
+== TODOS
+
+* MORE DOCUMENTAION
+* Add Contact model for contact creation and possible validation
+* Include expected responses in mocks

data/Rakefile

@@ -0,0 +1,20 @@
+require 'rubygems'
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+# Added to get the specs working
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec)
+
+task :default => :spec
+task :specs => :spec
+
+# Generate documentation
+require 'rake/rdoctask'
+desc "Generate Documentation"
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'doc'
+  rdoc.title = 'Name.com API'
+  rdoc.options << '--line-numbers' << '--inline-source' << '--main' << 'Name.com API'
+  rdoc.rdoc_files.include(FileList[ 'lib/**/*.rb', 'README.rdoc', 'LICENSE'])
+end

data/lib/name_dot_com_api/client.rb

@@ -0,0 +1,151 @@
+module NameDotComApi
+
+  class Client
+
+    attr_reader :connection
+
+    def initialize(username, api_token, test_mode = false)
+      @connection ||= Connection.new
+      @connection.test_mode = test_mode
+      login username, api_token
+    end
+
+    # response = client.login(username, api_token)
+    def login(username, api_token)
+      raise "You are already logged in" if @connection.logged_in?
+
+      @connection.username ||= username
+      @connection.api_token ||= api_token
+
+      connection.post '/login', { 
+        :username => @connection.username, :api_token => @connection.api_token
+      }
+    end
+
+    # response = client.logout
+    def logout
+      connection.get '/logout'
+    end
+
+    # response = client.hello
+    def hello
+      connection.get '/hello'
+    end
+
+    # response = client.get_account
+    def get_account
+      connection.get '/account/get'
+    end
+
+    # response = client.list_domains
+    def list_domains
+      connection.get "/domain/list/#{connection.username}"
+    end
+
+    # response = client.update_domain_nameservers('example.com', [
+    #   'ns1.name.com', 'ns2.name.com', 'ns3.name.com'
+    # ])
+    def update_domain_nameservers(domain, nameservers = {})
+      connection.post "/domain/update_nameservers/#{domain}", { :nameservers => nameservers }
+    end
+
+    # response = client.update_domain_contacts('mynewdomain.com', [
+    #   { 'type' => [ 'registrant','administrative','technical','billing' ],
+    #     'first_name'   => 'John',
+    #     'last_name'    => 'Doe',
+    #     'organization' => 'Name.com',
+    #     'address_1'    => '125 Main St',
+    #     'address_2'    => 'Suite 300',
+    #     'city'         => 'Denver',
+    #     'state'        => 'CO',
+    #     'zip'          => '80230',
+    #     'country'      => 'US',
+    #     'phone'        => '+1.3035555555',
+    #     'fax'          => '+1.3035555556',
+    #     'email'        => 'john@example.net'
+    #   }
+    # ])
+    def update_domain_contacts(domain, contacts = [])
+      connection.post "/domain/update_contacts/#{domain}", { :contacts => contacts }
+    end
+
+    # response = client.lock_domain('example.com')
+    def lock_domain(domain)
+      connection.get "/domain/lock/#{domain}"
+    end
+
+    # response = client.unlock_domain('example.com')
+    def unlock_domain(domain)
+      connection.get "/domain/unlock/#{domain}"
+    end
+
+    # response = client.list_dns_records('example.com')
+    def list_dns_records(domain)
+      connection.get "/dns/list/#{domain}"
+    end
+
+    # response = client.create_dns_record('example.com', 'www', 'A', '127.0.0.1', 300)
+    # response = client.create_dns_record('example.com', 'mail', 'MX', 'mx3.name.com', 300, 10)
+    def create_dns_record(domain, hostname, type, content, ttl, priority = nil)
+      body = {
+        'hostname' => hostname,
+        'type'     => type,
+        'content'  => content,
+        'ttl'      => ttl
+      }
+      body.update!(:priority => priority) if priority
+      connection.post "/dns/create/#{domain}", body
+    end
+    alias :add_dns_record :create_dns_record
+
+    # response = client.delete_dns_record('example.com', 1234)
+    def delete_dns_record(domain, record_id)
+      connection.post "/dns/delete/#{domain}", { :record_id => record_id }
+    end
+    alias :remove_dns_record :delete_dns_record
+
+    # response = client.check_domain('example')
+    # response = client.check_domain('example', [ 'com', 'net', 'org' ], [ 'availability','suggested' ])
+    def check_domain(keyword, tlds = nil, services = nil)
+      connection.post '/domain/power_check', {
+        'keyword'  => keyword,
+        'tlds'     => tlds || [ 'com' ], # ,'net','org','info','us','biz','tel' ],
+        'services' => services || [ 'availability' ] # ,'suggested' ]
+      }
+    end
+
+    # ns = [ 'ns1.name.com', 'ns2.name.com', 'ns3.name.com' ]
+    # response = client.create_domain('example.com', 1, ns, [
+    #   { 'type' => [ 'registrant','administrative','technical','billing' ],
+    #     'first_name'   => 'John',
+    #     'last_name'    => 'Doe',
+    #     'organization' => 'Name.com',
+    #     'address_1'    => '125 Main St',
+    #     'address_2'    => 'Suite 300',
+    #     'city'         => 'Denver',
+    #     'state'        => 'CO',
+    #     'zip'          => '80230',
+    #     'country'      => 'US',
+    #     'phone'        => '+1.3035555555',
+    #     'fax'          => '+1.3035555556',
+    #     'email'        => 'john@example.net'
+    #   }
+    # ])
+    def create_domain(domain, period, nameservers, contacts)
+      connection.post '/domain/create', {
+        'domain'      => domain,
+        'period'      => period,
+        'nameservers' => nameservers,
+        'contacts'    => contacts,
+        'username'    => connection.username
+      }
+    end
+
+    # response = client.get_domain('example.com')
+    def get_domain(domain)
+      connection.get "/domain/get/#{domain}"
+    end
+
+  end
+
+end

data/lib/name_dot_com_api/connection.rb

@@ -0,0 +1,141 @@
+require 'cgi'
+require 'net/https'
+require 'uri'
+require 'json'
+
+module NameDotComApi
+
+  class ConnectionError < StandardError
+    attr_reader :response
+
+    def initialize(response, message = nil)
+      @response = response
+      @message  = message
+    end
+
+    def to_s
+      "Failed with #{response.code} #{response.message if response.respond_to?(:message)}"
+    end
+  end
+
+  class Connection
+    HTTP_FORMAT_HEADER_NAMES = {
+      :get    => 'Accept',
+      :post   => 'Content-Type'
+    }
+
+    JSON_MIME_TYPE = 'text/json; charset=utf-8'
+
+    def initialize(test_mode = false)
+      @headers ||= {}
+      @cookies ||= {}
+      @test_mode = test_mode
+    end
+
+    attr_accessor :username, :api_token, :session_token
+    attr_accessor :url, :cookies, :timeout, :test_mode
+
+    def logged_in?; !!session_token; end
+
+    # Set URI for remote service.
+    def url=(url)
+      @url = url.is_a?(URI) ? url : URI.parse(url)
+    end
+
+    # Creates new Net::HTTP instance for communication with remote service and resources.
+    def http
+      http              = Net::HTTP.new(url.host, url.port)
+      http.use_ssl      = url.is_a?(URI::HTTPS)
+      http.verify_mode  = OpenSSL::SSL::VERIFY_NONE if http.use_ssl
+      http.read_timeout = timeout || 60 # Net::HTTP default 60 seconds
+      http.set_debug_output $stderr if test_mode
+      http
+    end
+
+    def get(path, params = {}); request(:get, path, params); end
+    def post(path, params = {}); request(:post, path, params); end
+
+    def logger
+      defined?(ActiveRecord) ? ActiveRecord::Base.logger : nil
+    end
+
+  private
+
+    # Makes request to remote service.  # Be sure to handle Timeout::Error
+    def request(method, path, params = {})
+      # ensure the user is logged in or logging in
+      raise "You must first login" unless path =~ /^\/login/ || logged_in?
+
+      self.url = "#{NameDotComApi.base_url(test_mode)}#{path}"
+
+      logger.info "#{method.to_s.upcase} #{url.to_s}" if logger
+      logger.info "with body: #{params.inspect}" if logger
+
+      result = case method
+        when :get then http.send(method, url.to_s, build_request_headers(method))
+        when :post then http.send(method, url.to_s, params.to_json, build_request_headers(method))
+      end
+
+      logger.info "--> %d %s (%d)" % [ result.code, result.message, result.body ? result.body.length : 0 ] if logger
+
+      handle_response(result)
+    rescue Timeout::Error => e
+      raise TimeoutError.new(e.message)
+    end
+
+    # Builds headers for request to remote service.
+    def build_request_headers(http_method = nil)
+      headers = {}
+
+      if session_token
+        logger.info "SessionToken: #{session_token}" if logger
+        headers['Api-Session-Token'] = session_token
+      end
+
+      if username && api_token
+        logger.info "Username: #{username}" if logger
+        headers['Api-Username'] = username
+
+        logger.info "SessionToken: #{api_token}" if logger
+        headers['Api-Token'] = api_token
+      end
+
+      http_format_header(http_method).update(cookie_header).update(headers)
+    end
+
+    # Builds the cookie header according to what's stored in @cookies
+    # Encodes correctly for cookies, e.g. key1=value1; key2=value2
+    def cookie_header
+      unless cookies.nil? || cookies.empty?
+        pairs = @cookies.inject([]) do |a, p|
+          a << "#{CGI::escape(p[0].to_s)}=#{CGI::escape(p[1].to_s)}"; a
+        end
+        { 'Cookie' => pairs.join('; ') }
+      else
+        {}
+      end
+    end
+
+    def http_format_header(http_method)
+      { HTTP_FORMAT_HEADER_NAMES[http_method] => JSON_MIME_TYPE }
+    end
+
+    # Handles response and error codes from remote service.
+    def handle_response(response)
+      case response.code.to_i
+      when 200
+        response = ::NameDotComApi::Response.new(response.body)
+        unless response['session_token'].nil?
+          self.session_token = response['session_token']
+        end
+        response
+      when 301, 302
+        raise ConnectionError.new(response, "Redirection response code: #{response.code}")
+      else
+        raise ConnectionError.new(response, "Connection response code: #{response.code}")
+      end
+    end
+
+  end
+
+end

data/lib/name_dot_com_api/response.rb

@@ -0,0 +1,34 @@
+require 'json'
+
+module NameDotComApi
+  class Response < Hash
+
+    def initialize(json)
+      self.update JSON.parse(json)
+    end
+
+    module EigenMethodDefiner # :nodoc:
+      def method_missing(name, *args, &block)
+        if key?(name.to_s)
+          define_eigen_method(name.to_s)
+          value = self[name.to_s]
+          value.extend(EigenMethodDefiner) if value.is_a?(Hash)
+          value
+        else
+          super
+        end
+      end
+
+    private
+
+      def define_eigen_method(name)
+        eigen_class = class << self; self; end
+        eigen_class.send(:define_method, name){ self[name] }
+      end
+
+    end
+
+    include EigenMethodDefiner
+
+  end
+end

data/lib/name_dot_com_api/version.rb

@@ -0,0 +1,3 @@
+module NameDotComApi
+  VERSION = "0.0.1"
+end

data/lib/name_dot_com_api.rb

@@ -0,0 +1,17 @@
+# client = NameDotComApi::Client.new('< username >','< api_token >', < test mode >)
+# response = client.check_domain('< domain_name >')
+
+require 'name_dot_com_api/client'
+require 'name_dot_com_api/connection'
+require 'name_dot_com_api/response'
+
+module NameDotComApi
+
+  TEST_API_HOST = 'https://api.dev.name.com/api'
+  PRODUCTION_API_HOST = 'https://api.name.com/api'
+
+  def self.base_url(test_mode = false)
+    test_mode ? TEST_API_HOST : PRODUCTION_API_HOST
+  end
+
+end

data/name_dot_com_api.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path("../lib/name_dot_com_api/version", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "name_dot_com_api"
+  s.version     = NameDotComApi::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = [ 'Nicholas Barthelemy' ]
+  s.email       = [ 'nicholas.barthelemy@gmail.com' ]
+  s.homepage    = "https://github.com/nbarthelemy/name_dot_com_api"
+  s.summary     = "An easy to use unterface for the name.com api"
+  s.description = "This gem allows you to interact with the name.com api via ruby."
+
+  s.required_rubygems_version = ">= 1.3.6"
+  s.rubyforge_project         = "name_dot_com_api"
+
+  s.add_development_dependency "bundler", ">= 1.0.0"
+
+  s.files        = `git ls-files`.split("\n")
+  s.executables  = `git ls-files`.split("\n").map{|f| f =~ /^bin\/(.*)/ ? $1 : nil}.compact
+  s.require_path = 'lib'
+end

data/spec/client_spec.rb

@@ -0,0 +1,174 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe NameDotComApi do
+
+  describe "::Client" do
+
+    before(:each) do
+      @username = 'spec_user'
+      @api_key = 'ds98fusdfjsdklfjk832934d9sa0d9auda8s7df8'
+      @session_token = '34d9sa0d9auda8' # fake logged in
+
+      @base_url = NameDotComApi.base_url
+
+      @domain = 'example.com'
+      @nameservers = [ 'ns1.name.com', 'ns2.name.com', 'ns3.name.com' ]
+      @contact = {
+        'type'         => [ 'registrant','administrative','technical','billing' ],
+        'first_name'   => 'John',
+        'last_name'    => 'Doe',
+        'organization' => 'Name.com',
+        'address_1'    => '125 Main St',
+        'address_2'    => 'Suite 300',
+        'city'         => 'Denver',
+        'state'        => 'CO',
+        'zip'          => '80230',
+        'country'      => 'US',
+        'phone'        => '+1.3035555555',
+        'fax'          => '+1.3035555556',
+        'email'        => 'john@example.net'
+      }
+
+      stub_request(:post, "#{@base_url}/login").
+        to_return(successful_json_response(:session_token => @session_token))
+
+      @client = NameDotComApi::Client.new(@username, @api_key)
+    end
+
+    def check_for_successful_response(response)
+      response.result['code'].should == 100
+      response.result['message'].should == "Command Successful"
+    end
+
+    def successful_json_response(body = {})
+      { :status => 200, :body => { 
+          :result => { :code => 100, :message => "Command Successful" } 
+        }.merge(body).to_json }
+    end
+
+    it "can login" do
+      @client.connection.logged_in?.should == true
+    end
+
+    it "can logoout" do
+      stub_request(:get, "#{@base_url}/logout").to_return(successful_json_response)
+
+      response = @client.logout
+      check_for_successful_response(response)
+    end
+
+    it "can get hello response" do
+      stub_request(:get, "#{@base_url}/hello").to_return(successful_json_response)
+
+      response = @client.hello
+      check_for_successful_response(response)
+    end
+
+    it "can get account information" do
+      stub_request(:get, "#{@base_url}/account/get").
+        to_return(successful_json_response(:username => @username))
+
+      response = @client.get_account
+      check_for_successful_response(response)
+      response.username.should == @username
+    end
+
+    it "can list domains" do
+      stub_request(:get, "#{@base_url}/domain/list/spec_user").
+        to_return(successful_json_response(:domains => []))
+
+      response = @client.list_domains
+      check_for_successful_response(response)
+    end
+
+    it "can create a domain" do
+      stub_request(:post, "#{@base_url}/domain/create").
+        to_return(successful_json_response)
+
+      response = @client.create_domain(@domain, 1, @nameservers, [ @contact ])
+      check_for_successful_response(response)
+    end
+
+    it "can update nameservers for domain" do
+      stub_request(:post, "#{@base_url}/domain/update_nameservers/#{@domain}").
+        to_return(successful_json_response)
+
+      response = @client.update_domain_nameservers(@domain, @nameservers)
+      check_for_successful_response(response)
+    end
+
+    it "can update contacts for domain" do
+      stub_request(:post, "#{@base_url}/domain/update_contacts/#{@domain}").
+        to_return(successful_json_response)
+
+      response = @client.update_domain_contacts(@domain, [ @contact ])
+      check_for_successful_response(response)
+    end
+
+    it "can lock a domain" do
+      stub_request(:get, "#{@base_url}/domain/lock/#{@domain}").
+        to_return(successful_json_response)
+
+      response = @client.lock_domain(@domain)
+      check_for_successful_response(response)
+    end
+
+    it "can unlock a domain" do
+      stub_request(:get, "#{@base_url}/domain/unlock/#{@domain}").
+        to_return(successful_json_response)
+
+      response = @client.unlock_domain(@domain)
+      check_for_successful_response(response)
+    end
+
+    it "can list dns records" do
+      stub_request(:get, "#{@base_url}/dns/list/#{@domain}").
+        to_return(successful_json_response)
+
+      response = @client.list_dns_records(@domain)
+      check_for_successful_response(response)
+    end
+
+    it "can create a dns record" do
+      stub_request(:post, "#{@base_url}/dns/create/#{@domain}").
+        to_return(successful_json_response)
+
+      response = @client.create_dns_record(@domain, 'www', 'A', '127.0.0.1', 300)
+      check_for_successful_response(response)
+    end
+
+    it "can delete a dns record" do
+      stub_request(:post, "#{@base_url}/dns/delete/#{@domain}").
+        to_return(successful_json_response)
+
+      response = @client.delete_dns_record(@domain, 1234)
+      check_for_successful_response(response)
+    end
+
+    it "can check a domain" do
+      stub_request(:post, "#{@base_url}/domain/power_check").
+        to_return(successful_json_response)
+
+      response = @client.check_domain('example', [ 'com' ])
+      check_for_successful_response(response)
+    end
+
+    it "can create a domain" do
+      stub_request(:post, "#{@base_url}/domain/create").
+        to_return(successful_json_response)
+
+      response = @client.create_domain(@domain, 1, @nameservers, [ @contact ])
+      check_for_successful_response(response)
+    end
+
+    it "can get a domain" do
+      stub_request(:get, "#{@base_url}/domain/get/#{@domain}").
+        to_return(successful_json_response)
+
+      response = @client.get_domain(@domain)
+      check_for_successful_response(response)
+    end
+
+  end
+
+end

data/spec/connection_spec.rb

@@ -0,0 +1,123 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+# test the private methods; see spec/spec_helper.rb
+describe_internally NameDotComApi::Connection do
+
+  before(:each) do
+    @connection = NameDotComApi::Connection.new
+    @connection.username = 'spec_user'
+    @connection.api_token = 'ds98fusdfjsdklfjk832934d9sa0d9auda8s7df8'
+    @connection.session_token = '34d9sa0d9auda8' # fake logged in
+
+    @test_path = '/hello'
+    @test_url = "#{NameDotComApi.base_url(@connection.test_mode)}#{@test_path}"
+  end
+
+  it "can represent both login states" do
+    @connection.logged_in?.should == true
+
+    @connection.session_token = nil
+    @connection.logged_in?.should == false
+  end
+
+  it "can build cookie headers" do
+    # no cookies
+    @connection.cookie_header.should == {}
+
+    # cookies
+    @connection.cookies = { 'test' => 'cookie' }
+    @connection.cookie_header.should == { 'Cookie' => 'test=cookie' }
+  end
+
+  it "can retrieve the correct http format header (get/post)" do
+    @connection.http_format_header(:get).should == { "Accept" => "text/json; charset=utf-8" }
+    @connection.http_format_header(:post).should == { "Content-Type" => "text/json; charset=utf-8" }
+  end
+
+  it "can build request headers (get/post)" do
+    # get
+    @connection.build_request_headers(:get).should == {
+      "Api-Username"      => @connection.username,
+      "Api-Token"         => @connection.api_token,
+      "Api-Session-Token" => @connection.session_token,
+      "Accept"            => NameDotComApi::Connection::JSON_MIME_TYPE
+    }
+
+    # post
+    @connection.build_request_headers(:post).should == {
+      "Api-Username"      => @connection.username,
+      "Api-Token"         => @connection.api_token,
+      "Api-Session-Token" => @connection.session_token,
+      "Content-Type"      => NameDotComApi::Connection::JSON_MIME_TYPE
+    }
+  end
+
+  it "can make a request (get/post)" do
+    # get
+    stub_request(:get, @test_url).to_return(:status => 200, :body => "{}")
+    @connection.request(:get, @test_path).should == {}
+
+    # post
+    stub_request(:post, @test_url).with(:body => "{}").to_return(:status => 200, :body => '{}')
+    @connection.request(:post, @test_path).should == {}
+  end
+
+  it "can handle a 200 response" do
+    @mock = mock('Net::HTTPResponse')
+    @mock.stub(:code => '200', :message => "OK", :content_type => "text/json", :body => '{}')
+    @connection.handle_response(@mock).should == {}
+  end
+
+  it "can handle a 30X response" do
+    @mock = mock('Net::HTTPResponse')
+    @mock.stub(:code => '301', :message => "PERMANENTLY MOVED", :content_type => "text/json", :body => '')
+    lambda{ @connection.handle_response(@mock) }.should raise_error(NameDotComApi::ConnectionError)
+
+    @mock = mock('Net::HTTPResponse')
+    @mock.stub(:code => '302', :message => "TEMPORARILY MOVED", :content_type => "text/json", :body => '')
+    lambda{ @connection.handle_response(@mock) }.should raise_error(NameDotComApi::ConnectionError)
+  end
+
+  it "can handle any other response" do
+    @mock = mock('Net::HTTPResponse')
+    @mock.stub(:code => '400', :message => "NOT FOUND", :content_type => "text/json", :body => '')
+    lambda{ @connection.handle_response(@mock) }.should raise_error(NameDotComApi::ConnectionError)
+  end
+
+end
+
+describe NameDotComApi::Connection do
+
+  before(:each) do
+    @connection = NameDotComApi::Connection.new
+    @connection.username = 'spec_user'
+    @connection.api_token = 'ds98fusdfjsdklfjk832934d9sa0d9auda8s7df8'
+    @connection.session_token = '34d9sa0d9auda8' # fake logged in
+
+    @test_path = '/hello'
+    @test_url = "#{NameDotComApi.base_url(@connection.test_mode)}#{@test_path}"
+  end
+
+  it "can set test mode" do
+    @connection.test_mode = true
+    @connection.test_mode.should == true
+    @connection.test_mode = false
+    @connection.test_mode.should == false
+  end
+
+  it "can create an http object" do
+    @connection.url = @test_url
+    @connection.http.is_a?(Net::HTTP).should == true
+  end
+
+  it "can make a get request" do
+    stub_request(:get, @test_url).to_return(:status => 200, :body => "{}")
+    @connection.get(@test_path).should == {}
+  end
+
+  it "can make a post request" do
+    stub_request(:post, @test_url).with(:body => "{}").to_return(:status => 200, :body => '{}')
+    @connection.post(@test_path).should == {}
+  end
+
+end

data/spec/name_dot_com_api_spec.rb

@@ -0,0 +1,18 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe NameDotComApi do
+
+  describe "#base_url" do
+
+    it "returns test url" do
+      NameDotComApi.base_url(true).should == 'https://api.dev.name.com/api'
+    end
+
+    it "returns production url" do
+      NameDotComApi.base_url.should == 'https://api.name.com/api'
+      NameDotComApi.base_url(false).should == 'https://api.name.com/api'
+    end
+
+  end
+
+end

data/spec/response_spec.rb

@@ -0,0 +1,25 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe NameDotComApi do
+
+  describe "::Response" do
+
+    before(:each) do
+      @response = NameDotComApi::Response.new("{\"a\":1,\"b\":2,\"c\":[1,2]}")
+    end
+
+    it "parses a json object" do
+      @response['a'].should == 1
+      @response['b'].should == 2
+      @response['c'].should == [1,2]
+    end
+
+    it "allows top level hash keys to be called as methods" do
+      @response.a.should == 1
+      @response.b.should == 2
+      @response.c.should == [1,2]
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,25 @@
+RAILS_ENV = 'test' if ENV['RAILS_ENV'] == 'development' || !ENV.key?('RAILS_ENV')
+
+require 'rubygems'
+require 'bundler/setup'
+require 'spec'
+require 'webmock/rspec'
+require 'name_dot_com_api'
+
+# http://kailuowang.blogspot.com/2010/08/testing-private-methods-in-rspec.html
+def describe_internally *args, &block
+  example = describe *args, &block
+  klass = args[0]
+  if klass.is_a? Class
+    saved_private_instance_methods = klass.private_instance_methods
+    example.before do
+      klass.class_eval { public *saved_private_instance_methods }
+    end
+    example.after do
+      klass.class_eval { private *saved_private_instance_methods }
+    end
+  end
+end
+
+Spec::Runner.configure do |config|
+end

data/spec.opts

@@ -0,0 +1,3 @@
+--colour
+--format s
+--backtrace

metadata

@@ -0,0 +1,94 @@
+--- !ruby/object:Gem::Specification 
+name: name_dot_com_api
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Nicholas Barthelemy
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-01-06 00:00:00 -06:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  type: :development
+  version_requirements: *id001
+description: This gem allows you to interact with the name.com api via ruby.
+email: 
+- nicholas.barthelemy@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- MIT-LICENSE
+- README.rdoc
+- Rakefile
+- lib/name_dot_com_api.rb
+- lib/name_dot_com_api/client.rb
+- lib/name_dot_com_api/connection.rb
+- lib/name_dot_com_api/response.rb
+- lib/name_dot_com_api/version.rb
+- name_dot_com_api.gemspec
+- spec.opts
+- spec/client_spec.rb
+- spec/connection_spec.rb
+- spec/name_dot_com_api_spec.rb
+- spec/response_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: https://github.com/nbarthelemy/name_dot_com_api
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 3
+      - 6
+      version: 1.3.6
+requirements: []
+
+rubyforge_project: name_dot_com_api
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: An easy to use unterface for the name.com api
+test_files: []
+