rainforest 1.0.1 → 1.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b4ab37f7ce8b3ac359e5808731670e7ff2a52cbc
-  data.tar.gz: 3dd6db625d4cfe6630d1bbaf4fab5721229b8ecc
+  metadata.gz: d6cbbfc3410b0696d478289fce462b081c2dc5f6
+  data.tar.gz: 3f665a7a8ffb46ec8fc23d6dde9c296ca55cd474
 SHA512:
-  metadata.gz: 0a4dcabfbfebd8118c8fb7516bfbc7dcfa1dd378e2c22389de90b25fc088d6e8060acb926322b6f55a28767010d98e3ad255ca9eae87a1f2eba4a319acb9a0b5
-  data.tar.gz: d45e3fd64c0133b0d0aebba5e8e6ea1e47ecc354e2ccacc24ccd9e81b6e41491ccc6f8001477b3d6b744b694512d63ae96fa80157d8d2d0c89ce3237ac2dbfa0
+  metadata.gz: 442f253755bb2bcabeb923ce94e6cf1f6018f88317eeeeb5cea7d9ea75d461c85390346c44b94ff24813a79ddc4caeee7a17a1eb343fc1b858b9c7de29319fb8
+  data.tar.gz: e4a9787bdd2fa079adce0bc6a7ad26c83a3c62d09f91bfb3becefece959f3fdfafbc1ec94dcc096b82bd575673bfdfe9f7192aa4d0eb678a46be2fdf7af28bfe

data/README.md

@@ -26,6 +26,12 @@ Development
 Test cases can be run with: `bundle exec rake test`
 
 
+Docs
+----
+
+You can find the Rainforest docs here: https://app.rainforestqa.com/docs
+
+
 Examples
 --------
 

data/VERSION

@@ -1 +1 @@
-1.0.1
+1.0.3

data/rainforest.gemspec

@@ -9,7 +9,7 @@ spec = Gem::Specification.new do |s|
   s.description = 'Rainforest allows you to create tests for your website in plain English, then run them across all major browsers with a single click.  See https://www.rainforestqa.com/ for details.'
   s.authors = ['Jon Calhon']
   s.email = ['joncalhoun@gmail.com']
-  s.homepage = 'https://app.rainforestqa.com/docs/ruby'
+  s.homepage = 'https://github.com/joncalhoun/rainforest-ruby'
 
   s.add_dependency('rest-client', '~> 1.4')
   s.add_dependency('multi_json', '>= 1.0.4', '< 2')

data/test/rainforest/api_resource_test.rb

@@ -0,0 +1,11 @@
+# -*- coding: utf-8 -*-
+require File.expand_path('../../test_helper', __FILE__)
+
+module Rainforest
+  class ApiResourceTest < ::Test::Unit::TestCase
+    should "creating a new APIResource should not fetch over the network" do
+      @mock.expects(:get).never
+      c = Rainforest::Test.new("someid")
+    end
+  end
+end

data/test/rainforest/list_object_test.rb

@@ -0,0 +1,7 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+module Rainforest
+  class ListObjectTest < ::Test::Unit::TestCase
+    should_eventually "implement some tests"
+  end
+end

data/test/rainforest/metadata_test.rb

@@ -0,0 +1,7 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+module Rainforest
+  class MetadataTest < ::Test::Unit::TestCase
+    should_eventually "implement some tests"
+  end
+end

data/test/rainforest/test_test.rb

@@ -0,0 +1,8 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+module Rainforest
+  # Dear god this name is odd.. :(   - jon
+  class TestTest < ::Test::Unit::TestCase
+    should_eventually "implement some tests"
+  end
+end

data/test/{stripe → rainforest}/util_test.rb

@@ -1,7 +1,7 @@
 require File.expand_path('../../test_helper', __FILE__)
 
 module Rainforest
-  class UtilTest < Test::Unit::TestCase
+  class UtilTest < ::Test::Unit::TestCase
     should "symbolize_names should convert names to symbols" do
       start = {
         'foo' => 'bar',

data/test/test_helper.rb

@@ -34,308 +34,107 @@ def test_response(body, code=200)
   m
 end
 
-def test_balance(params={})
-  {
-    :pending => [
-      {:amount => 12345, :currency => "usd"}
-    ],
-    :available => [
-      {:amount => 6789, :currency => "usd"}
+def test_test(params={})
+  {
+    id: 2181,
+    created_at: "2013-11-05T04:57:55Z",
+    test_id: 2181,
+    site_id: 860,
+    title: "shit works",
+    result: "no_result",
+    start_uri: "/ghost/signin",
+    run_mode: "default",
+    deleted: false,
+    deletable: true,
+    editable: true,
+    browsers: [
+      {
+        name: "chrome",
+        state: "enabled"
+      },{
+        name: "firefox",
+        state: "enabled"
+      },{
+        name: "ie8",
+        state: "enabled"
+      },{
+        name: "ie9",
+        state: "enabled"
+      },{
+        name: "safari",
+        state: "enabled"
+      }
     ],
-    :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"
+    tags: [],
+    dry_run_url: "https://fierce-thicket-5713.herokuapp.com/turker/dry_run/L4nI_HqGn6ZT4fvecPmDng?turkSubmitTo=%2Fthanks",
+    last_run: {
+      id: 4244,
+      created_at: "2013-11-13T14:38:01Z",
+      state: "in_progress"
     }
   }
 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"
-    }
+def test_run(params={})
+  {
+    id: 4244,
+    created_at: "2013-11-13T14:38:01Z",
+    environment_id: 1144,
+    test_count: 1,
+    state_log: [
+      {
+        id: 11741379,
+        created_at: "2013-11-13T14:38:04Z",
+        event: "validate_run!",
+        from: "queued",
+        state_column: "state",
+        stateful_id: 4244,
+        stateful_type: "Run",
+        to: "validating",
+        transitioned_at: "2013-11-13T14:38:04Z",
+        updated_at: "2013-11-13T14:38:04Z"
+      },{
+        id: 11741378,
+        created_at: "2013-11-13T14:38:04Z",
+        event: "validated!",
+        from: "validating",
+        state_column: "state",
+        stateful_id: 4244,
+        stateful_type: "Run",
+        to: "in_progress",
+        transitioned_at: "2013-11-13T14:38:04Z",
+        updated_at: "2013-11-13T14:38:04Z"
+      }
+    ],
+    state: "in_progress",
+    result: "no_result",
+    expected_wait_time: 5400.0,
+    browsers: [
+      {
+        name: "chrome",
+        state: "enabled"
+      },{
+        name: "firefox",
+       state: "enabled"
+      },{
+        name: "ie8",
+        state: "enabled"
+      },{
+        name: "ie9",
+        state: "enabled"
+      },{
+        name: "safari",
+        state: "enabled"
+      }
+    ],
+    requested_tests: [2181]
   }
 end
 
-def test_delete_discount_response
+def test_run_array
   {
-    :deleted => true,
-    :id => "di_test_coupon"
+    data: [test_run, test_run, test_run],
+    url: '/1/runs'
   }
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rainforest
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.3
 platform: ruby
 authors:
 - Jon Calhon
@@ -126,6 +126,7 @@ files:
 - lib/.DS_Store
 - lib/data/ca-certificates.crt
 - lib/rainforest.rb
+- lib/rainforest/.DS_Store
 - lib/rainforest/api_operations/create.rb
 - lib/rainforest/api_operations/delete.rb
 - lib/rainforest/api_operations/list.rb
@@ -145,17 +146,15 @@ files:
 - lib/rainforest/util.rb
 - lib/rainforest/version.rb
 - rainforest.gemspec
-- test/stripe/account_test.rb
-- test/stripe/api_resource_test.rb
-- test/stripe/charge_test.rb
-- test/stripe/coupon_test.rb
-- test/stripe/customer_test.rb
-- test/stripe/invoice_test.rb
-- test/stripe/list_object_test.rb
-- test/stripe/metadata_test.rb
-- test/stripe/util_test.rb
+- test/.DS_Store
+- test/rainforest/.DS_Store
+- test/rainforest/api_resource_test.rb
+- test/rainforest/list_object_test.rb
+- test/rainforest/metadata_test.rb
+- test/rainforest/test_test.rb
+- test/rainforest/util_test.rb
 - test/test_helper.rb
-homepage: https://app.rainforestqa.com/docs/ruby
+homepage: https://github.com/joncalhoun/rainforest-ruby
 licenses: []
 metadata: {}
 post_install_message: 
@@ -179,13 +178,10 @@ signing_key:
 specification_version: 4
 summary: Ruby bindings for the Rainforest API
 test_files:
-- test/stripe/account_test.rb
-- test/stripe/api_resource_test.rb
-- test/stripe/charge_test.rb
-- test/stripe/coupon_test.rb
-- test/stripe/customer_test.rb
-- test/stripe/invoice_test.rb
-- test/stripe/list_object_test.rb
-- test/stripe/metadata_test.rb
-- test/stripe/util_test.rb
+- test/rainforest/.DS_Store
+- test/rainforest/api_resource_test.rb
+- test/rainforest/list_object_test.rb
+- test/rainforest/metadata_test.rb
+- test/rainforest/test_test.rb
+- test/rainforest/util_test.rb
 - test/test_helper.rb

data/test/stripe/account_test.rb

@@ -1,14 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-
-module Rainforest
-  class AccountTest < Test::Unit::TestCase
-    should "account should be retrievable" do
-      resp = {:email => "test+bindings@rainforest.com", :charge_enabled => false, :details_submitted => false}
-      @mock.expects(:get).once.returns(test_response(resp))
-      a = Rainforest::Account.retrieve
-      assert_equal "test+bindings@rainforest.com", a.email
-      assert !a.charge_enabled
-      assert !a.details_submitted
-    end
-  end
-end

data/test/stripe/api_resource_test.rb

@@ -1,345 +0,0 @@
-# -*- coding: utf-8 -*-
-require File.expand_path('../../test_helper', __FILE__)
-
-module Rainforest
-  class ApiResourceTest < Test::Unit::TestCase
-    should "creating a new APIResource should not fetch over the network" do
-      @mock.expects(:get).never
-      c = Rainforest::Customer.new("someid")
-    end
-
-    should "creating a new APIResource from a hash should not fetch over the network" do
-      @mock.expects(:get).never
-      c = Rainforest::Customer.construct_from({
-        :id => "somecustomer",
-        :card => {:id => "somecard", :object => "card"},
-        :object => "customer"
-      })
-    end
-
-    should "setting an attribute should not cause a network request" do
-      @mock.expects(:get).never
-      @mock.expects(:post).never
-      c = Rainforest::Customer.new("test_customer");
-      c.card = {:id => "somecard", :object => "card"}
-    end
-
-    should "accessing id should not issue a fetch" do
-      @mock.expects(:get).never
-      c = Rainforest::Customer.new("test_customer");
-      c.id
-    end
-
-    should "not specifying api credentials should raise an exception" do
-      Rainforest.api_key = nil
-      assert_raises Rainforest::AuthenticationError do
-        Rainforest::Customer.new("test_customer").refresh
-      end
-    end
-
-    should "specifying api credentials containing whitespace should raise an exception" do
-      Rainforest.api_key = "key "
-      assert_raises Rainforest::AuthenticationError do
-        Rainforest::Customer.new("test_customer").refresh
-      end
-    end
-
-    should "specifying invalid api credentials should raise an exception" do
-      Rainforest.api_key = "invalid"
-      response = test_response(test_invalid_api_key_error, 401)
-      assert_raises Rainforest::AuthenticationError do
-        @mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 401))
-        Rainforest::Customer.retrieve("failing_customer")
-      end
-    end
-
-    should "AuthenticationErrors should have an http status, http body, and JSON body" do
-      Rainforest.api_key = "invalid"
-      response = test_response(test_invalid_api_key_error, 401)
-      begin
-        @mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 401))
-        Rainforest::Customer.retrieve("failing_customer")
-      rescue Rainforest::AuthenticationError => e
-        assert_equal(401, e.http_status)
-        assert_equal(true, !!e.http_body)
-        assert_equal(true, !!e.json_body[:error][:message])
-        assert_equal(test_invalid_api_key_error['error']['message'], e.json_body[:error][:message])
-      end
-    end
-
-    context "when specifying per-object credentials" do
-      context "with no global API key set" do
-        should "use the per-object credential when creating" do
-          Rainforest.expects(:execute_request).with do |opts|
-            opts[:headers][:authorization] == 'Bearer sk_test_local'
-          end.returns(test_response(test_charge))
-
-          Rainforest::Charge.create({:card => {:number => '4242424242424242'}},
-            'sk_test_local')
-        end
-      end
-
-      context "with a global API key set" do
-        setup do
-          Rainforest.api_key = "global"
-        end
-
-        teardown do
-          Rainforest.api_key = nil
-        end
-
-        should "use the per-object credential when creating" do
-          Rainforest.expects(:execute_request).with do |opts|
-            opts[:headers][:authorization] == 'Bearer local'
-          end.returns(test_response(test_charge))
-
-          Rainforest::Charge.create({:card => {:number => '4242424242424242'}},
-            'local')
-        end
-
-        should "use the per-object credential when retrieving and making other calls" do
-          Rainforest.expects(:execute_request).with do |opts|
-            opts[:url] == "#{Rainforest.api_base}/v1/charges/ch_test_charge" &&
-              opts[:headers][:authorization] == 'Bearer local'
-          end.returns(test_response(test_charge))
-          Rainforest.expects(:execute_request).with do |opts|
-            opts[:url] == "#{Rainforest.api_base}/v1/charges/ch_test_charge/refund" &&
-              opts[:headers][:authorization] == 'Bearer local'
-          end.returns(test_response(test_charge))
-
-          ch = Rainforest::Charge.retrieve('ch_test_charge', 'local')
-          ch.refund
-        end
-      end
-    end
-
-    context "with valid credentials" do
-      should "urlencode values in GET params" do
-        response = test_response(test_charge_array)
-        @mock.expects(:get).with("#{Rainforest.api_base}/v1/charges?customer=test%20customer", nil, nil).returns(response)
-        charges = Rainforest::Charge.all(:customer => 'test customer').data
-        assert charges.kind_of? Array
-      end
-
-      should "construct URL properly with base query parameters" do
-        response = test_response(test_invoice_customer_array)
-        @mock.expects(:get).with("#{Rainforest.api_base}/v1/invoices?customer=test_customer", nil, nil).returns(response)
-        invoices = Rainforest::Invoice.all(:customer => 'test_customer')
-
-        @mock.expects(:get).with("#{Rainforest.api_base}/v1/invoices?customer=test_customer&paid=true", nil, nil).returns(response)
-        invoices.all(:paid => true)
-      end
-
-      should "a 400 should give an InvalidRequestError with http status, body, and JSON body" do
-        response = test_response(test_missing_id_error, 400)
-        @mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 404))
-        begin
-          Rainforest::Customer.retrieve("foo")
-        rescue Rainforest::InvalidRequestError => e
-          assert_equal(400, e.http_status)
-          assert_equal(true, !!e.http_body)
-          assert_equal(true, e.json_body.kind_of?(Hash))
-        end
-      end
-
-      should "a 401 should give an AuthenticationError with http status, body, and JSON body" do
-        response = test_response(test_missing_id_error, 401)
-        @mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 404))
-        begin
-          Rainforest::Customer.retrieve("foo")
-        rescue Rainforest::AuthenticationError => e
-          assert_equal(401, e.http_status)
-          assert_equal(true, !!e.http_body)
-          assert_equal(true, e.json_body.kind_of?(Hash))
-        end
-      end
-
-      should "a 402 should give a CardError with http status, body, and JSON body" do
-        response = test_response(test_missing_id_error, 402)
-        @mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 404))
-        begin
-          Rainforest::Customer.retrieve("foo")
-        rescue Rainforest::CardError => e
-          assert_equal(402, e.http_status)
-          assert_equal(true, !!e.http_body)
-          assert_equal(true, e.json_body.kind_of?(Hash))
-        end
-      end
-
-      should "a 404 should give an InvalidRequestError with http status, body, and JSON body" do
-        response = test_response(test_missing_id_error, 404)
-        @mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 404))
-        begin
-          Rainforest::Customer.retrieve("foo")
-        rescue Rainforest::InvalidRequestError => e
-          assert_equal(404, e.http_status)
-          assert_equal(true, !!e.http_body)
-          assert_equal(true, e.json_body.kind_of?(Hash))
-        end
-      end
-
-      should "setting a nil value for a param should exclude that param from the request" do
-        @mock.expects(:get).with do |url, api_key, params|
-          uri = URI(url)
-          query = CGI.parse(uri.query)
-          (url =~ %r{^#{Rainforest.api_base}/v1/charges?} &&
-           query.keys.sort == ['offset', 'sad'])
-        end.returns(test_response({ :count => 1, :data => [test_charge] }))
-        c = Rainforest::Charge.all(:count => nil, :offset => 5, :sad => false)
-
-        @mock.expects(:post).with do |url, api_key, params|
-          url == "#{Rainforest.api_base}/v1/charges" &&
-            api_key.nil? &&
-            CGI.parse(params) == { 'amount' => ['50'], 'currency' => ['usd'] }
-        end.returns(test_response({ :count => 1, :data => [test_charge] }))
-        c = Rainforest::Charge.create(:amount => 50, :currency => 'usd', :card => { :number => nil })
-      end
-
-      should "requesting with a unicode ID should result in a request" do
-        response = test_response(test_missing_id_error, 404)
-        @mock.expects(:get).once.with("#{Rainforest.api_base}/v1/customers/%E2%98%83", nil, nil).raises(RestClient::ExceptionWithResponse.new(response, 404))
-        c = Rainforest::Customer.new("☃")
-        assert_raises(Rainforest::InvalidRequestError) { c.refresh }
-      end
-
-      should "requesting with no ID should result in an InvalidRequestError with no request" do
-        c = Rainforest::Customer.new
-        assert_raises(Rainforest::InvalidRequestError) { c.refresh }
-      end
-
-      should "making a GET request with parameters should have a query string and no body" do
-        params = { :limit => 1 }
-        @mock.expects(:get).once.with("#{Rainforest.api_base}/v1/charges?limit=1", nil, nil).returns(test_response([test_charge]))
-        c = Rainforest::Charge.all(params)
-      end
-
-      should "making a POST request with parameters should have a body and no query string" do
-        params = { :amount => 100, :currency => 'usd', :card => 'sc_token' }
-        @mock.expects(:post).once.with do |url, get, post|
-          get.nil? && CGI.parse(post) == {'amount' => ['100'], 'currency' => ['usd'], 'card' => ['sc_token']}
-        end.returns(test_response(test_charge))
-        c = Rainforest::Charge.create(params)
-      end
-
-      should "loading an object should issue a GET request" do
-        @mock.expects(:get).once.returns(test_response(test_customer))
-        c = Rainforest::Customer.new("test_customer")
-        c.refresh
-      end
-
-      should "using array accessors should be the same as the method interface" do
-        @mock.expects(:get).once.returns(test_response(test_customer))
-        c = Rainforest::Customer.new("test_customer")
-        c.refresh
-        assert_equal c.created, c[:created]
-        assert_equal c.created, c['created']
-        c['created'] = 12345
-        assert_equal c.created, 12345
-      end
-
-      should "accessing a property other than id or parent on an unfetched object should fetch it" do
-        @mock.expects(:get).once.returns(test_response(test_customer))
-        c = Rainforest::Customer.new("test_customer")
-        c.charges
-      end
-
-      should "updating an object should issue a POST request with only the changed properties" do
-        @mock.expects(:post).with do |url, api_key, params|
-          url == "#{Rainforest.api_base}/v1/customers/c_test_customer" && api_key.nil? && CGI.parse(params) == {'description' => ['another_mn']}
-        end.once.returns(test_response(test_customer))
-        c = Rainforest::Customer.construct_from(test_customer)
-        c.description = "another_mn"
-        c.save
-      end
-
-      should "updating should merge in returned properties" do
-        @mock.expects(:post).once.returns(test_response(test_customer))
-        c = Rainforest::Customer.new("c_test_customer")
-        c.description = "another_mn"
-        c.save
-        assert_equal false, c.livemode
-      end
-
-      should "deleting should send no props and result in an object that has no props other deleted" do
-        @mock.expects(:get).never
-        @mock.expects(:post).never
-        @mock.expects(:delete).with("#{Rainforest.api_base}/v1/customers/c_test_customer", nil, nil).once.returns(test_response({ "id" => "test_customer", "deleted" => true }))
-
-        c = Rainforest::Customer.construct_from(test_customer)
-        c.delete
-        assert_equal true, c.deleted
-
-        assert_raises NoMethodError do
-          c.livemode
-        end
-      end
-
-      should "loading an object with properties that have specific types should instantiate those classes" do
-        @mock.expects(:get).once.returns(test_response(test_charge))
-        c = Rainforest::Charge.retrieve("test_charge")
-        assert c.card.kind_of?(Rainforest::RainforestObject) && c.card.object == 'card'
-      end
-
-      should "loading all of an APIResource should return an array of recursively instantiated objects" do
-        @mock.expects(:get).once.returns(test_response(test_charge_array))
-        c = Rainforest::Charge.all.data
-        assert c.kind_of? Array
-        assert c[0].kind_of? Rainforest::Charge
-        assert c[0].card.kind_of?(Rainforest::RainforestObject) && c[0].card.object == 'card'
-      end
-
-      context "error checking" do
-
-        should "404s should raise an InvalidRequestError" do
-          response = test_response(test_missing_id_error, 404)
-          @mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 404))
-
-          begin
-            Rainforest::Customer.new("test_customer").refresh
-            assert false #shouldn't get here either
-          rescue Rainforest::InvalidRequestError => e # we don't use assert_raises because we want to examine e
-            assert e.kind_of? Rainforest::InvalidRequestError
-            assert_equal "id", e.param
-            assert_equal "Missing id", e.message
-            return
-          end
-
-          assert false #shouldn't get here
-        end
-
-        should "5XXs should raise an APIError" do
-          response = test_response(test_api_error, 500)
-          @mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 500))
-
-          begin
-            Rainforest::Customer.new("test_customer").refresh
-            assert false #shouldn't get here either
-          rescue Rainforest::APIError => e # we don't use assert_raises because we want to examine e
-            assert e.kind_of? Rainforest::APIError
-            return
-          end
-
-          assert false #shouldn't get here
-        end
-
-        should "402s should raise a CardError" do
-          response = test_response(test_invalid_exp_year_error, 402)
-          @mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 402))
-
-          begin
-            Rainforest::Customer.new("test_customer").refresh
-            assert false #shouldn't get here either
-          rescue Rainforest::CardError => e # we don't use assert_raises because we want to examine e
-            assert e.kind_of? Rainforest::CardError
-            assert_equal "invalid_expiry_year", e.code
-            assert_equal "exp_year", e.param
-            assert_equal "Your card's expiration year is invalid", e.message
-            return
-          end
-
-          assert false #shouldn't get here
-        end
-      end
-    end
-  end
-end

data/test/stripe/charge_test.rb

@@ -1,67 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-
-module Rainforest
-  class ChargeTest < Test::Unit::TestCase
-    should "charges should be listable" do
-      @mock.expects(:get).once.returns(test_response(test_charge_array))
-      c = Rainforest::Charge.all
-      assert c.data.kind_of? Array
-      c.each do |charge|
-        assert charge.kind_of?(Rainforest::Charge)
-      end
-    end
-
-    should "charges should be refundable" do
-      @mock.expects(:get).never
-      @mock.expects(:post).once.returns(test_response({:id => "ch_test_charge", :refunded => true}))
-      c = Rainforest::Charge.new("test_charge")
-      c.refund
-      assert c.refunded
-    end
-
-    should "charges should not be deletable" do
-      assert_raises NoMethodError do
-        @mock.expects(:get).once.returns(test_response(test_charge))
-        c = Rainforest::Charge.retrieve("test_charge")
-        c.delete
-      end
-    end
-
-    should "charges should be updateable" do
-      @mock.expects(:get).once.returns(test_response(test_charge))
-      @mock.expects(:post).once.returns(test_response(test_charge))
-      c = Rainforest::Charge.new("test_charge")
-      c.refresh
-      c.mnemonic = "New charge description"
-      c.save
-    end
-
-    should "charges should have Card objects associated with their Card property" do
-      @mock.expects(:get).once.returns(test_response(test_charge))
-      c = Rainforest::Charge.retrieve("test_charge")
-      assert c.card.kind_of?(Rainforest::RainforestObject) && c.card.object == 'card'
-    end
-
-    should "execute should return a new, fully executed charge when passed correct parameters" do
-      @mock.expects(:post).with do |url, api_key, params|
-        url == "#{Rainforest.api_base}/v1/charges" && api_key.nil? && CGI.parse(params) == {
-          'currency' => ['usd'], 'amount' => ['100'],
-          'card[exp_year]' => ['2012'],
-          'card[number]' => ['4242424242424242'],
-          'card[exp_month]' => ['11']
-        }
-      end.once.returns(test_response(test_charge))
-
-      c = Rainforest::Charge.create({
-        :amount => 100,
-        :card => {
-          :number => "4242424242424242",
-          :exp_month => 11,
-          :exp_year => 2012,
-        },
-        :currency => "usd"
-      })
-      assert c.paid
-    end
-  end
-end

data/test/stripe/coupon_test.rb

@@ -1,11 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-
-module Rainforest
-  class CouponTest < Test::Unit::TestCase
-    should "create should return a new coupon" do
-      @mock.expects(:post).once.returns(test_response(test_coupon))
-      c = Rainforest::Coupon.create
-      assert_equal "co_test_coupon", c.id
-    end
-  end
-end

data/test/stripe/customer_test.rb

@@ -1,70 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-
-module Rainforest
-  class CustomerTest < Test::Unit::TestCase
-    should "customers should be listable" do
-      @mock.expects(:get).once.returns(test_response(test_customer_array))
-      c = Rainforest::Customer.all.data
-      assert c.kind_of? Array
-      assert c[0].kind_of? Rainforest::Customer
-    end
-
-    should "customers should be deletable" do
-      @mock.expects(:delete).once.returns(test_response(test_customer({:deleted => true})))
-      c = Rainforest::Customer.new("test_customer")
-      c.delete
-      assert c.deleted
-    end
-
-    should "customers should be updateable" do
-      @mock.expects(:get).once.returns(test_response(test_customer({:mnemonic => "foo"})))
-      @mock.expects(:post).once.returns(test_response(test_customer({:mnemonic => "bar"})))
-      c = Rainforest::Customer.new("test_customer").refresh
-      assert_equal c.mnemonic, "foo"
-      c.mnemonic = "bar"
-      c.save
-      assert_equal c.mnemonic, "bar"
-    end
-
-    should "create should return a new customer" do
-      @mock.expects(:post).once.returns(test_response(test_customer))
-      c = Rainforest::Customer.create
-      assert_equal "c_test_customer", c.id
-    end
-
-    should "be able to update a customer's subscription" do
-      @mock.expects(:get).once.returns(test_response(test_customer))
-      c = Rainforest::Customer.retrieve("test_customer")
-
-      @mock.expects(:post).once.with do |url, api_key, params|
-        url == "#{Rainforest.api_base}/v1/customers/c_test_customer/subscription" && api_key.nil? && CGI.parse(params) == {'plan' => ['silver']}
-      end.returns(test_response(test_subscription('silver')))
-      s = c.update_subscription({:plan => 'silver'})
-
-      assert_equal 'subscription', s.object
-      assert_equal 'silver', s.plan.identifier
-    end
-
-    should "be able to cancel a customer's subscription" do
-      @mock.expects(:get).once.returns(test_response(test_customer))
-      c = Rainforest::Customer.retrieve("test_customer")
-
-      # Not an accurate response, but whatever
-
-      @mock.expects(:delete).once.with("#{Rainforest.api_base}/v1/customers/c_test_customer/subscription?at_period_end=true", nil, nil).returns(test_response(test_subscription('silver')))
-      s = c.cancel_subscription({:at_period_end => 'true'})
-
-      @mock.expects(:delete).once.with("#{Rainforest.api_base}/v1/customers/c_test_customer/subscription", nil, nil).returns(test_response(test_subscription('silver')))
-      s = c.cancel_subscription
-    end
-
-    should "be able to delete a customer's discount" do
-      @mock.expects(:get).once.returns(test_response(test_customer))
-      c = Rainforest::Customer.retrieve("test_customer")
-
-      @mock.expects(:delete).once.with("#{Rainforest.api_base}/v1/customers/c_test_customer/discount", nil, nil).returns(test_response(test_delete_discount_response))
-      s = c.delete_discount
-      assert_equal nil, c.discount
-    end
-  end
-end

data/test/stripe/invoice_test.rb

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

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

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