snuggie 0.1.0

data/README.markdown

@@ -0,0 +1,98 @@
+# Snuggie [![Build Status](http://travis-ci.org/site5/snuggie.png)][Build Status]
+
+Snuggie wraps the Softaculous API in a warm, loving ruby embrace.
+
+Snuggie has been tested on on MRI 1.8.4, MRI 1.8.7, MRI 1.9.2,
+Rubinius 2.0.0pre, and JRuby 1.6.2.
+
+[Build Status]: http://travis-ci.org/site5/snuggie
+
+## Installation
+
+    gem install snuggie
+
+## Usage
+
+Create a new `Snuggie::NOC` object with your credentials:
+
+    noc = Snuggie::NOC.new(
+      :username => 'marty',
+      :password => 'mcSUPERfly'
+    )
+
+Your Softaculous credentials can also be configured globally:
+
+    Snuggie.configure do |config|
+      config.username = 'marty'
+      config.password = 'mcSUPERfly'
+    end
+
+    noc = Snuggie::NOC.new
+
+Buy/renew a license
+
+    noc.buy_license(
+      :ip            => '127.0.0.1',
+      :months_to_add => 1,
+      :server_type   => :dedicated,
+      :auth_email    => 'marty@hilldale.edu',
+      :auto_renew    => true
+    )
+
+Refund a transaction
+
+    noc.refund :action_id => 99999
+
+List all licenses
+
+    noc.list_licenses
+
+List licenses by IP
+
+    noc.list_licenses :ip => '127.0.0.1'
+
+List all expired licenses
+
+    noc.list_licenses :expired => 1
+
+List licenses expiring in 7 days
+
+    noc.list_licenses :expired => 2
+
+List licenses expiring in 15 days
+
+    noc.list_licenses :expired => 3
+
+Get invoice details
+
+    noc.invoice_details :invoice_id => 99999
+
+Get unbilled transactions for the current month:
+
+    noc.invoice_details
+
+Cancel a license by key
+
+    noc.cancel_license :key => 'XXXXX-XXXXX-XXXXX-XXXXX-XXXXX'
+
+Cancel a license by IP
+
+    noc.cancel_license :ip => '127.0.0.1'
+
+Get Action/Activity logs for a license
+
+    noc.license_logs :key => 'XXXXX-XXXXX-XXXXX-XXXXX-XXXXX'
+
+## Note on Patches/Pull Requests
+
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a future version
+  unintentionally.
+* Commit, do not bump version. (If you want to have your own version, that is
+  fine but bump version in a commit by itself I can ignore when I pull.)
+* Send me a pull request. Bonus points for topic branches.
+
+## Copyright
+
+Copyright (c) 2011 Site5 LLC. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,31 @@
+$:.unshift 'lib'
+
+require 'rake/testtask'
+
+Rake::TestTask.new do |test|
+  test.libs << "test"
+  test.test_files = FileList['test/**/*_test.rb']
+end
+
+task :default => :test
+
+desc "Open an irb session preloaded with this library"
+task :console do
+  sh "irb -rubygems -r ./lib/snuggie.rb -I ./lib"
+end
+
+desc "Push a new version to rubygems.org"
+task :publish do
+  require 'snuggie/version'
+
+  ver = Snuggie::Version
+
+  mkdir("pkg") unless File.exists?("pkg")
+
+  sh "gem build snuggie.gemspec"
+  sh "gem push snuggie-#{ver}.gem"
+  sh "git tag -a -m 'Snuggie v#{ver}' v#{ver}"
+  sh "git push origin v#{ver}"
+  sh "git push origin master"
+  sh "mv snuggie-#{ver}.gem pkg"
+end

data/lib/snuggie.rb

@@ -0,0 +1,17 @@
+module Snuggie
+  autoload :Version, "snuggie/version"
+  autoload :Errors,  "snuggie/errors"
+  autoload :Config,  "snuggie/config"
+  autoload :NOC,     "snuggie/noc"
+
+  class << self
+    attr_accessor :config
+  end
+
+  def self.configure
+    yield config if block_given?
+    config
+  end
+
+  self.config = Config.new
+end

data/lib/snuggie/config.rb

@@ -0,0 +1,10 @@
+module Snuggie
+  # The Snuggie::Config class stores your Softaculous API credentials
+  class Config
+    # Your Softaculous username
+    attr_accessor :username
+
+    # Your Softaculous password
+    attr_accessor :password
+  end
+end

data/lib/snuggie/errors.rb

@@ -0,0 +1,6 @@
+module Snuggie
+  module Errors
+    class MissingArgument < ArgumentError
+    end
+  end
+end

data/lib/snuggie/noc.rb

@@ -0,0 +1,276 @@
+require 'cgi'
+require 'net/http'
+require 'php_serialize'
+
+module Snuggie
+  # Snuggie::NOC is the main class for communicating with the
+  # Softaculous NOC API.
+  class NOC
+
+    # The Softaculous NOC API lives here
+    API_URL = 'http://www.softaculous.com/noc'
+
+    # Creates a new Snuggie::NOC instance
+    #
+    # Params
+    #
+    #   * credentials - (Optional) a hash with :username, :password to
+    #                   be used to authenticate with Softaculous. If not
+    #                   provided, the Snuggie will try using those
+    #                   configured via `Snuggie#configure`
+    def initialize(credentials = {})
+      credentials = {
+        :username => Snuggie.config.username,
+        :password => Snuggie.config.password
+      } if credentials.empty? && Snuggie.config.username && Snuggie.config.password
+
+      @credentials = credentials
+    end
+
+    # Buy a license
+    #
+    # NOTE: You must specify either months_to_add or years_to_add
+    #
+    # Params
+    #
+    #   * ip             - The IP of the license to be Purchased or Renewed
+    #   * months_to_add  - Months to buy/renew the license for
+    #   * years_to_add   - Years to buy/renew the license for
+    #   * server_type    - Type of server used by this license, should be
+    #                      :dedicated or :vps
+    #   * auth_email     - When buying a new license, this is required to
+    #                      verify the owner of the License. This address will
+    #                      be used to send reminders when the license is
+    #                      expiring. Not required for renewals
+    #   * auto_renew     - Renew this license automatically before
+    #                      expiration. Set to true or false.
+    def buy_license(params = {})
+      params[:ips]        = params.delete(:ip)          if params[:ip]
+      params[:autorenew]  = params.delete(:auto_renew)  if params[:auto_renew]
+      params[:authemail]  = params.delete(:auth_email)  if params[:auth_email]
+      params[:servertype] = params.delete(:server_type) if params[:server_type]
+
+      if params[:months_to_add]
+        params[:toadd] = "#{params.delete(:months_to_add)}M"
+      elsif params[:years_to_add]
+        params[:toadd] = "#{params.delete(:years_to_add)}Y"
+      end
+
+      if [:dedicated, :vps].include?(params[:servertype])
+        params[:servertype] = params[:servertype] == :dedicated ? 1 : 2
+      end
+
+      if params.has_key?(:autorenew)
+        params[:autorenew] = params[:autorenew] === true ? 1 : 2
+      end
+
+      commit(params.merge!(:ca => :buy, :purchase => 1),
+        :require  => [:purchase, :ips, :toadd, :servertype, :autorenew]
+      )
+    end
+
+    # Refund a transaction
+    #
+    # NOTE: A refund can only be issued within 7 days of buying/renewing
+    # a license.
+    #
+    # Params
+    #
+    #   * action_id - The Action ID to clain a refund for
+    def refund(params = {})
+      params[:actid] = params.delete(:action_id) if params[:action_id]
+      params[:ca]    = :refund
+      commit(params, :require => [:actid])
+    end
+
+    # List licenses
+    #
+    # NOTE: All parameters are optional. If called without parameters, a
+    # list of all of your licenses will be returned.
+    #
+    # Params
+    #
+    #   * key    - (Optional) Search for a specific License by License Key
+    #   * ip     - (Optional) Search for a specific License by Primary IP
+    #   * expiry - (Optional) Fetch a list of Licenses that are expiring
+    #              Set to 1 to list all expired licenses on your account
+    #              Set to 2 to list licenses expiring in the next 7 days
+    #              Set to 3 to list licenses expiring in the next 15 days
+    #   * start  - (Optional) The starting point to return from
+    #              Eg: specify 99 if you have 500 licenses and want to
+    #              return licenses 100-500.
+    #   * limit  - (Optional) The length to limit the result set to
+    #              Eg: specify 100 if you have 500 licenses and want to
+    #              limit the result set to 100 items
+    def list_licenses(params = {})
+      params[:len] = params.delete(:limit) if params[:limit]
+      params[:ca]  = :licenses
+      commit(params)
+    end
+
+    # Cancel license
+    #
+    # NOTES:
+    # * Either ip or key needs to be specified
+    # * Cancellations are not allowed on licenses expiring more than 1
+    #   month in the future.
+    # * A refund is **NOT** applied when you cancel a license. You must
+    #   claim the refund using Snuggie::NOC#refund
+    #
+    # Params
+    #
+    #   * key - (Optional) The license key
+    #   * ip  - (Optional) The Primary IP of the license
+    def cancel_license(params = {})
+      params[:lickey] = params.delete(:key) if params[:key]
+      params[:licip]  = params.delete(:ip)  if params[:ip]
+      commit(params.merge!(:ca => :cancel, :cancel_license => 1),
+        :require_one => [:lickey, :licip]
+      )
+    end
+
+    # Edit IPs associated with a license
+    #
+    # Params
+    #
+    #   * license_id - The license ID (**NOT** the license key)
+    #   * ips        - The list of IPs of the same VPS/Server. The first IP is
+    #                  the Primary IP. You may add up to 8 IPs
+    def edit_ips(params = {})
+      params[:'ips[]'] = params.delete(:ips)
+      params[:lid]     = params.delete(:license_id) if params[:license_id]
+      commit(params.merge!(:ca => :showlicense, :editlicense => 1),
+        :require => [:lid, :'ips[]']
+      )
+    end
+
+    # Get details for an invoice
+    #
+    # NOTE: If invoid is 0 or not set, a list of **all** unbilled
+    # transactions for the current month will be returned
+    #
+    # Params
+    #
+    #   * invoice_id - The invoice ID to getch details for.
+    def invoice_details(params = {})
+      params[:invoid] = params.delete(:invoice_id) if params[:invoice_id]
+      params[:ca]     = :invoicedetails
+      commit(params)
+    end
+
+    # Get Action Logs for a license
+    #
+    # NOTE: The logs are returned in **DESCENDING ORDER**, meaning the
+    # latest logs will appear first.
+    #
+    # Params
+    #
+    #   * key   - The license key
+    #   * limit - The number of action logs to return
+    def license_logs(params = {})
+      params[:ca] = :licenselogs
+      commit(params, :require => :key)
+    end
+
+  private
+
+    # Send a request upstream to Softaculous
+    #
+    # Params
+    #
+    #   * params  - a hash of parameters for the request
+    #   * options - a hash of options, used to validate required params
+    def commit(params, options = {})
+      if options[:require]
+        unless require_params(params, options[:require])
+          raise Errors::MissingArgument
+        end
+      end
+
+      if options[:require_one]
+        unless require_one_of(params, options[:require_one])
+          raise Errors::MissingArgument
+        end
+      end
+
+      params.merge!(@credentials) unless @credentials.nil? || @credentials.empty?
+
+      uri = "#{API_URL}?#{query_string(params)}"
+      if res = fetch(uri)
+        @response = begin
+                      PHP.unserialize(res.body)
+                    rescue
+                      res.body
+                    end
+      end
+    end
+
+    # Returns true if params has all of the specified keys
+    #
+    # Params
+    #
+    #   * params - hash of query parameters
+    #   * keys   - keys to search for in params
+    def require_params(params, keys)
+      Array(keys).each { |key| return false unless params[key] }
+      true
+    end
+
+    # Returns true if params has one of the specified keys
+    #
+    # Params
+    #
+    #   * params - hash of query parameters
+    #   * keys   - keys to search for in params
+    def require_one_of(params, keys)
+      Array(keys).each { |key| return true if params[key] }
+      false
+    end
+
+    # Formats params into a query string for a GET request
+    #
+    # NOTE: For convenience, this converts the keys :username and
+    #       :password to :nocname and :nocpass respectively.
+    #
+    # Params
+    #
+    #   * params - hash of query parameters
+    def query_string(params)
+      params.map do |key, val|
+        case key.to_sym
+        when :username
+          key = :nocname
+        when :password
+          key = :nocpass
+        end
+        "#{key}=#{CGI.escape(val.to_s)}"
+      end.join('&')
+    end
+
+    # Performs a GET request on the given URI, redirects if needed
+    #
+    # See Following Redirection at
+    # http://ruby-doc.org/stdlib/libdoc/net/http/rdoc/classes/Net/HTTP.html
+    #
+    # Params
+    #
+    #   * uri_str - the URL to fetch as a string
+    #   * limit   - number of redirects to allow
+    def fetch(uri_str, limit = 10)
+      # You should choose better exception.
+      raise ArgumentError, 'HTTP redirect too deep' if limit == 0
+
+      uri = URI.parse(uri_str)
+      http = Net::HTTP.new(uri.host, uri.port)
+      request = Net::HTTP::Get.new(uri.request_uri)
+      response = http.start { |http| http.request(request) }
+
+      case response
+      when Net::HTTPSuccess     then response
+      when Net::HTTPRedirection then fetch(response['location'], limit - 1)
+      else
+        response.error!
+      end
+    end
+  end
+end

data/lib/snuggie/version.rb

@@ -0,0 +1,3 @@
+module Snuggie
+  VERSION = Version = '0.1.0'
+end

data/test/fixtures/buy_license.txt

@@ -0,0 +1 @@
+a:12:{s:3:"lid";i:99999;s:7:"license";s:29:"XXXXX-XXXXX-XXXXX-XXXXX-XXXXX";s:3:"bal";d:-48;s:2:"ip";s:9:"127.0.0.1";s:4:"time";i:1308062889;s:4:"rate";i:2;s:3:"amt";i:2;s:5:"added";s:2:"1M";s:6:"action";s:3:"new";s:9:"autorenew";s:3:"YES";s:5:"actid";i:99999;s:5:"error";N;}

data/test/fixtures/cancel_license.txt

@@ -0,0 +1 @@
+a:2:{s:5:"error";N;s:17:"cancelled_license";a:15:{s:6:"apiuid";s:1:"0";s:5:"nocid";s:4:"XXXX";s:10:"servertype";s:1:"1";s:7:"license";s:29:"XXXXX-XXXXX-XXXXX-XXXXX-XXXXX";s:4:"time";s:10:"1308062889";s:7:"expires";s:8:"20110614";s:3:"env";s:0:"";s:4:"type";s:1:"1";s:9:"last_sync";s:1:"0";s:3:"lid";s:5:"99999";s:10:"soft_email";s:0:"";s:5:"panel";s:0:"";s:9:"authemail";s:18:"marty@hilldale.edu";s:6:"unique";s:0:"";s:6:"active";s:1:"1";}}

data/test/fixtures/edit_ips.txt

@@ -0,0 +1 @@
+a:3:{s:5:"error";N;s:7:"new_ips";a:1:{i:0;s:9:"127.0.0.2";}s:3:"lid";i:99999;}

data/test/fixtures/invoice_details_unbilled.txt

@@ -0,0 +1 @@
+a:3:{s:7:"actions";a:2:{i:XXXXX;a:12:{s:5:"actid";s:5:"XXXXX";s:5:"nocid";s:4:"XXXX";s:6:"action";s:7:"advance";s:3:"lid";s:1:"0";s:6:"invoid";s:1:"0";s:4:"rate";s:5:"50.00";s:5:"added";s:0:"";s:3:"amt";s:6:"-50.00";s:4:"time";s:10:"1307554880";s:4:"date";s:8:"20110608";s:8:"refunded";s:1:"0";s:7:"license";N;}i:XXXXX;a:12:{s:5:"actid";s:5:"XXXXX";s:5:"nocid";s:4:"XXXX";s:6:"action";s:3:"new";s:3:"lid";s:5:"XXXXX";s:6:"invoid";s:1:"0";s:4:"rate";s:4:"2.00";s:5:"added";s:2:"1M";s:3:"amt";s:4:"2.00";s:4:"time";s:10:"1308062889";s:4:"date";s:8:"20110614";s:8:"refunded";s:1:"0";s:7:"license";s:29:"XXXXX-XXXXX-XXXXX-XXXXX-XXXXX";}}s:3:"amt";d:-48;s:6:"invoid";i:0;}

data/test/fixtures/license_logs.txt

@@ -0,0 +1 @@
+a:3:{s:7:"actions";a:1:{i:XXXXX;a:11:{s:5:"actid";s:5:"XXXXX";s:5:"nocid";s:4:"XXXX";s:6:"action";s:3:"new";s:3:"lid";s:5:"XXXXX";s:6:"invoid";s:1:"0";s:4:"rate";s:4:"2.00";s:5:"added";s:2:"1M";s:3:"amt";s:4:"2.00";s:4:"time";s:10:"1308062889";s:4:"date";s:8:"20110614";s:8:"refunded";s:1:"0";}}s:7:"license";a:15:{s:3:"lid";s:5:"XXXXX";s:7:"license";s:29:"XXXXX-XXXXX-XXXXX-XXXXX-XXXXX";s:4:"type";s:1:"1";s:6:"unique";s:0:"";s:6:"apiuid";s:1:"0";s:5:"nocid";s:4:"XXXX";s:9:"authemail";s:18:"marty@hilldale.edu";s:10:"soft_email";s:0:"";s:4:"time";s:10:"1308062889";s:7:"expires";s:8:"20110714";s:6:"active";s:1:"1";s:10:"servertype";s:1:"1";s:9:"last_sync";s:1:"0";s:5:"panel";s:0:"";s:3:"env";s:0:"";}s:5:"error";N;}

data/test/fixtures/list_licenses.txt

@@ -0,0 +1 @@
+a:4:{s:8:"licenses";a:1:{i:99999;a:19:{s:3:"lid";s:5:"XXXXX";s:7:"license";s:29:"XXXXX-XXXXX-XXXXX-XXXXX-XXXXX";s:4:"type";s:1:"1";s:6:"unique";s:0:"";s:6:"apiuid";s:1:"0";s:5:"nocid";s:4:"XXXX";s:9:"authemail";s:18:"marty@hilldale.org";s:10:"soft_email";s:0:"";s:4:"time";s:10:"1308062889";s:7:"expires";s:8:"20110614";s:6:"active";s:1:"1";s:10:"servertype";s:1:"1";s:9:"last_sync";s:1:"0";s:5:"panel";s:0:"";s:3:"env";s:0:"";s:4:"ipid";s:5:"XXXXX";s:2:"ip";s:9:"127.0.0.1";s:7:"primary";s:1:"1";s:8:"hostname";s:12:"hilldale.org";}}s:10:"num_active";i:1;s:11:"num_results";i:1;s:5:"error";N;}

data/test/fixtures/refund.txt

@@ -0,0 +1 @@
+a:10:{s:3:"lid";s:5:"XXXXX";s:7:"license";s:29:"XXXXX-XXXXX-XXXXX-XXXXX-XXXXX";s:3:"bal";d:-50;s:4:"time";i:1308066592;s:4:"rate";s:4:"2.00";s:3:"amt";d:-2;s:5:"added";s:3:"-1M";s:6:"action";s:6:"refund";s:5:"actid";i:99999;s:5:"error";N;}

data/test/snuggie/config_test.rb

@@ -0,0 +1,15 @@
+require 'test_helper'
+
+context "Snuggie::Config" do
+  setup do
+    @config = Snuggie::Config.new
+  end
+
+  test "has attr_accessor :username" do
+    assert_attr_accessor @config, :username
+  end
+
+  test "has attr_accessor :password" do
+    assert_attr_accessor @config, :password
+  end
+end

data/test/snuggie/noc_test.rb

@@ -0,0 +1,279 @@
+require 'test_helper'
+
+context "Snuggie::NOC" do
+  TEST_CREDENTIALS = { :username => 'marty', :password => 'mcSUPERfly' }
+
+  setup do
+    @noc = Snuggie::NOC.new(TEST_CREDENTIALS)
+  end
+
+  def mock_query_url(params = {})
+    @noc.class::API_URL + '?' + @noc.instance_eval { query_string(params) }
+  end
+
+  test "::API_URL has a valid format" do
+    assert_valid_url @noc.class::API_URL
+  end
+
+  test "#initialize sets @credentials" do
+    credentials = @noc.instance_variable_get(:@credentials)
+    assert credentials.is_a?(Hash)
+    TEST_CREDENTIALS.each do |key, val|
+      assert credentials.has_key?(key)
+      assert_equal val, credentials[key]
+    end
+  end
+
+  test "#initialize uses Config to set @credentials" do
+    Snuggie.configure do |c|
+      c.username = 'doc'
+      c.password = 'clara'
+    end
+    credentials = @noc.class.new.instance_variable_get(:@credentials)
+    assert credentials.is_a?(Hash)
+    ({ :username => 'doc', :password => 'clara' }).each do |key, val|
+      assert_not_nil credentials[key]
+      assert credentials.has_key?(key)
+    end
+
+    Snuggie.configure do |c|
+      c.username = nil
+      c.password = nil
+    end
+    assert_equal @noc.class.new.instance_variable_get(:@credentials), Hash.new
+  end
+
+  test "#require_params returns true if all params are set" do
+    a1 = @noc.instance_eval do
+      require_params({ :fuel => :plutonium, :date => 1955 }, [:fuel, :date])
+    end
+    assert a1
+  end
+
+  test "#require_one_of returns true if one param is set" do
+    a1 = @noc.instance_eval do
+      require_one_of({ :date => 1955, :fuel => :plutonium }, [:fusion, :fuel])
+    end
+    assert a1
+  end
+
+  test "#query_string" do
+    params = {
+      :date     => 1955,
+      :fuel     => :plutonium,
+      :username => 'marty',
+      :password => 'mcSUPERfly'
+    }
+
+    query = @noc.instance_eval do
+      query_string(params)
+    end
+
+    assert_match /date=1955/,          query
+    assert_match /fuel=plutonium/,     query
+    assert_match /nocname=marty/,      query
+    assert_match /nocpass=mcSUPERfly/, query
+
+    assert_no_match /username/, query
+    assert_no_match /password/, query
+  end
+
+  test "#commit requires all :require params" do
+    mock_request(mock_query_url)
+    assert_raise(Snuggie::Errors::MissingArgument) do
+      @noc.instance_eval do
+        commit({}, :require => :fuel)
+      end
+    end
+
+    params = { :fuel => :plutonium }
+    mock_request(mock_query_url(params))
+    assert_nothing_raised do
+      @noc.instance_eval do
+        commit(params, :require => :fuel)
+      end
+    end
+  end
+
+  test "#commit requires one of :require_one params" do
+    p1 = { :date => 1955 }
+    mock_request(mock_query_url(p1))
+    assert_raise(Snuggie::Errors::MissingArgument) do
+      @noc.instance_eval do
+        commit(p1, :require_one => :fuel)
+      end
+    end
+
+    p2 = { :date => 1955, :fuel => :plutonium }
+    mock_request(mock_query_url(p2))
+    assert_nothing_raised do
+      @noc.instance_eval do
+        commit(p2, :require_one => :fuel)
+      end
+    end
+  end
+
+  test "#commit returns a hash if PHP.unserialize works" do
+    p1 = { :date => 1955 }
+    mock_request(mock_query_url(p1), :body => PHP.serialize(:status => :success))
+    res = @noc.instance_eval do
+      commit(p1, :require => :date)
+    end
+    assert res.has_key?('status')
+    assert_equal 'success', res['status']
+  end
+
+  test "#commit returns HTTP body if PHP.unserialize fails" do
+    p1 = { :date => 1955 }
+    mock_request(mock_query_url(p1), :body => "not a PHP serialized string")
+    res = @noc.instance_eval do
+      commit(p1, :require => :date)
+    end
+    assert_equal 'not a PHP serialized string', res
+  end
+
+  test "#buy_license required params" do
+    params = {
+      :ip            => '127.0.0.1',
+      :months_to_add => 1,
+      :servertype    => :dedicated,
+      :authemail     => 'marty@hilldale.edu',
+      :autorenew     => true
+    }
+    mock_request(:buy_license)
+    assert_raise(Snuggie::Errors::MissingArgument, "requires args") do
+      @noc.buy_license
+    end
+
+    res = @noc.buy_license(params)
+    assert res.is_a?(Hash)
+    assert_equal '1M', res['added']
+    assert_equal 'YES', res['autorenew']
+    assert_equal 'XXXXX-XXXXX-XXXXX-XXXXX-XXXXX', res['license']
+    assert_equal 1308062889, res['time']
+    assert_equal -48.0, res['bal']
+    assert_equal 2, res['rate']
+    assert_equal 99999, res['actid']
+    assert_equal '127.0.0.1', res['ip']
+    assert_equal 99999, res['lid']
+    assert_equal 2, res['amt']
+  end
+
+  test "#refund" do
+    mock_request(:refund)
+    assert_raise(Snuggie::Errors::MissingArgument, "requires actid") do
+      @noc.refund
+    end
+
+    res = @noc.refund :actid => 99999
+    assert res.is_a?(Hash)
+    assert_equal '-1M', res['added']
+    assert_equal 'XXXXX-XXXXX-XXXXX-XXXXX-XXXXX', res['license']
+    assert_equal 1308066592, res['time']
+    assert_equal -50.0, res['bal']
+    assert_equal 'refund', res['action']
+    assert_equal '2.00', res['rate']
+    assert_equal 99999, res['actid']
+    assert_equal 'XXXXX', res['lid']
+    assert_equal -2.0, res['amt']
+  end
+
+  test "#list_licenses" do
+    mock_request(:list_licenses)
+    res = @noc.list_licenses
+    assert res.is_a?(Hash)
+    assert_equal 1, res['num_results']
+    assert_equal 1, res['num_active']
+    assert_not_nil res['licenses']
+  end
+
+  test "#cancel_license" do
+    mock_request(:cancel_license)
+    assert_raise(Snuggie::Errors::MissingArgument, "requires lickey or licip") do
+      @noc.cancel_license
+    end
+    # TODO: fixture/test
+    res = @noc.cancel_license :key => 'XXXXX-XXXXX-XXXXX-XXXXX-XXXXX'
+    assert res.is_a?(Hash)
+    assert res['cancelled_license'].is_a?(Hash)
+    res = res['cancelled_license']
+    assert_equal '0', res['apiuid']
+    assert_equal 'XXXX', res['nocid']
+    assert_equal '1', res['servertype']
+    assert_equal 'XXXXX-XXXXX-XXXXX-XXXXX-XXXXX', res['license']
+    assert_equal '1308062889', res['time']
+    assert_equal '20110614', res['expires']
+    assert_equal '1', res['type']
+    assert_equal '0', res['last_sync']
+    assert_equal 'marty@hilldale.edu', res['authemail']
+  end
+
+  test "#invoice_details unbilled" do
+    mock_request(:invoice_details_unbilled)
+    res = @noc.invoice_details
+    assert res.is_a?(Hash)
+    assert res['actions'].is_a?(Hash)
+    act = res['actions'][0]
+    assert_equal '1M', act['added']
+    assert_equal 'XXXX', act['nocid']
+    assert_equal 'XXXXX-XXXXX-XXXXX-XXXXX-XXXXX', act['license']
+    assert_equal '0', act['refunded']
+    assert_equal '1308062889', act['time']
+    assert_equal '20110614', act['date']
+    assert_equal '2.00', act['rate']
+    assert_equal 'new', act['action']
+    assert_equal 'XXXXX', act['actid']
+    assert_equal '0', act['invoid']
+    assert_equal 'XXXXX', act['lid']
+    assert_equal '2.00', act['amt']
+  end
+
+  test "#license_logs" do
+    mock_request(:license_logs)
+    assert_raise(Snuggie::Errors::MissingArgument, "requires key") do
+      @noc.license_logs
+    end
+    res = @noc.license_logs :key => 'XXXXX-XXXXX-XXXXX-XXXXX'
+
+    assert res.is_a?(Hash)
+    assert res['actions'].is_a?(Array)
+    act = res['actions'].first
+    assert act.is_a?(Hash)
+    assert_equal '1M', act['added']
+    assert_equal 'XXXX', act['nocid']
+    assert_equal '0', act['refunded']
+    assert_equal '1308062889', act['time']
+    assert_equal '20110614', act['date']
+    assert_equal '2.00', act['rate']
+    assert_equal 'new', act['action']
+    assert_equal '0', act['invoid']
+    assert_equal 'XXXXX', act['lid']
+    assert_equal '2.00', act['amt']
+    lic = res['license']
+    assert lic.is_a?(Hash)
+    assert_equal '1', lic['servertype']
+    assert_equal 'XXXX', lic['nocid']
+    assert_equal '0', lic['apiuid']
+    assert_equal 'XXXXX-XXXXX-XXXXX-XXXXX-XXXXX', lic['license']
+    assert_equal '20110714', lic['expires']
+    assert_equal '1308062889', lic['time']
+    assert_equal '0', lic['last_sync']
+    assert_equal '1', lic['type']
+    assert_equal 'XXXXX', lic['lid']
+    assert_equal 'marty@hilldale.edu', lic['authemail']
+    assert_equal '1', lic['active']
+  end
+
+  test "#edit_ips" do
+    mock_request(:edit_ips)
+    assert_raise(Snuggie::Errors::MissingArgument, "requires ips and lid") do
+      @noc.edit_ips
+    end
+    res = @noc.edit_ips :ips => '127.0.0.2', :lid => 'XXXXX'
+
+   assert res.is_a?(Hash)
+   assert_equal 99999, res['lid']
+   assert res['new_ips'].is_a?(Array)
+   assert_equal '127.0.0.2', res['new_ips'].first
+  end
+end

data/test/snuggie_test.rb

@@ -0,0 +1,31 @@
+require 'test_helper'
+
+context "Snuggie" do
+  setup do
+    Snuggie.config = Snuggie::Config.new
+  end
+
+  test "::Version has a valid format" do
+    assert Snuggie::Version.match(/\d+\.\d+\.\d+/)
+  end
+
+  test "has class attr_accessor :config" do
+    assert_attr_accessor Snuggie, :config
+  end
+
+  test "::config defaults to Config.new" do
+    assert Snuggie.config.is_a?(Snuggie::Config)
+  end
+
+  test "::configure sets config with a block" do
+    Snuggie.configure do |c|
+      c.username = 'mcfly'
+      c.password = 'b4ck1nt1m3'
+    end
+
+    assert Snuggie.configure.is_a?(Snuggie::Config)
+    assert_equal Snuggie.config.username, 'mcfly'
+    assert_equal Snuggie.config.password, 'b4ck1nt1m3'
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,138 @@
+require 'rubygems'
+require 'snuggie'
+require 'test/unit'
+require 'fakeweb'
+require 'php_serialize'
+
+begin
+  require 'turn'
+rescue LoadError
+  puts "'gem install turn' for prettier test output"
+end
+
+FakeWeb.allow_net_connect = false
+
+# test/spec/mini 3
+# Based on http://gist.github.com/25455
+def context(*args, &block)
+  return super unless (name = args.first) && block
+  klass = Class.new(Test::Unit::TestCase) do
+    def self.test(name, &block)
+      name = " #{name}" unless %w[: # .].include?(name[0].chr)
+      define_method("test: #{self.name}#{name}", &block) if block
+    end
+    def self.setup(&block) define_method(:setup, &block) end
+    def self.teardown(&block) define_method(:teardown, &block) end
+  end
+  (class << klass; self end).send(:define_method, :name) { name }
+  (class << klass; self end).send(:define_method, :to_s) { name }
+  klass.class_eval &block
+end
+
+def mock_request(method, options = {})
+  fixture = File.expand_path("../fixtures/#{method}.txt", __FILE__)
+  if File.exists?(fixture)
+    options[:body] = File.read(fixture)
+  end
+  FakeWeb.register_uri(:get, %r|^#{Snuggie::NOC::API_URL}\?.*|, options)
+end
+
+# Asserts that the given object has an instance variable for var
+#
+#   class Foo
+#     def initialize
+#       @bar = :bar
+#     end
+#   end
+#
+#   assert_instance_var(Foo.new, :bar) => passes
+def assert_instance_var(obj, var)
+  assert_not_nil obj.instance_variable_get("@#{var}")
+end
+
+# Asserts that the given object has an attr_accessor for method
+#
+#   class Foo
+#     attr_accessor :bar
+#   end
+#
+#   assert_attr_accesor(Foo.new, :bar) => passes
+def assert_attr_accessor(obj, method)
+  assert_attr_reader obj, method
+  assert_attr_writer obj, method
+end
+
+# Asserts that the given object has an attr_reader for method
+#
+#   class Foo
+#     attr_writer :bar
+#   end
+#
+#   assert_attr_reader(Foo.new, :bar) => passes
+def assert_attr_reader(obj, method)
+  assert_respond_to obj, method
+  assert_equal obj.send(method), obj.instance_variable_get("@#{method}")
+end
+
+# Asserts that the given object has an attr_writer for method
+#
+#   class Foo
+#     attr_writer :bar
+#   end
+#
+#   assert_attr_writer(Foo.new, :bar) => passes
+def assert_attr_writer(obj, method)
+  assert_respond_to obj, "#{method}="
+end
+
+# Asserts that the given string is a valid URL
+#
+#   assert_valid_url('http://google.com') => passes
+def assert_valid_url(string)
+  assert string.to_s.match(/https?:\/\/[\S]+/)
+end
+
+# From https://github.com/thoughtbot/shoulda-context/blob/master/lib/shoulda/context/assertions.rb
+# Asserts that two arrays contain the same elements, the same number of times.  Essentially ==, but unordered.
+#
+#   assert_same_elements([:a, :b, :c], [:c, :a, :b]) => passes
+def assert_same_elements(a1, a2, msg = nil)
+  [:select, :inject, :size].each do |m|
+    [a1, a2].each {|a| assert_respond_to(a, m, "Are you sure that #{a.inspect} is an array?  It doesn't respond to #{m}.") }
+  end
+
+  assert a1h = a1.inject({}) { |h,e| h[e] ||= a1.select { |i| i == e }.size; h }
+  assert a2h = a2.inject({}) { |h,e| h[e] ||= a2.select { |i| i == e }.size; h }
+
+  assert_equal(a1h, a2h, msg)
+end
+
+# Asserts that the given collection contains item x.  If x is a regular expression, ensure that
+# at least one element from the collection matches x.  +extra_msg+ is appended to the error message if the assertion fails.
+#
+#   assert_contains(['a', '1'], /\d/) => passes
+#   assert_contains(['a', '1'], 'a') => passes
+#   assert_contains(['a', '1'], /not there/) => fails
+def assert_contains(collection, x, extra_msg = "")
+  collection = Array(collection)
+  msg = "#{x.inspect} not found in #{collection.to_a.inspect} #{extra_msg}"
+  case x
+  when Regexp
+    assert(collection.detect { |e| e =~ x }, msg)
+  else
+    assert(collection.include?(x), msg)
+  end
+end
+
+# Asserts that the given collection does not contain item x.  If x is a regular expression, ensure that
+# none of the elements from the collection match x.
+def assert_does_not_contain(collection, x, extra_msg = "")
+  collection = Array(collection)
+  msg = "#{x.inspect} found in #{collection.to_a.inspect} " + extra_msg
+  case x
+  when Regexp
+    assert(!collection.detect { |e| e =~ x }, msg)
+  else
+    assert(!collection.include?(x), msg)
+  end
+end

metadata

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification 
+name: snuggie
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Joshua Priddle
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-06-15 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: php-serialize
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 1.1.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 0.8.7
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: fakeweb
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 1.3.0
+  type: :development
+  version_requirements: *id003
+description: "    Snuggie wraps the Softaculous API in a warm, loving ruby embrace.\n"
+email: jpriddle@site5.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.markdown
+files: 
+- Rakefile
+- README.markdown
+- lib/snuggie/config.rb
+- lib/snuggie/errors.rb
+- lib/snuggie/noc.rb
+- lib/snuggie/version.rb
+- lib/snuggie.rb
+- test/fixtures/buy_license.txt
+- test/fixtures/cancel_license.txt
+- test/fixtures/edit_ips.txt
+- test/fixtures/invoice_details_unbilled.txt
+- test/fixtures/license_logs.txt
+- test/fixtures/list_licenses.txt
+- test/fixtures/refund.txt
+- test/snuggie/config_test.rb
+- test/snuggie/noc_test.rb
+- test/snuggie_test.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: https://github.com/site5/snuggie
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Snuggie wraps the Softaculous API in a warm, loving ruby embrace
+test_files: []
+