moo_moo 0.1.1 → 0.2.0

data/lib/moo_moo/opensrs/provisioning_commands.rb

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

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

@@ -1,83 +0,0 @@
-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.rb

@@ -1,13 +0,0 @@
-module MooMoo
-  module OpenSRS
-    autoload :Args,                 'moo_moo/opensrs/args'
-    autoload :Base,                 'moo_moo/opensrs/base'
-    autoload :Command,              'moo_moo/opensrs/command'
-    autoload :LookupCommands,       'moo_moo/opensrs/lookup_commands'
-    autoload :ProvisioningCommands, 'moo_moo/opensrs/provisioning_commands'
-    autoload :TransferCommands,     'moo_moo/opensrs/transfer_commands'
-    autoload :NameserverCommands,   'moo_moo/opensrs/nameserver_commands'
-    autoload :CookieCommands,       'moo_moo/opensrs/cookie_commands'
-    autoload :Response,             'moo_moo/opensrs/response'
-  end
-end

data/spec/moo_moo/opensrs/args_spec.rb

@@ -1,176 +0,0 @@
-require 'spec_helper'
-
-describe MooMoo::OpenSRS::Args do
-  context "#required_parms" do
-    it "raises an error when missing" do
-      options = {:arg1 => true}
-      args = lambda {
-        MooMoo::OpenSRS::Args.new(options) do |c|
-          c.requires :arg2
-        end
-      }
-      expect { args.call }.to raise_error(MooMoo::MooMooArgumentError, /Missing required parameter: arg2/)
-    end
-
-    it "does not raise an error with valid params" do
-      options = {:arg1 => true}
-      args =  MooMoo::OpenSRS::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::OpenSRS::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::OpenSRS::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::OpenSRS::Args.new(options) do |c|
-          c.booleans :arg1
-        end
-      }
-      expect { args.call }.to raise_error(MooMoo::MooMooArgumentError, /Boolean parameter must be.*: arg1/)
-    end
-
-    it "raises an error with boolean params" do
-      options = {:arg1 => true}
-      args =  MooMoo::OpenSRS::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::OpenSRS::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::OpenSRS::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::OpenSRS::Args.new(options) do |c|
-          c.optionals :arg2
-        end
-      }
-
-      expect { args.call }.to raise_error(MooMoo::MooMooArgumentError, /Not a valid parameter: arg1/)
-    end
-
-    it "does not raise an error with known params" do
-      options = {:arg1 => true, :arg2 => 2}
-      args =  MooMoo::OpenSRS::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::OpenSRS::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::OpenSRS::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::OpenSRS::Args.new(options) do |c|
-          c.one_of :arg1
-        end
-      }
-
-      expect { args.call }.to raise_error(MooMoo::MooMooArgumentError, /One of requires two or more items/)
-    end
-
-    it "allows two or more args" do
-      options = {:arg1 => true}
-
-      args = MooMoo::OpenSRS::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::OpenSRS::Args.new(options) do |c|
-          c.one_of :arg1, :arg2
-        end
-      }
-
-      expect { args.call }.to raise_error(MooMoo::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::OpenSRS::Args.new(options) do |c|
-          c.one_of :arg1, :arg2
-        end
-      }
-
-      expect { args.call }.to raise_error(MooMoo::MooMooArgumentError, /The parameters may include only one of 'arg1, arg2'/)
-    end
-  end
-end

data/spec/moo_moo/opensrs/base_spec.rb

@@ -1,22 +0,0 @@
-require 'spec_helper'
-
-describe MooMoo::OpenSRS::Base do
-  describe "included modules" do
-    subject { MooMoo::OpenSRS::Base }
-    it { should include MooMoo::OpenSRS::CookieCommands }
-    it { should include MooMoo::OpenSRS::LookupCommands }
-    it { should include MooMoo::OpenSRS::NameserverCommands }
-    it { should include MooMoo::OpenSRS::ProvisioningCommands }
-    it { should include MooMoo::OpenSRS::TransferCommands }
-  end
-
-  describe "#try_opensrs" do
-    it "raises an OpenSRSException" do
-      expect do
-        MooMoo::OpenSRS::Base.new.instance_eval do
-          try_opensrs { raise "Exception message" }
-        end
-      end.to raise_error MooMoo::OpenSRSException
-    end
-  end
-end

data/spec/moo_moo/opensrs/cookie_spec.rb

@@ -1,76 +0,0 @@
-require 'spec_helper'
-
-describe MooMoo::OpenSRS::CookieCommands do
-  before(:each) do
-    @opensrs = MooMoo::OpenSRS::Base.new
-    @registered_domain = "domainthatsnottaken1302209138.com"
-  end
-
-  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