moo_moo 0.1.0 → 0.1.1

data/.travis.yml

@@ -1,9 +1,11 @@
-script: "rake"
+script: "bundle exec rake spec"
 notifications:
   disabled: true
 rvm:
   - 1.8.7
   - 1.9.2
+  - 1.9.3
   - ree
   - rbx
+  - rbx-head
   - jruby

data/README.md

@@ -1,27 +1,42 @@
-MooMoo
-======
+MooMoo [![MooMoo Build Status][Build Icon]][Build Status]
+=========================================================
 
-Ruby library for using the Tucows OpenSRS XML API
+MooMoo is a Ruby library for working with the [Tucows OpenSRS XML API][].
+
+MooMoo has been tested on MRI 1.8.7, MRI 1.9.2, MRI 1.9.3 Preview 1,
+Rubinius 2.0.0pre, and JRuby 1.6.2.
+
+Documentation is available in [RDoc][] format.
+
+[Build Status]: http://travis-ci.org/site5/moo_moo
+[Build Icon]: https://secure.travis-ci.org/site5/moo_moo.png?branch=master
+[Tucows OpenSRS XML API]: http://www.opensrs.com/site/resources/documentation
+[RDoc]: http://rdoc.info/github/site5/moo_moo/master/frames
 
 Description
-==========
+-----------
 
 Implements most of the functionality of the OpenSRS XML API. For full
 documentation of the OpenSRS XML API see
-http://opensrs.com/docs/opensrsxmlapi/index.htm
+<http://www.opensrs.com/site/resources/documentation>
 
 Usage
-=====
+-----
 
 First, create an opensrs object from which all commands are called:
 
-    opensrs = MooMoo::OpenSRS::Base.new("horizon.opensrs.net", "<YOUR_KEY>", "<YOUR_RESELLER_USER>", "<YOUR_PASSWORD>")
+    opensrs = MooMoo::OpenSRS::Base.new(
+      "horizon.opensrs.net",
+      "<YOUR_KEY>",
+      "<YOUR_RESELLER_USER>",
+      "<YOUR_PASSWORD>"
+    )
 
 Or configure MooMoo and you can initialize it without any arguments:
 
     MooMoo.configure do |config|
       config.host = "horizon.opensrs.net"
-      config.key = "<YOUR_KEY>"
+      config.key  = "<YOUR_KEY>"
       config.user = "<YOUR_RESELLER_USER>"
       config.pass = "<YOUR_PASSWORD>"
     end
@@ -40,13 +55,13 @@ Here's how to check the availability of a domain name:
     true
     taken
 
-Each method returns an OpenSRSResponse object which you can
-use to determine if the call was successful and retrieve the response code
-and/or error message. The result variable is a hash that contains all of the
-relevant data returned by the call.
+Each method returns an `OpenSRSResponse` object which you can use to determine
+if the call was successful and retrieve the response code and/or error
+message. The result variable is a hash that contains all of the relevant data
+returned by the call.
 
 Note on Patches/Pull Requests
-=======
+-----------------------------
 
 * Fork the project.
 * Make your feature addition or bug fix.
@@ -58,6 +73,6 @@ Note on Patches/Pull Requests
 * Send me a pull request. Bonus points for topic branches.
 
 Copyright
-=========
+---------
 
 Copyright (c) 2011 Site5 LLC. See LICENSE for details.

data/lib/moo_moo/exceptions.rb

@@ -0,0 +1,4 @@
+module MooMoo
+  class MooMooArgumentError < ArgumentError; end
+  class OpenSRSException < Exception; end
+end

data/lib/moo_moo/opensrs/args.rb

@@ -1,108 +1,108 @@
 module MooMoo
-  class MooMooArgumentError < ArgumentError; end
-
-  class Args
-    attr_reader :required_params, :boolean_params, :optional_params, :one_of_params
-    attr_reader :options
-    # Check the included hash for the included parameters.
-    # Raises MooMooArgumentError when it's mising the proper params
-    #
-    # ==== Example
-    # 
-    #    Args.new(options) do |c|
-    #      c.requries  :user, :pass
-    #      c.booleans  :name
-    #      c.optionals :whatever
-    #    end
-    def initialize(options)
-      @required_params ||= []
-      @boolean_params  ||= []
-      @optional_params ||= []
-      @one_of_params   ||= []
-      @options = options
-
-      yield self
-
-      requires!
-      booleans!
-      one_ofs!
-      valid_options!
-    end
+  module OpenSRS
+    class Args
+      attr_reader :required_params, :boolean_params, :optional_params, :one_of_params
+      attr_reader :options
+      # Check the included hash for the included parameters.
+      # Raises MooMooArgumentError when it's mising the proper params
+      #
+      # ==== Example
+      #
+      #    Args.new(options) do |c|
+      #      c.requries  :user, :pass
+      #      c.booleans  :name
+      #      c.optionals :whatever
+      #    end
+      def initialize(options)
+        @required_params ||= []
+        @boolean_params  ||= []
+        @optional_params ||= []
+        @one_of_params   ||= []
+        @options = options
+
+        yield self
+
+        requires!
+        booleans!
+        one_ofs!
+        valid_options!
+      end
 
-    # Specifies the required arguments
-    def requires(*values)
-      @optional_params.concat(values)
-      @required_params = values
-    end
+      # Specifies the required arguments
+      def requires(*values)
+        @optional_params.concat(values)
+        @required_params = values
+      end
 
-    # Specifies which arguments are boolean
-    def booleans(*values)
-      @optional_params.concat(values)
-      @boolean_params = values
-    end
+      # Specifies which arguments are boolean
+      def booleans(*values)
+        @optional_params.concat(values)
+        @boolean_params = values
+      end
 
-    # Specifies which arguments are optional
-    def optionals(*values)
-      @optional_params.concat(values)
-    end
+      # Specifies which arguments are optional
+      def optionals(*values)
+        @optional_params.concat(values)
+      end
 
-    # Specifies which arguments take one of a set of arguments
-    def one_of(*values)
-      @optional_params.concat(values)
-      @one_of_params = values
-    end
+      # Specifies which arguments take one of a set of arguments
+      def one_of(*values)
+        @optional_params.concat(values)
+        @one_of_params = values
+      end
 
-    protected
+      protected
 
-    # Verifies that all required arguments are present
-    def requires!
-      @required_params.each do |param|
-        key = (param.is_a?(Array) ? param.first : param)
-        verify_required_param(key)
+      # Verifies that all required arguments are present
+      def requires!
+        @required_params.each do |param|
+          key = (param.is_a?(Array) ? param.first : param)
+          verify_required_param(key)
+        end
       end
-    end
 
 
-    # Checks to see if supplied params (which are booleans) contain
-    # either a 1 ("Yes") or 0 ("No") value.
-    def booleans!
-      @boolean_params.each do |param|
-        key = (param.is_a?(Array) ? param.first : param)
-        verify_boolean_param(key)
+      # Checks to see if supplied params (which are booleans) contain
+      # either a 1 ("Yes") or 0 ("No") value.
+      def booleans!
+        @boolean_params.each do |param|
+          key = (param.is_a?(Array) ? param.first : param)
+          verify_boolean_param(key)
+        end
       end
-    end
 
-    # Verifies that only valid arguments were set
-    def valid_options!
-      @options.keys.uniq.each do |key|
-        raise MooMoo::MooMooArgumentError.new("Not a valid parameter: #{key}") unless @optional_params.include?(key)
+      # Verifies that only valid arguments were set
+      def valid_options!
+        @options.keys.uniq.each do |key|
+          raise MooMoo::MooMooArgumentError.new("Not a valid parameter: #{key}") unless @optional_params.include?(key)
+        end
       end
-    end  
 
-    # Verifies that the one_of arguments were used correctly
-    def one_ofs!
-      if @one_of_params.size > 1
-        specified = @options.keys.select { |key| @one_of_params.include?(key) }.uniq
-        if specified.size > 1 || specified.size == 0
-          raise MooMoo::MooMooArgumentError.new("The parameters may include only one of '#{@one_of_params.join(', ')}'")
+      # Verifies that the one_of arguments were used correctly
+      def one_ofs!
+        if @one_of_params.size > 1
+          specified = @options.keys.select { |key| @one_of_params.include?(key) }.uniq
+          if specified.size > 1 || specified.size == 0
+            raise MooMoo::MooMooArgumentError.new("The parameters may include only one of '#{@one_of_params.join(', ')}'")
+          end
+        else
+          raise MooMoo::MooMooArgumentError.new("One of requires two or more items") unless @one_of_params.empty?
         end
-      else
-        raise MooMoo::MooMooArgumentError.new("One of requires two or more items") unless @one_of_params.empty?
       end
-    end
 
-    private
+      private
 
-    # Internal method for verifiying required arguments
-    def verify_required_param(param)
-      raise MooMoo::MooMooArgumentError.new("Missing required parameter: #{param}") unless @options.has_key?(param)
-      raise MooMoo::MooMooArgumentError.new("Required parameter cannot be blank: #{param}") if (@options[param].nil? || (@options[param].respond_to?(:empty?) && @options[param].empty?))
-    end
+      # Internal method for verifiying required arguments
+      def verify_required_param(param)
+        raise MooMoo::MooMooArgumentError.new("Missing required parameter: #{param}") unless @options.has_key?(param)
+        raise MooMoo::MooMooArgumentError.new("Required parameter cannot be blank: #{param}") if (@options[param].nil? || (@options[param].respond_to?(:empty?) && @options[param].empty?))
+      end
 
-    # Internal method for verifying boolean arguments
-    def verify_boolean_param(param)
-      if @options.include?(param) && ![true, false].include?(@options[param])
-        raise MooMoo::MooMooArgumentError.new("Boolean parameter must be \"true\" or \"false\": #{param}")
+      # Internal method for verifying boolean arguments
+      def verify_boolean_param(param)
+        if @options.include?(param) && ![true, false].include?(@options[param])
+          raise MooMoo::MooMooArgumentError.new("Boolean parameter must be \"true\" or \"false\": #{param}")
+        end
       end
     end
   end

data/lib/moo_moo/opensrs/base.rb

@@ -1,21 +1,11 @@
 module MooMoo
   module OpenSRS
-    autoload :OpenSRSException, 'moo_moo/opensrs/opensrsexception'
-    autoload :Command, 'moo_moo/opensrs/command'
-    autoload :Utils, 'moo_moo/opensrs/utils'
-    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'
-
     class Base
       include LookupCommands
       include ProvisioningCommands
       include TransferCommands
       include NameserverCommands
       include CookieCommands
-      include Utils
 
       attr_reader :host, :key, :user, :pass, :port
 
@@ -31,7 +21,7 @@ module MooMoo
       #  * <tt>:port</tt> - port to connect on
       def initialize(host = nil, key = nil, user = nil, pass = nil, port = 55443)
         @host = host || MooMoo.config.host
-        @key = key || MooMoo.config.key
+        @key  = key  || MooMoo.config.key
         @user = user || MooMoo.config.user
         @pass = pass || MooMoo.config.pass
         @port = port || MooMoo.config.port
@@ -70,6 +60,14 @@ module MooMoo
 
         arr_indexed
       end
+
+      def try_opensrs
+        begin
+          yield
+        rescue Exception => e
+          raise OpenSRSException, e.message
+        end
+      end
     end
   end
 end

data/lib/moo_moo/opensrs.rb

@@ -1,8 +1,13 @@
 module MooMoo
-  autoload :Args, 'moo_moo/opensrs/args'
-
   module OpenSRS
-    autoload :Base, 'moo_moo/opensrs/base'
-    autoload :Response, 'moo_moo/opensrs/response'
+    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/lib/moo_moo/version.rb

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

data/lib/moo_moo.rb

@@ -1,3 +1,5 @@
+require 'moo_moo/exceptions'
+
 module MooMoo
   autoload :Version, 'moo_moo/version'
   autoload :Config,  'moo_moo/config'

data/moo_moo.gemspec

@@ -15,14 +15,10 @@ Gem::Specification.new do |s|
   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 'rake', '~> 0.9.2.2'
+  s.add_development_dependency 'rspec', '~> 2.8.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_development_dependency 'vcr', '~> 1.11.3'
 
   s.add_dependency 'extlib'
 

data/spec/moo_moo/config_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe MooMoo::Config do
+  before :each do
+    @config = MooMoo::Config.new
+  end
+
+  it { @config.should have_attr_accessor :host }
+  it { @config.should have_attr_accessor :key  }
+  it { @config.should have_attr_accessor :user }
+  it { @config.should have_attr_accessor :pass }
+end

data/spec/moo_moo/opensrs/args_spec.rb

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

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

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