rainforest 1.0.1

data/test/stripe/invoice_test.rb

@@ -0,0 +1,20 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+module Rainforest
+  class InvoiceTest < Test::Unit::TestCase
+    should "retrieve should retrieve invoices" do
+      @mock.expects(:get).once.returns(test_response(test_invoice))
+      i = Rainforest::Invoice.retrieve('in_test_invoice')
+      assert_equal 'in_test_invoice', i.id
+    end
+
+    should "pay should pay an invoice" do
+      @mock.expects(:get).once.returns(test_response(test_invoice))
+      i = Rainforest::Invoice.retrieve('in_test_invoice')
+
+      @mock.expects(:post).once.with('https://api.rainforest.com/v1/invoices/in_test_invoice/pay', nil, '').returns(test_response(test_paid_invoice))
+      i.pay
+      assert_equal i.next_payment_attempt, nil
+    end
+  end
+end

data/test/stripe/list_object_test.rb

@@ -0,0 +1,16 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+module Rainforest
+  class ListObjectTest < Test::Unit::TestCase
+    should "be able to retrieve full lists given a listobject" do
+      @mock.expects(:get).twice.returns(test_response(test_charge_array))
+      c = Rainforest::Charge.all
+      assert c.kind_of?(Rainforest::ListObject)
+      assert_equal('/v1/charges', c.url)
+      all = c.all
+      assert all.kind_of?(Rainforest::ListObject)
+      assert_equal('/v1/charges', all.url)
+      assert all.data.kind_of?(Array)
+    end
+  end
+end

data/test/stripe/metadata_test.rb

@@ -0,0 +1,114 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+module Rainforest
+  class MetadataTest < Test::Unit::TestCase
+    setup do
+      @metadata_supported = {
+        :charge => {
+          :new => Rainforest::Charge.method(:new),
+          :test => method(:test_charge),
+          :url => "/v1/charges/#{test_charge()[:id]}"
+        },
+        :customer => {
+          :new => Rainforest::Customer.method(:new),
+          :test => method(:test_customer),
+          :url => "/v1/customers/#{test_customer()[:id]}"
+        },
+        :recipient => {
+          :new => Rainforest::Recipient.method(:new),
+          :test => method(:test_recipient),
+          :url => "/v1/recipients/#{test_recipient()[:id]}"
+        },
+        :transfer => {
+          :new => Rainforest::Transfer.method(:new),
+          :test => method(:test_transfer),
+          :url => "/v1/transfers/#{test_transfer()[:id]}"
+        }
+      }
+
+      @base_url = 'https://api.rainforest.com'
+    end
+
+    should "not touch metadata" do
+      update_actions = lambda {|obj| obj.description = 'test'}
+      check_metadata({:metadata => {'initial' => 'true'}},
+                    'description=test',
+                    update_actions)
+    end
+
+
+    should "update metadata as a whole" do
+      update_actions = lambda {|obj| obj.metadata = {'uuid' => '6735'}}
+      check_metadata({:metadata => {}},
+                    'metadata[uuid]=6735',
+                    update_actions)
+
+      if is_greater_than_ruby_1_9?
+        check_metadata({:metadata => {:initial => 'true'}},
+                      'metadata[uuid]=6735&metadata[initial]=',
+                      update_actions)
+      end
+    end
+
+    should "update metadata keys individually" do
+      update_actions = lambda {|obj| obj.metadata['txn_id'] = '134a13'}
+      check_metadata({:metadata => {'initial' => 'true'}},
+                     'metadata[txn_id]=134a13',
+                     update_actions)
+    end
+
+    should "clear metadata as a whole" do
+      update_actions = lambda {|obj| obj.metadata = nil}
+      check_metadata({:metadata => {'initial' => 'true'}},
+                     'metadata=',
+                     update_actions)
+    end
+
+    should "clear metadata keys individually" do
+      update_actions = lambda {|obj| obj.metadata['initial'] = nil}
+      check_metadata({:metadata => {'initial' => 'true'}},
+                     'metadata[initial]=',
+                     update_actions)
+    end
+
+    should "handle combinations of whole and partial metadata updates" do
+      if is_greater_than_ruby_1_9?
+        update_actions = lambda do |obj|
+          obj.metadata = {'type' => 'summer'}
+          obj.metadata['uuid'] = '6735'
+        end
+        params = {:metadata => {'type' => 'summer', 'uuid' => '6735'}}
+        curl_args = Rainforest.uri_encode(params)
+        check_metadata({:metadata => {'type' => 'christmas'}},
+                       curl_args,
+                       update_actions)
+      end
+    end
+
+    def check_metadata (initial_params, curl_args, metadata_update)
+      @metadata_supported.each do |name, methods|
+        neu = methods[:new]
+        test = methods[:test]
+        url = @base_url + methods[:url]
+
+        initial_test_obj = test.call(initial_params)
+        @mock.expects(:get).once.returns(test_response(initial_test_obj))
+
+        final_test_obj = test.call()
+        @mock.expects(:post).once.
+          returns(test_response(final_test_obj)).
+          with(url, nil, curl_args)
+
+        obj = neu.call("test")
+        obj.refresh()
+        metadata_update.call(obj)
+        obj.save
+      end
+    end
+
+    def is_greater_than_ruby_1_9?
+      version = RUBY_VERSION.dup  # clone preserves frozen state
+      Gem::Version.new(version) >= Gem::Version.new('1.9')
+    end
+  end
+end

data/test/stripe/util_test.rb

@@ -0,0 +1,29 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+module Rainforest
+  class UtilTest < Test::Unit::TestCase
+    should "symbolize_names should convert names to symbols" do
+      start = {
+        'foo' => 'bar',
+        'array' => [{ 'foo' => 'bar' }],
+        'nested' => {
+          1 => 2,
+          :symbol => 9,
+          'string' => nil
+        }
+      }
+      finish = {
+        :foo => 'bar',
+        :array => [{ :foo => 'bar' }],
+        :nested => {
+          1 => 2,
+          :symbol => 9,
+          :string => nil
+        }
+      }
+
+      symbolized = Rainforest::Util.symbolize_names(start)
+      assert_equal(finish, symbolized)
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,356 @@
+require 'rainforest'
+require 'test/unit'
+require 'mocha/setup'
+require 'stringio'
+require 'shoulda'
+
+#monkeypatch request methods
+module Rainforest
+  @mock_rest_client = nil
+
+  def self.mock_rest_client=(mock_client)
+    @mock_rest_client = mock_client
+  end
+
+  def self.execute_request(opts)
+    get_params = (opts[:headers] || {})[:params]
+    post_params = opts[:payload]
+    case opts[:method]
+    when :get then @mock_rest_client.get opts[:url], get_params, post_params
+    when :post then @mock_rest_client.post opts[:url], get_params, post_params
+    when :delete then @mock_rest_client.delete opts[:url], get_params, post_params
+    end
+  end
+end
+
+def test_response(body, code=200)
+  # When an exception is raised, restclient clobbers method_missing.  Hence we
+  # can't just use the stubs interface.
+  body = MultiJson.dump(body) if !(body.kind_of? String)
+  m = mock
+  m.instance_variable_set('@rainforest_values', { :body => body, :code => code })
+  def m.body; @rainforest_values[:body]; end
+  def m.code; @rainforest_values[:code]; end
+  m
+end
+
+def test_balance(params={})
+  {
+    :pending => [
+      {:amount => 12345, :currency => "usd"}
+    ],
+    :available => [
+      {:amount => 6789, :currency => "usd"}
+    ],
+    :livemode => false,
+    :object => "balance"
+  }.merge(params)
+end
+
+def test_balance_transaction(params={})
+  {
+    :amount => 100,
+    :net => 41,
+    :currency => "usd",
+    :type => "charge",
+    :created => 1371945005,
+    :available_on => 1372549805,
+    :status => "pending",
+    :description => "A test balance transaction",
+    :fee => 59,
+    :object => "balance_transaction"
+  }.merge(params)
+end
+
+def test_balance_transaction_array
+  {
+    :data => [test_balance_transaction, test_balance_transaction, test_balance_transaction],
+    :object => "list",
+    :url => "/v1/balance/history"
+  }
+end
+
+def test_customer(params={})
+  {
+    :subscription_history => [],
+    :bills => [],
+    :charges => [],
+    :livemode => false,
+    :object => "customer",
+    :id => "c_test_customer",
+    :default_card => "cc_test_card",
+    :created => 1304114758,
+    :cards => test_card_array('c_test_customer'),
+    :metadata => {}
+  }.merge(params)
+end
+
+def test_customer_array
+  {
+    :data => [test_customer, test_customer, test_customer],
+    :object => 'list',
+    :url => '/v1/customers'
+  }
+end
+
+def test_charge(params={})
+  {
+    :refunded => false,
+    :paid => true,
+    :amount => 100,
+    :card => {
+      :type => "Visa",
+      :last4 => "4242",
+      :exp_month => 11,
+      :country => "US",
+      :exp_year => 2012,
+      :id => "cc_test_card",
+      :object => "card"
+    },
+    :id => "ch_test_charge",
+    :reason => "execute_charge",
+    :livemode => false,
+    :currency => "usd",
+    :object => "charge",
+    :created => 1304114826,
+    :metadata => {}
+  }.merge(params)
+end
+
+def test_charge_array
+  {
+    :data => [test_charge, test_charge, test_charge],
+    :object => 'list',
+    :url => '/v1/charges'
+  }
+end
+
+def test_card_array(customer_id)
+  {
+    :data => [test_card, test_card, test_card],
+    :object => 'list',
+    :url => '/v1/customers/' + customer_id + '/cards'
+  }
+end
+
+def test_card(params={})
+  {
+    :type => "Visa",
+    :last4 => "4242",
+    :exp_month => 11,
+    :country => "US",
+    :exp_year => 2012,
+    :id => "cc_test_card",
+    :customer => 'c_test_customer',
+    :object => "card"
+  }.merge(params)
+end
+
+def test_coupon(params={})
+  {
+    :duration => 'repeating',
+    :duration_in_months => 3,
+    :percent_off => 25,
+    :id => "co_test_coupon",
+    :object => "coupon"
+  }.merge(params)
+end
+
+#FIXME nested overrides would be better than hardcoding plan_id
+def test_subscription(plan_id="gold")
+  {
+    :current_period_end => 1308681468,
+    :status => "trialing",
+    :plan => {
+      :interval => "month",
+      :amount => 7500,
+      :trial_period_days => 30,
+      :object => "plan",
+      :identifier => plan_id
+    },
+    :current_period_start => 1308595038,
+    :start => 1308595038,
+    :object => "subscription",
+    :trial_start => 1308595038,
+    :trial_end => 1308681468,
+    :customer => "c_test_customer"
+  }
+end
+
+def test_invoice
+  {
+    :id => 'in_test_invoice',
+    :object => 'invoice',
+    :livemode => false,
+    :amount_due => 1000,
+    :attempt_count => 0,
+    :attempted => false,
+    :closed => false,
+    :currency => 'usd',
+    :customer => 'c_test_customer',
+    :date => 1349738950,
+    :lines => {
+      "invoiceitems" => [
+        {
+          :id => 'ii_test_invoice_item',
+          :object => '',
+          :livemode => false,
+          :amount => 1000,
+          :currency => 'usd',
+          :customer => 'c_test_customer',
+          :date => 1349738950,
+          :description => "A Test Invoice Item",
+          :invoice => 'in_test_invoice'
+        },
+      ],
+    },
+    :paid => false,
+    :period_end => 1349738950,
+    :period_start => 1349738950,
+    :starting_balance => 0,
+    :subtotal => 1000,
+    :total => 1000,
+    :charge => nil,
+    :discount => nil,
+    :ending_balance => nil,
+    :next_payemnt_attempt => 1349825350,
+  }
+end
+
+def test_paid_invoice
+  test_invoice.merge({
+      :attempt_count => 1,
+      :attempted => true,
+      :closed => true,
+      :paid => true,
+      :charge => 'ch_test_charge',
+      :ending_balance => 0,
+      :next_payment_attempt => nil,
+    })
+end
+
+def test_invoice_customer_array
+  {
+    :data => [test_invoice],
+    :object => 'list',
+    :url => '/v1/invoices?customer=test_customer'
+  }
+end
+
+def test_recipient(params={})
+  {
+    :name => "Rainforest User",
+    :type => "individual",
+    :livemode => false,
+    :object => "recipient",
+    :id => "rp_test_recipient",
+    :active_account => {
+      :last4 => "6789",
+      :bank_name => "STRIPE TEST BANK",
+      :country => "US",
+      :object => "bank_account"
+    },
+    :created => 1304114758,
+    :verified => true,
+    :metadata => {}
+  }.merge(params)
+end
+
+def test_recipient_array
+  {
+    :data => [test_recipient, test_recipient, test_recipient],
+    :object => 'list',
+    :url => '/v1/recipients'
+  }
+end
+
+def test_transfer(params={})
+  {
+    :status => 'pending',
+    :amount => 100,
+    :account => {
+      :object => 'bank_account',
+      :country => 'US',
+      :bank_name => 'STRIPE TEST BANK',
+      :last4 => '6789'
+    },
+    :recipient => 'test_recipient',
+    :fee => 0,
+    :fee_details => [],
+    :id => "tr_test_transfer",
+    :livemode => false,
+    :currency => "usd",
+    :object => "transfer",
+    :date => 1304114826,
+    :metadata => {}
+  }.merge(params)
+end
+
+def test_transfer_array
+  {
+    :data => [test_transfer, test_transfer, test_transfer],
+    :object => 'list',
+    :url => '/v1/transfers'
+  }
+end
+
+def test_invalid_api_key_error
+  {
+    "error" => {
+      "type" => "invalid_request_error",
+      "message" => "Invalid API Key provided: invalid"
+    }
+  }
+end
+
+def test_invalid_exp_year_error
+  {
+    "error" => {
+      "code" => "invalid_expiry_year",
+      "param" => "exp_year",
+      "type" => "card_error",
+      "message" => "Your card's expiration year is invalid"
+    }
+  }
+end
+
+def test_missing_id_error
+  {
+    :error => {
+      :param => "id",
+      :type => "invalid_request_error",
+      :message => "Missing id"
+    }
+  }
+end
+
+def test_api_error
+  {
+    :error => {
+      :type => "api_error"
+    }
+  }
+end
+
+def test_delete_discount_response
+  {
+    :deleted => true,
+    :id => "di_test_coupon"
+  }
+end
+
+class Test::Unit::TestCase
+  include Mocha
+
+  setup do
+    @mock = mock
+    Rainforest.mock_rest_client = @mock
+    Rainforest.api_key="foo"
+  end
+
+  teardown do
+    Rainforest.mock_rest_client = nil
+    Rainforest.api_key=nil
+  end
+end
+