moo_moo 0.1.0

data/lib/moo_moo/opensrs/opensrsexception.rb

@@ -0,0 +1,6 @@
+module MooMoo
+  module OpenSRS
+    class OpenSRSException < Exception
+    end
+  end
+end

data/lib/moo_moo/opensrs/provisioning_commands.rb

@@ -0,0 +1,167 @@
+module MooMoo
+  module OpenSRS
+    module ProvisioningCommands
+      # Cancels a Trust Service order
+      #
+      # ==== Required
+      #  * <tt>:order_id</tt> - ID of the order
+      def cancel_order(order_id)
+        run_command :cancel_order, :trust_service, {
+          :order_id => order_id,
+          :key => 'attributes'
+        }
+      end
+
+      # Cancels pending or declined orders
+      #
+      # ==== Required
+      #  * <tt>:to_date</tt> - date before which to cancel orders
+      def cancel_pending_orders(to_date)
+        run_command :cancel_pending_orders, :order, {
+          :to_date => to_date,
+          :key => 'attributes'
+        }
+      end
+
+      # Changes information associated with a domain
+      #
+      # ==== Required
+      #  * <tt>:type</tt> - type of data to modify
+      #  * <tt>:params</tt> - new parameter values to set
+      #
+      # ==== Optional
+      #  * <tt>:cookie</tt> - cookie for the domain
+      def modify(params)
+        cookie = params.delete :cookie
+
+        run_command :modify, :domain, params, cookie
+      end
+
+      # Processes or cancels a pending order
+      #
+      # ==== Required
+      #  * <tt>:order_id</tt> - ID of the pending order to process
+      def process_pending(order_id)
+        run_command :process_pending, :domain, {
+          :order_id => order_id,
+          :key => 'attributes'
+        }
+      end
+
+      # Renews a domain name
+      #
+      # ==== Required
+      #  * <tt>:domain</tt> - domain name to renew
+      #  * <tt>:term</tt> - number of years to renew for
+      #  * <tt>:current_expiration_year</tt> - current expiration year in YYYY format
+      def renew_domain(attribs)
+        Args.new(attribs) do |c|
+          c.requires :domain, :term, :current_expiration_year
+        end
+
+        attribs[:handle] = 'process' unless attribs[:handle]
+        attribs[:key] = 'attributes'
+
+        run_command :renew, :domain, attribs
+      end
+
+      # Removes the domain at the registry
+      #
+      # ==== Required
+      #  * <tt>:domain</tt> - domain name to remove
+      #  * <tt>:reseller</tt> - username of the reseller
+      def revoke(params)
+        params[:key] = 'attributes'
+
+        run_command :revoke, :domain, params
+      end
+
+      # Submits a domain contact information update
+      #
+      # ==== Required
+      #  * <tt>:domain</tt> - domain name to update the contacts of
+      #  * <tt>:contacts</tt> - contact set with updated values
+      #  * <tt>:types</tt> - list of contact types that are to be updated
+      def update_contacts(params)
+        params[:types] = index_array(params[:types])
+
+        params[:contact_set] = params.delete :contacts
+        params[:key] = 'attributes'
+
+        run_command :update_contacts, :domain, params
+      end
+
+      # Submits a new registration request or transfer order
+      #
+      # ==== Required
+      #  * <tt>:domain</tt> - domain name to register
+      #  * <tt>:contacts</tt> - contact set for the domain
+      #  * <tt>:nameservers</tt> - array of nameservers
+      #
+      # ==== Optional
+      #  * <tt>:term</tt> - number of years to register the domain for
+      #  * <tt>:options</tt> - additional attributes to set
+      def register_domain(attribs)
+        Args.new(attribs) do |c|
+          c.requires :domain, :contacts, :nameservers
+          c.optionals :term, :options
+        end
+
+        attribs[:term] = 1 unless attribs[:term]
+        nameservers = format_nameservers(attribs[:nameservers])
+
+        attributes = {
+          :contact_set => attribs[:contacts],
+          :custom_nameservers => 1,
+          :custom_tech_contact => 1,
+          :domain => attribs[:domain],
+          :nameserver_list => nameservers,
+          :period => attribs[:term],
+          :reg_username => @user,
+          :reg_password => @password
+        }
+
+        attributes[:reg_type] = :new unless attribs[:options] && attribs[:options][:reg_type]
+        attributes.merge!(attribs[:options]) if attribs[:options]
+        attributes[:key] = 'attributes'
+
+        res = run_command :sw_register, :domain, attributes
+      end
+
+      # Submits a new registration request or transfer order
+      #
+      # ==== Required
+      #  * <tt>:csr</tt> - certificate signing request
+      #  * <tt>:contacts</tt> - contact set for the trust service
+      #
+      # ==== Optional
+      #  * <tt>:attribs</tt> - additional attributes to set
+      #  * <tt>:term</tt> - number of years to register the trust service for
+      def register_trust_service(params)
+        params[:period] = params.delete :term
+        params[:period] = 1 unless params[:period]
+        params[:reg_type] = 'new' unless params[:reg_type]
+        params[:handle] = 'process' unless params[:handle]
+        params[:contact_set] = params.delete :contacts
+        params[:key] = 'attributes'
+
+        run_command :sw_register, :trust_service, params
+      end
+
+      private
+
+      def format_nameservers(nameservers)
+        [
+          "0".to_sym => {
+            :sortorder => 1,
+            :name => nameservers.first
+          },
+          "1".to_sym => {
+            :sortorder => 2,
+            :name => nameservers.size == 2 ? nameservers[1] : nameservers.first
+          },
+        ]
+      end
+    end
+  end
+end

data/lib/moo_moo/opensrs/response.rb

@@ -0,0 +1,41 @@
+module MooMoo
+  module OpenSRS
+    class Response
+      # Constructor
+      #
+      # ==== Required
+      #  * <tt>:hash</tt> - hash of the response
+      #
+      # ==== Optional
+      #  * <tt>:key</tt> - primary key to use when indexing the hash
+      def initialize(hash, key = nil)
+        @hash = hash
+        @key = key
+      end
+
+      # Returns whether or not the command executed was successful
+      #
+      def success?
+        @hash['is_success'].nil? ? true : @hash['is_success'].to_i == 1
+      end
+
+      # Returns the error message if one is present
+      #
+      def error_msg
+        @hash['response_text']
+      end
+
+      # Returns the response code if one is present
+      #
+      def error_code
+        @hash['response_code'].to_i
+      end
+
+      # Returns the result hash
+      #
+      def result
+        @key.nil? ? @hash : @hash[@key]
+      end
+    end
+  end
+end

data/lib/moo_moo/opensrs/transfer_commands.rb

@@ -0,0 +1,83 @@
+module MooMoo
+  module OpenSRS
+    module TransferCommands
+      # Cancels a transfer that is pending owner approval
+      #
+      # ==== Required
+      #  * <tt>:domain</tt> - domain name that is being transferred
+      #  * <tt>:reseller</tt> - username of the reseller
+      def cancel_transfer(params)
+        run_command :cancel_transfer, :transfer, params
+      end
+
+      # Cancels a transfer that is pending owner approval by order ID
+      #
+      # ==== Required
+      #  * <tt>:order_id</tt> - ID of the order
+      #  * <tt>:reseller</tt> - username of the reseller
+      def cancel_transfer_for_order(params)
+        run_command :cancel_transfer, :transfer, params
+      end
+
+      # Checks to see if the given domain can be transferred
+      #
+      # ==== Required
+      #  * <tt>:domain</tt> - domain name to check
+      def check_transfer(domain)
+        run_command :check_transfer, :domain, {
+          :domain => domain,
+          :key => 'attributes'
+        }
+      end
+
+      # Lists all domains that have been transferred away
+      #
+      def get_transfers_away
+        run_command :get_transfers_away, :domain, {
+          :key => 'attributes'
+        }
+      end
+
+      # Lists all domains that have been transferred in
+      def get_transfers_in
+        run_command :get_transfers_in, :domain, {
+          :key => 'attributes'
+        }
+      end
+
+      # Creates a new order with the same data as a cancelled order
+      #
+      # ==== Required
+      #  * <tt>:order_id</tt> - ID of the cancelled order
+      #  * <tt>:reseller</tt> - username of the reseller
+      def process_transfer(params)
+        params[:key] = 'attributes'
+
+        run_command :process_transfer, :transfer, params
+      end
+
+      # Resends an e-mail to the admin contact for the transfer that is in 'pending owner approval' state
+      #
+      # ==== Required
+      #  * <tt>:domain</tt> - domain name being transferred
+      def send_password(domain)
+        run_command :send_password, :transfer, {
+          :domain_name => domain
+        }
+      end
+
+      # Transfers a domain name from one reseller to another
+      #
+      # ==== Required
+      #  * <tt>:domain</tt> - domain name to transfer
+      #  * <tt>:username</tt> - username of the registrant
+      #  * <tt>:password</tt> - password of the registrant
+      #  * <tt>:reseller</tt> - name of the gaining reseller
+      def push_transfer(params)
+        params[:grsp] = params.delete :reseller
+
+        run_command :rsp2rsp_push_transfer, nil, params
+      end
+    end
+  end
+end

data/lib/moo_moo/opensrs/utils.rb

@@ -0,0 +1,13 @@
+module MooMoo
+  module OpenSRS
+    module Utils
+      def try_opensrs
+        begin
+          yield
+        rescue Exception => e
+          raise OpenSRSException, e.message
+        end
+      end
+    end
+  end
+end

data/lib/moo_moo/opensrs.rb

@@ -0,0 +1,8 @@
+module MooMoo
+  autoload :Args, 'moo_moo/opensrs/args'
+
+  module OpenSRS
+    autoload :Base, 'moo_moo/opensrs/base'
+    autoload :Response, 'moo_moo/opensrs/response'
+  end
+end

data/lib/moo_moo/version.rb

@@ -0,0 +1,3 @@
+module MooMoo
+  VERSION = Version = "0.1.0"
+end

data/lib/moo_moo.rb

@@ -0,0 +1,16 @@
+module MooMoo
+  autoload :Version, 'moo_moo/version'
+  autoload :Config,  'moo_moo/config'
+  autoload :OpenSRS, 'moo_moo/opensrs'
+
+  class << self
+    attr_accessor :config
+  end
+
+  def self.configure
+    yield config if block_given?
+    config
+  end
+
+  self.config = Config.new
+end

data/moo_moo.gemspec

@@ -0,0 +1,33 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require 'moo_moo/version'
+
+Gem::Specification.new do |s|
+  s.name        = "moo_moo"
+  s.version     = MooMoo::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Tim Parkin"]
+  s.email       = ["tparkin@site5.com"]
+  s.homepage    = ""
+  s.summary     = %q{Implements OpenSRS XML API}
+  s.description = %q{Implements OpenSRS XML API}
+
+  s.rubyforge_project = "opensrs"
+
+  s.add_runtime_dependency('jruby-openssl', '~> 0.7.3') if RUBY_PLATFORM == 'java'
+  s.add_development_dependency 'rake', '~> 0.8.7'
+  s.add_development_dependency 'rspec', '~> 2.5.0'
+  s.add_development_dependency 'fakeweb', '~> 1.3.0'
+  s.add_development_dependency 'vcr', '~> 1.9.0'
+  if !defined?(RUBY_ENGINE) || RUBY_ENGINE != 'rbx'
+    s.add_development_dependency 'rcov', '>= 0.9.9'
+    s.add_development_dependency 'metric_fu', '>= 2.1.1'
+  end
+
+  s.add_dependency 'extlib'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/spec/moo_moo_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe MooMoo do
+  describe "::Version" do
+    it "has a valid version" do
+      MooMoo::Version.should match /\d+\.\d+\.\d+/
+    end
+  end
+
+  describe "::configure" do
+    it { MooMoo.configure.should be_a MooMoo::Config }
+  end
+
+  describe "::config" do
+    it { MooMoo.should have_attr_accessor :config }
+  end
+end

data/spec/opensrs/args_spec.rb

@@ -0,0 +1,179 @@
+require 'spec_helper'
+require 'moo_moo/opensrs/args'
+
+module MooMoo
+  describe MooMoo::Args do
+    context "required_parms" do
+      it "raises an error when missing" do
+        options = {:arg1 => true}
+        args = lambda { 
+          MooMoo::Args.new(options) do |c|
+            c.requires :arg2
+          end
+        }
+        expect { args.call }.to raise_error(MooMooArgumentError, /Missing required parameter: arg2/)
+      end
+
+      it "does not raise an error with valid params" do
+        options = {:arg1 => true}
+        args =  MooMoo::Args.new(options) { |c|
+          c.requires :arg1
+        }
+
+        args.required_params.should have(1).value
+        args.required_params.should include(:arg1)
+      end
+
+      it "sets optional_params" do
+        options = {:arg1 => true, :arg2 => 2}
+        args =  MooMoo::Args.new(options) { |c|
+          c.requires :arg1, :arg2
+        }
+
+        args.optional_params.should have(2).values
+        args.required_params.should have(2).values
+
+        args.optional_params.should include(*args.required_params)
+      end
+
+      it "does not set boolean_params" do
+        options = {:arg1 => true, :arg2 => 2}
+        args =  MooMoo::Args.new(options) { |c|
+          c.requires :arg1, :arg2
+        }
+
+        args.boolean_params.should be_empty
+      end
+    end
+
+    context "boolean_params" do
+      it "raises an error when the param is not boolean" do
+        options = {:arg1 => 'string'}
+        args = lambda { 
+          MooMoo::Args.new(options) do |c|
+            c.booleans :arg1
+          end
+        }
+        expect { args.call }.to raise_error(MooMooArgumentError, /Boolean parameter must be.*: arg1/)
+      end
+
+      it "raises an error with boolean params" do
+        options = {:arg1 => true}
+        args =  MooMoo::Args.new(options) { |c|
+          c.booleans :arg1
+        }
+
+        args.boolean_params.should have(1).value
+        args.boolean_params.should include(:arg1)
+      end
+
+      it "sets optional_params" do
+        options = {:arg1 => true, :arg2 => false}
+        args =  MooMoo::Args.new(options) { |c|
+          c.booleans :arg1, :arg2
+        }
+
+        args.optional_params.should have(2).values
+        args.boolean_params.should have(2).values
+
+        args.optional_params.should include(:arg1, :arg2)
+      end
+
+      it "sets required_params" do
+        options = {:arg1 => true, :arg2 => false}
+        args =  MooMoo::Args.new(options) { |c|
+          c.booleans :arg1, :arg2
+        }
+
+        args.required_params.should be_empty
+      end
+    end
+
+    context "optional_params" do
+      it "raises an error with unknown params" do
+        options = {:arg1 => true}
+        args = lambda { 
+          MooMoo::Args.new(options) do |c|
+            c.optionals :arg2
+          end
+        }
+
+        expect { args.call }.to raise_error(MooMooArgumentError, /Not a valid parameter: arg1/)
+      end
+
+      it "does not raise an error with known params" do
+        options = {:arg1 => true, :arg2 => 2}
+        args =  MooMoo::Args.new(options) { |c|
+          c.optionals :arg1, :arg2
+        }
+
+        args.optional_params.should have(2).values
+        args.optional_params.should include(:arg1, :arg2)
+      end
+
+      it "does not set required_params" do
+        options = {:arg1 => true, :arg2 => 2}
+        args =  MooMoo::Args.new(options) { |c|
+          c.optionals :arg1, :arg2
+        }
+        
+        args.required_params.should be_empty
+      end
+
+      it "does not set boolean_params" do
+        options = {:arg1 => true, :arg2 => 2}
+        args =  MooMoo::Args.new(options) { |c|
+          c.optionals :arg1, :arg2
+        }
+        
+        args.boolean_params.should be_empty
+      end
+    end
+
+    context "one_of" do
+      it "allows one arg" do
+        options = {:arg1 => true}
+        args = lambda {
+          MooMoo::Args.new(options) do |c|
+            c.one_of :arg1
+          end
+        }
+
+        expect { args.call }.to raise_error(MooMooArgumentError, /One of requires two or more items/)
+      end
+
+      it "allows two or more args" do
+        options = {:arg1 => true}
+
+        args = MooMoo::Args.new(options) do |c|
+          c.one_of :arg1, :arg2
+        end
+
+        args.one_of_params.should have(2).values
+        args.one_of_params.should include(:arg1, :arg2)
+      end
+
+      it "does not allow 0 params" do
+        options = {}
+        args = lambda {
+          MooMoo::Args.new(options) do |c|
+            c.one_of :arg1, :arg2
+          end
+        }
+
+        expect { args.call }.to raise_error(MooMooArgumentError, /The parameters may include only one of 'arg1, arg2'/)
+      end
+
+      it "does not allow both args" do
+        options = {:arg1 => true, :arg2 => 2}
+        args = lambda {
+          MooMoo::Args.new(options) do |c|
+            c.one_of :arg1, :arg2
+          end
+        }
+
+        expect { args.call }.to raise_error(MooMooArgumentError, /The parameters may include only one of 'arg1, arg2'/)
+      end
+    end
+  end
+end

data/spec/opensrs/cookie_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+require 'moo_moo/opensrs'
+
+module MooMoo
+
+  describe OpenSRS do
+    before(:each) do
+      def random_domain
+        "domainthatsnottaken#{Time.now.to_i}.com"
+      end
+
+      @opensrs = OpenSRS::Base.new
+      @registered_domain = "domainthatsnottaken1302209138.com"
+    end
+
+    describe "CookieCommands" do
+      describe "#set_cookie" do
+        it "sets the cookie" do
+          VCR.use_cassette("cookie/set_cookie") do
+            res = @opensrs.set_cookie(:username => MooMoo.config.user,
+                                      :password => MooMoo.config.pass,
+                                      :domain => @registered_domain)
+            res.success?.should be_true
+            res.result['cookie'].should == "0000000000000000:000000:00000"
+          end
+        end
+
+        it "fails to set the cookie" do
+          VCR.use_cassette("cookie/set_cookie_fail") do
+            res = @opensrs.set_cookie(:username => MooMoo.config.user,
+                                      :password => 'password',
+                                      :domain => 'example.com')
+            res.success?.should be_false
+            res.error_code.should == 415
+          end
+        end
+      end
+
+      describe "#delete_cookie" do
+        use_vcr_cassette "cookie/delete_cookie"
+
+        it "destroys the cookie" do
+          res = @opensrs.set_cookie(:username => MooMoo.config.user,
+                                    :password => MooMoo.config.pass,
+                                    :domain => @registered_domain)
+          res = @opensrs.delete_cookie(res.result['cookie'])
+          res.success?.should be_true
+        end
+      end
+
+      describe "#update_cookie" do
+        use_vcr_cassette "cookie/update_cookie"
+
+        it "updates the cookie's domain" do
+          res = @opensrs.set_cookie(:username => MooMoo.config.user,
+                                    :password => MooMoo.config.pass,
+                                    :domain => @registered_domain)
+          res = @opensrs.update_cookie(
+            :old_domain => @registered_domain, 
+            :new_domain => @registered_domain, 
+            :cookie => res.result['cookie'])
+          res.success?.should be_true
+          res.result['domain_count'].to_i.should == 1
+        end
+      end
+
+      describe "#quit_session" do
+        use_vcr_cassette "cookie/quit_session"
+
+        it "quits the session" do
+          res = @opensrs.quit_session
+          res.success?.should be_true
+        end
+      end
+    end
+
+  end
+end