paysio 1.0.0 → 1.0.2

data/lib/paysio/singleton_api_resource.rb

@@ -1,20 +0,0 @@
-module Paysio
-  class SingletonAPIResource < APIResource
-    def self.url()
-      if self == SingletonAPIResource
-        raise NotImplementedError.new('SingletonAPIResource is an abstract class.  You should perform actions on its subclasses (Account, etc.)')
-      end
-      "/v1/#{CGI.escape(class_name.downcase)}"
-    end
-
-    def url
-      self.class.url
-    end
-
-    def self.retrieve(api_key=nil)
-      instance = self.new(nil, api_key)
-      instance.refresh
-      instance
-    end
-  end
-end

data/lib/paysio/util.rb

@@ -1,100 +0,0 @@
-module Paysio
-  module Util
-    def self.objects_to_ids(h)
-      case h
-      when APIResource
-        h.id
-      when Hash
-        res = {}
-        h.each { |k, v| res[k] = objects_to_ids(v) unless v.nil? }
-        res
-      when Array
-        h.map { |v| objects_to_ids(v) }
-      else
-        h
-      end
-    end
-
-    def self.convert_to_paysio_object(resp, api_key)
-      types = {
-        'charge' => Charge,
-        'customer' => Customer,
-        'coupon' => Coupon,
-        'event' => Event,
-        'list' => ListObject
-      }
-      case resp
-      when Array
-        resp.map { |i| convert_to_paysio_object(i, api_key) }
-      when Hash
-        # Try converting to a known object class.  If none available, fall back to generic APIResource
-        if klass_name = resp[:object]
-          klass = types[klass_name]
-        end
-        klass ||= PaysioObject
-        klass.construct_from(resp, api_key)
-      else
-        resp
-      end
-    end
-
-    def self.file_readable(file)
-      begin
-        File.open(file) { |f| }
-      rescue
-        false
-      else
-        true
-      end
-    end
-
-    def self.symbolize_names(object)
-      case object
-      when Hash
-        new = {}
-        object.each do |key, value|
-          key = (key.to_sym rescue key) || key
-          new[key] = symbolize_names(value)
-        end
-        new
-      when Array
-        object.map { |value| symbolize_names(value) }
-      else
-        object
-      end
-    end
-
-    def self.url_encode(key)
-      URI.escape(key.to_s, Regexp.new("[^#{URI::PATTERN::UNRESERVED}]"))
-    end
-
-    def self.flatten_params(params, parent_key=nil)
-      result = []
-      params.each do |key, value|
-        calculated_key = parent_key ? "#{parent_key}[#{url_encode(key)}]" : url_encode(key)
-        if value.is_a?(Hash)
-          result += flatten_params(value, calculated_key)
-        elsif value.is_a?(Array)
-          result += flatten_params_array(value, calculated_key)
-        else
-          result << [calculated_key, value]
-        end
-      end
-      result
-    end
-
-    def self.flatten_params_array(value, calculated_key)
-      result = []
-      value.each do |elem|
-        if elem.is_a?(Hash)
-          result += flatten_params(elem, calculated_key)
-        elsif elem.is_a?(Array)
-          result += flatten_params_array(elem, calculated_key)
-        else
-          result << ["#{calculated_key}[]", elem]
-        end
-      end
-      result
-    end
-  end
-end

data/test/test_helper.rb

@@ -1,162 +0,0 @@
-require 'stringio'
-require 'test/unit'
-require 'paysio'
-require 'mocha'
-include Mocha
-
-#monkeypatch request methods
-module Paysio
-  @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('@paysio_values', { :body => body, :code => code })
-  def m.body; @paysio_values[:body]; end
-  def m.code; @paysio_values[:code]; end
-  m
-end
-
-def test_customer(params={})
-  {
-    :subscription_history => [],
-    :bills => [],
-    :charges => [],
-    :livemode => false,
-    :object => "customer",
-    :id => "c_test_customer",
-    :active_card => {
-      :type => "Visa",
-      :last4 => "4242",
-      :exp_month => 11,
-      :country => "US",
-      :exp_year => 2012,
-      :id => "cc_test_card",
-      :object => "card"
-    },
-    :created => 1304114758
-  }.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
-  }.merge(params)
-end
-
-def test_charge_array
-  {
-    :data => [test_charge, test_charge, test_charge],
-    :object => 'list',
-    :url => '/v1/charges'
-  }
-end
-
-def test_card(params={})
-  {
-    :type => "Visa",
-    :last4 => "4242",
-    :exp_month => 11,
-    :country => "US",
-    :exp_year => 2012,
-    :id => "cc_test_card",
-    :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
-
-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

data/test/test_paysio.rb

@@ -1,479 +0,0 @@
-# -*- coding: utf-8 -*-
-require File.expand_path('../test_helper', __FILE__)
-require 'test/unit'
-require 'shoulda'
-require 'mocha'
-require 'pp'
-require 'rest-client'
-require 'cgi'
-require 'uri'
-
-class TestPaysioRuby < Test::Unit::TestCase
-  include Mocha
-
-  context "Util" do
-    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 = Paysio::Util.symbolize_names(start)
-      assert_equal(finish, symbolized)
-    end
-  end
-
-  context "API Bindings" do
-    setup do
-      @mock = mock
-      Paysio.mock_rest_client = @mock
-    end
-
-    teardown do
-      Paysio.mock_rest_client = nil
-    end
-
-    should "creating a new APIResource should not fetch over the network" do
-      @mock.expects(:get).never
-      c = Paysio::Customer.new("someid")
-    end
-
-    should "creating a new APIResource from a hash should not fetch over the network" do
-      @mock.expects(:get).never
-      c = Paysio::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 = Paysio::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 = Paysio::Customer.new("test_customer");
-      c.id
-    end
-
-    should "not specifying api credentials should raise an exception" do
-      Paysio.api_key = nil
-      assert_raises Paysio::AuthenticationError do
-        Paysio::Customer.new("test_customer").refresh
-      end
-    end
-
-    should "specifying invalid api credentials should raise an exception" do
-      Paysio.api_key = "invalid"
-      response = test_response(test_invalid_api_key_error, 401)
-      assert_raises Paysio::AuthenticationError do
-        @mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 401))
-        Paysio::Customer.retrieve("failing_customer")
-      end
-    end
-
-    should "AuthenticationErrors should have an http status, http body, and JSON body" do
-      Paysio.api_key = "invalid"
-      response = test_response(test_invalid_api_key_error, 401)
-      begin
-        @mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 401))
-        Paysio::Customer.retrieve("failing_customer")
-      rescue Paysio::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 "with valid credentials" do
-      setup do
-        Paysio.api_key="foo"
-      end
-
-      teardown do
-        Paysio.api_key=nil
-      end
-
-      should "urlencode values in GET params" do
-        response = test_response(test_charge_array)
-        @mock.expects(:get).with("#{Paysio.api_base}/v1/charges?customer=test%20customer", nil, nil).returns(response)
-        charges = Paysio::Charge.all(:customer => 'test customer').data
-        assert charges.kind_of? Array
-      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
-          Paysio::Customer.retrieve("foo")
-        rescue Paysio::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
-          Paysio::Customer.retrieve("foo")
-        rescue Paysio::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
-          Paysio::Customer.retrieve("foo")
-        rescue Paysio::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
-          Paysio::Customer.retrieve("foo")
-        rescue Paysio::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{^#{Paysio.api_base}/v1/charges?} &&
-           query.keys.sort == ['offset', 'sad'])
-        end.returns(test_response({ :count => 1, :data => [test_charge] }))
-        c = Paysio::Charge.all(:count => nil, :offset => 5, :sad => false)
-
-        @mock.expects(:post).with do |url, api_key, params|
-          url == "#{Paysio.api_base}/v1/charges" && api_key.nil? && CGI.parse(params) == { 'amount' => ['50'], 'currency' => ['usd'] }
-        end.returns(test_response({ :count => 1, :data => [test_charge] }))
-        c = Paysio::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("#{Paysio.api_base}/v1/customers/%E2%98%83", nil, nil).raises(RestClient::ExceptionWithResponse.new(response, 404))
-        c = Paysio::Customer.new("☃")
-        assert_raises(Paysio::InvalidRequestError) { c.refresh }
-      end
-
-      should "requesting with no ID should result in an InvalidRequestError with no request" do
-        c = Paysio::Customer.new
-        assert_raises(Paysio::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("#{Paysio.api_base}/v1/charges?limit=1", nil, nil).returns(test_response([test_charge]))
-        c = Paysio::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 = Paysio::Charge.create(params)
-      end
-
-      should "loading an object should issue a GET request" do
-        @mock.expects(:get).once.returns(test_response(test_customer))
-        c = Paysio::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 = Paysio::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 = Paysio::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 == "#{Paysio.api_base}/v1/customers/c_test_customer" && api_key.nil? && CGI.parse(params) == {'mnemonic' => ['another_mn']}
-        end.once.returns(test_response(test_customer))
-        c = Paysio::Customer.construct_from(test_customer)
-        c.mnemonic = "another_mn"
-        c.save
-      end
-
-      should "updating should merge in returned properties" do
-        @mock.expects(:post).once.returns(test_response(test_customer))
-        c = Paysio::Customer.new("c_test_customer")
-        c.mnemonic = "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("#{Paysio.api_base}/v1/customers/c_test_customer", nil, nil).once.returns(test_response({ "id" => "test_customer", "deleted" => true }))
-
-        c = Paysio::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 = Paysio::Charge.retrieve("test_charge")
-        assert c.card.kind_of?(Paysio::PaysioObject) && 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 = Paysio::Charge.all.data
-        assert c.kind_of? Array
-        assert c[0].kind_of? Paysio::Charge
-        assert c[0].card.kind_of?(Paysio::PaysioObject) && c[0].card.object == 'card'
-      end
-
-      context "account tests" do
-        should "account should be retrievable" do
-          resp = {:email => "test+bindings@stripe.com", :charge_enabled => false, :details_submitted => false}
-          @mock.expects(:get).once.returns(test_response(resp))
-          a = Paysio::Account.retrieve
-          assert_equal "test+bindings@stripe.com", a.email
-          assert !a.charge_enabled
-          assert !a.details_submitted
-        end
-      end
-
-      context "list tests" do
-        should "be able to retrieve full lists given a listobject" do
-          @mock.expects(:get).twice.returns(test_response(test_charge_array))
-          c = Paysio::Charge.all
-          assert c.kind_of?(Paysio::ListObject)
-          assert_equal('/v1/charges', c.url)
-          all = c.all
-          assert all.kind_of?(Paysio::ListObject)
-          assert_equal('/v1/charges', all.url)
-          assert all.data.kind_of?(Array)
-        end
-      end
-
-      context "charge tests" do
-
-        should "charges should be listable" do
-          @mock.expects(:get).once.returns(test_response(test_charge_array))
-          c = Paysio::Charge.all
-          assert c.data.kind_of? Array
-          c.each do |charge|
-            assert charge.kind_of?(Paysio::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 = Paysio::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 = Paysio::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 = Paysio::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 = Paysio::Charge.retrieve("test_charge")
-          assert c.card.kind_of?(Paysio::PaysioObject) && 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 == "#{Paysio.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 = Paysio::Charge.create({
-            :amount => 100,
-            :card => {
-              :number => "4242424242424242",
-              :exp_month => 11,
-              :exp_year => 2012,
-            },
-            :currency => "usd"
-          })
-          assert c.paid
-        end
-
-      end
-
-      context "customer tests" do
-
-        should "customers should be listable" do
-          @mock.expects(:get).once.returns(test_response(test_customer_array))
-          c = Paysio::Customer.all.data
-          assert c.kind_of? Array
-          assert c[0].kind_of? Paysio::Customer
-        end
-
-        should "customers should be deletable" do
-          @mock.expects(:delete).once.returns(test_response(test_customer({:deleted => true})))
-          c = Paysio::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 = Paysio::Customer.new("test_customer").refresh
-          assert_equal c.mnemonic, "foo"
-          c.mnemonic = "bar"
-          c.save
-          assert_equal c.mnemonic, "bar"
-        end
-
-        should "customers should have Card objects associated with their active_ard property" do
-          @mock.expects(:get).once.returns(test_response(test_customer))
-          c = Paysio::Customer.retrieve("test_customer")
-          assert c.active_card.kind_of?(Paysio::PaysioObject) && c.active_card.object == 'card'
-        end
-
-        should "create should return a new customer" do
-          @mock.expects(:post).once.returns(test_response(test_customer))
-          c = Paysio::Customer.create
-          assert_equal "c_test_customer", c.id
-        end
-
-        should "be able to delete a customer's discount" do
-          @mock.expects(:get).once.returns(test_response(test_customer))
-          c = Paysio::Customer.retrieve("test_customer")
-
-          @mock.expects(:delete).once.with("#{Paysio.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
-
-      context "coupon tests" do
-        should "create should return a new coupon" do
-          @mock.expects(:post).once.returns(test_response(test_coupon))
-          c = Paysio::Coupon.create
-          assert_equal "co_test_coupon", c.id
-        end
-      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
-            Paysio::Customer.new("test_customer").refresh
-            assert false #shouldn't get here either
-          rescue Paysio::InvalidRequestError => e # we don't use assert_raises because we want to examine e
-            assert e.kind_of? Paysio::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
-            Paysio::Customer.new("test_customer").refresh
-            assert false #shouldn't get here either
-          rescue Paysio::APIError => e # we don't use assert_raises because we want to examine e
-            assert e.kind_of? Paysio::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
-            Paysio::Customer.new("test_customer").refresh
-            assert false #shouldn't get here either
-          rescue Paysio::CardError => e # we don't use assert_raises because we want to examine e
-            assert e.kind_of? Paysio::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