payjp 0.0.2

data/lib/payjp/plan.rb

@@ -0,0 +1,8 @@
+module Payjp
+  class Plan < APIResource
+    include Payjp::APIOperations::Create
+    include Payjp::APIOperations::Delete
+    include Payjp::APIOperations::List
+    include Payjp::APIOperations::Update
+  end
+end

data/lib/payjp/subscription.rb

@@ -0,0 +1,37 @@
+module Payjp
+  class Subscription < APIResource
+    include Payjp::APIOperations::List
+    include Payjp::APIOperations::Create
+    include Payjp::APIOperations::Update
+    include Payjp::APIOperations::Delete
+
+    def pause(params = {}, opts = {})
+      response, opts = request(:post, pause_url, params, opts)
+      refresh_from(response, opts)
+    end
+
+    def resume(params = {}, opts = {})
+      response, opts = request(:post, resume_url, params, opts)
+      refresh_from(response, opts)
+    end
+
+    def cancel(params = {}, opts = {})
+      response, opts = request(:post, cancel_url, params, opts)
+      refresh_from(response, opts)
+    end
+
+    private
+
+    def pause_url
+      url + '/pause'
+    end
+
+    def resume_url
+      url + '/resume'
+    end
+
+    def cancel_url
+      url + '/cancel'
+    end
+  end
+end

data/lib/payjp/token.rb

@@ -0,0 +1,5 @@
+module Payjp
+  class Token < APIResource
+    include Payjp::APIOperations::Create
+  end
+end

data/lib/payjp/transfer.rb

@@ -0,0 +1,5 @@
+module Payjp
+  class Transfer < APIResource
+    include Payjp::APIOperations::List
+  end
+end

data/lib/payjp/util.rb

@@ -0,0 +1,121 @@
+module Payjp
+  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.object_classes
+      @object_classes ||= {
+        # data structures
+        'list' => ListObject,
+
+        # business objects
+        'account' => Account,
+        'card' => Card,
+        'charge' => Charge,
+        'customer' => Customer,
+        'event' => Event,
+        'plan' => Plan,
+        'subscription' => Subscription,
+        'token' => Token,
+        'transfer' => Transfer
+      }
+    end
+
+    def self.convert_to_payjp_object(resp, opts)
+      case resp
+      when Array
+        resp.map { |i| convert_to_payjp_object(i, opts) }
+      when Hash
+        # Try converting to a known object class.  If none available, fall back to generic PayjpObject
+        object_classes.fetch(resp[:object], PayjpObject).construct_from(resp, opts)
+      else
+        resp
+      end
+    end
+
+    def self.symbolize_names(object)
+      case object
+      when Hash
+        new_hash = {}
+        object.each do |key, value|
+          key = (key.to_sym rescue key) || key
+          new_hash[key] = symbolize_names(value)
+        end
+        new_hash
+      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
+
+    # The secondary opts argument can either be a string or hash
+    # Turn this value into an api_key and a set of headers
+    def self.normalize_opts(opts)
+      case opts
+      when String
+        { :api_key => opts }
+      when Hash
+        check_api_key!(opts.fetch(:api_key)) if opts.has_key?(:api_key)
+        opts.clone
+      else
+        raise TypeError.new('normalize_opts expects a string or a hash')
+      end
+    end
+
+    def self.check_string_argument!(key)
+      raise TypeError.new("argument must be a string") unless key.is_a?(String)
+      key
+    end
+
+    def self.check_api_key!(key)
+      raise TypeError.new("api_key must be a string") unless key.is_a?(String)
+      key
+    end
+  end
+end

data/lib/payjp/version.rb

@@ -0,0 +1,3 @@
+module Payjp
+  VERSION = '0.0.2'
+end

data/payjp.gemspec

@@ -0,0 +1,27 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), 'lib'))
+
+require 'payjp/version'
+
+Gem::Specification.new do |s|
+  s.name = 'payjp'
+  s.version = Payjp::VERSION
+  s.summary = 'Ruby bindings for the Payjp API'
+  s.description = 'PAY.JP is the easiest way to accept payments online.'
+  s.authors = ['PAY.JP']
+  s.email = ['support@pay.jp']
+  s.homepage = 'https://pay.jp'
+  s.license = 'MIT'
+
+  s.add_dependency('rest-client', '~> 1.4')
+  s.add_dependency('json', '~> 1.8.1')
+
+  s.add_development_dependency('mocha', '~> 0.13.2')
+  s.add_development_dependency('shoulda', '~> 3.4.0')
+  s.add_development_dependency('test-unit')
+  s.add_development_dependency('rake')
+
+  s.files = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- test/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
+  s.require_paths = ['lib']
+end

data/test/payjp/account_test.rb

@@ -0,0 +1,17 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+module Payjp
+  class AccountTest < Test::Unit::TestCase
+    should "be retrievable" do
+      resp = { :email => "test+bindings@pay.jp", :accounts_enabled => ['merchant', 'customer'], :merchant => { :bank_enabled => false } }
+      @mock.expects(:get).
+        once.
+        with("#{Payjp.api_base}/v1/accounts", nil, nil).
+        returns(test_response(resp))
+      a = Payjp::Account.retrieve
+      assert_equal "test+bindings@pay.jp", a.email
+      assert_equal ['merchant', 'customer'], a.accounts_enabled
+      assert !a.merchant.bank_enabled
+    end
+  end
+end

data/test/payjp/api_resource_test.rb

@@ -0,0 +1,445 @@
+# -*- coding: utf-8 -*-
+require File.expand_path('../../test_helper', __FILE__)
+
+module Payjp
+  class ApiResourceTest < Test::Unit::TestCase
+    should "creating a new APIResource should not fetch over the network" do
+      @mock.expects(:get).never
+      Payjp::Customer.new("someid")
+    end
+
+    should "creating a new APIResource from a hash should not fetch over the network" do
+      @mock.expects(:get).never
+      Payjp::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 = Payjp::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 = Payjp::Customer.new("test_customer")
+      c.id
+    end
+
+    should "not specifying api credentials should raise an exception" do
+      Payjp.api_key = nil
+      assert_raises Payjp::AuthenticationError do
+        Payjp::Customer.new("test_customer").refresh
+      end
+    end
+
+    should "using a nil api key should raise an exception" do
+      assert_raises TypeError do
+        Payjp::Customer.all({}, nil)
+      end
+      assert_raises TypeError do
+        Payjp::Customer.all({}, { :api_key => nil })
+      end
+    end
+
+    should "specifying api credentials containing whitespace should raise an exception" do
+      Payjp.api_key = "key "
+      assert_raises Payjp::AuthenticationError do
+        Payjp::Customer.new("test_customer").refresh
+      end
+    end
+
+    should "specifying invalid api credentials should raise an exception" do
+      Payjp.api_key = "invalid"
+      response = test_response(test_invalid_api_key_error, 401)
+      assert_raises Payjp::AuthenticationError do
+        @mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 401))
+        Payjp::Customer.retrieve("failing_customer")
+      end
+    end
+
+    should "AuthenticationErrors should have an http status, http body, and JSON body" do
+      Payjp.api_key = "invalid"
+      response = test_response(test_invalid_api_key_error, 401)
+      begin
+        @mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 401))
+        Payjp::Customer.retrieve("failing_customer")
+      rescue Payjp::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
+
+    should "send expand on fetch properly" do
+      @mock.expects(:get).once.
+        with("#{Payjp.api_base}/v1/charges/ch_test_charge?expand[]=customer", nil, nil).
+        returns(test_response(test_charge))
+
+      Payjp::Charge.retrieve({ :id => 'ch_test_charge', :expand => [:customer] })
+    end
+
+    should "preserve expand across refreshes" do
+      @mock.expects(:get).twice.
+        with("#{Payjp.api_base}/v1/charges/ch_test_charge?expand[]=customer", nil, nil).
+        returns(test_response(test_charge))
+
+      ch = Payjp::Charge.retrieve({ :id => 'ch_test_charge', :expand => [:customer] })
+      ch.refresh
+    end
+
+    should "send payjp account as header when set" do
+      payjp_account = "acct_0000"
+      Payjp.expects(:execute_request).with do |opts|
+        opts[:headers][:payjp_account] == payjp_account
+      end.returns(test_response(test_charge))
+
+      Payjp::Charge.create({ :card => { :number => '4242424242424242' } },
+                           { :payjp_account => payjp_account, :api_key => 'sk_test_local' })
+    end
+
+    should "not send payjp account as header when not set" do
+      Payjp.expects(:execute_request).with do |opts|
+        opts[:headers][:payjp_account].nil?
+      end.returns(test_response(test_charge))
+
+      Payjp::Charge.create({ :card => { :number => '4242424242424242' } },
+                           'sk_test_local')
+    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
+          api_key = 'sk_test_local'
+          Payjp.expects(:execute_request).with do |opts|
+            opts[:headers][:authorization] == encode_credentials(api_key)
+          end.returns(test_response(test_charge))
+
+          Payjp::Charge.create({ :card => { :number => '4242424242424242' } },
+                               api_key)
+        end
+      end
+
+      context "with a global API key set" do
+        setup do
+          Payjp.api_key = "global"
+        end
+
+        teardown do
+          Payjp.api_key = nil
+        end
+
+        should "use the per-object credential when creating" do
+          api_key = 'local'
+          Payjp.expects(:execute_request).with do |opts|
+            opts[:headers][:authorization] == encode_credentials(api_key)
+          end.returns(test_response(test_charge))
+
+          Payjp::Charge.create({ :card => { :number => '4242424242424242' } },
+                               api_key)
+        end
+
+        should "use the per-object credential when retrieving and making other calls" do
+          api_key = 'local'
+          Payjp.expects(:execute_request).with do |opts|
+            opts[:url] == "#{Payjp.api_base}/v1/charges/ch_test_charge" &&
+              opts[:headers][:authorization] == encode_credentials(api_key)
+          end.returns(test_response(test_charge))
+          Payjp.expects(:execute_request).with do |opts|
+            opts[:url] == "#{Payjp.api_base}/v1/charges/ch_test_charge/refund" &&
+              opts[:headers][:authorization] == encode_credentials(api_key)
+          end.returns(test_response(test_charge))
+
+          ch = Payjp::Charge.retrieve('ch_test_charge', api_key)
+          ch.refund
+        end
+      end
+    end
+
+    context "with valid credentials" do
+      should "send along the idempotency-key header" do
+        Payjp.expects(:execute_request).with do |opts|
+          opts[:headers][:idempotency_key] == 'bar'
+        end.returns(test_response(test_charge))
+
+        Payjp::Charge.create({ :card => { :number => '4242424242424242' } }, {
+          :idempotency_key => 'bar',
+          :api_key => 'local'
+        })
+      end
+
+      should "urlencode values in GET params" do
+        response = test_response(test_charge_array)
+        @mock.expects(:get).with("#{Payjp.api_base}/v1/charges?customer=test%20customer", nil, nil).returns(response)
+        charges = Payjp::Charge.all(:customer => 'test customer').data
+        assert charges.is_a? 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
+          Payjp::Customer.retrieve("foo")
+        rescue Payjp::InvalidRequestError => e
+          assert_equal(400, e.http_status)
+          assert_equal(true, !!e.http_body)
+          assert_equal(true, e.json_body.is_a?(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
+          Payjp::Customer.retrieve("foo")
+        rescue Payjp::AuthenticationError => e
+          assert_equal(401, e.http_status)
+          assert_equal(true, !!e.http_body)
+          assert_equal(true, e.json_body.is_a?(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
+          Payjp::Customer.retrieve("foo")
+        rescue Payjp::CardError => e
+          assert_equal(402, e.http_status)
+          assert_equal(true, !!e.http_body)
+          assert_equal(true, e.json_body.is_a?(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
+          Payjp::Customer.retrieve("foo")
+        rescue Payjp::InvalidRequestError => e
+          assert_equal(404, e.http_status)
+          assert_equal(true, !!e.http_body)
+          assert_equal(true, e.json_body.is_a?(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{^#{Payjp.api_base}/v1/charges?} &&
+           query.keys.sort == ['offset', 'sad'])
+        end.returns(test_response({ :count => 1, :data => [test_charge] }))
+        Payjp::Charge.all(:count => nil, :offset => 5, :sad => false)
+
+        @mock.expects(:post).with do |url, api_key, params|
+          url == "#{Payjp.api_base}/v1/charges" &&
+            api_key.nil? &&
+            CGI.parse(params) == { 'amount' => ['50'], 'currency' => ['jpy'] }
+        end.returns(test_response({ :count => 1, :data => [test_charge] }))
+        Payjp::Charge.create(:amount => 50, :currency => 'jpy', :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("#{Payjp.api_base}/v1/customers/%E2%98%83", nil, nil).raises(RestClient::ExceptionWithResponse.new(response, 404))
+        c = Payjp::Customer.new("☃")
+        assert_raises(Payjp::InvalidRequestError) { c.refresh }
+      end
+
+      should "requesting with no ID should result in an InvalidRequestError with no request" do
+        c = Payjp::Customer.new
+        assert_raises(Payjp::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("#{Payjp.api_base}/v1/charges?limit=1", nil, nil).returns(test_response([test_charge]))
+        Payjp::Charge.all(params)
+      end
+
+      should "making a POST request with parameters should have a body and no query string" do
+        params = { :amount => 100, :currency => 'jpy', :card => 'sc_token' }
+        @mock.expects(:post).once.with do |_url, get, post|
+          get.nil? && CGI.parse(post) == { 'amount' => ['100'], 'currency' => ['jpy'], 'card' => ['sc_token'] }
+        end.returns(test_response(test_charge))
+        Payjp::Charge.create(params)
+      end
+
+      should "loading an object should issue a GET request" do
+        @mock.expects(:get).once.returns(test_response(test_customer))
+        c = Payjp::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 = Payjp::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 "updating an object should issue a POST request with only the changed properties" do
+        @mock.expects(:post).with do |url, api_key, params|
+          url == "#{Payjp.api_base}/v1/customers/c_test_customer" && api_key.nil? && CGI.parse(params) == { 'description' => ['another_mn'] }
+        end.once.returns(test_response(test_customer))
+        c = Payjp::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 = Payjp::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("#{Payjp.api_base}/v1/customers/c_test_customer", nil, nil).once.returns(test_response({ "id" => "test_customer", "deleted" => true }))
+        c = Payjp::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 = Payjp::Charge.retrieve("test_charge")
+        assert c.card.is_a?(Payjp::PayjpObject) && 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 = Payjp::Charge.all.data
+        assert c.is_a? Array
+        assert c[0].is_a? Payjp::Charge
+        assert c[0].card.is_a?(Payjp::PayjpObject) && c[0].card.object == 'card'
+      end
+
+      should "passing in a payjp_account header should pass it through on call" do
+        Payjp.expects(:execute_request).with do |opts|
+          opts[:method] == :get &&
+            opts[:url] == "#{Payjp.api_base}/v1/customers/c_test_customer" &&
+            opts[:headers][:payjp_account] == 'acct_abc'
+        end.once.returns(test_response(test_customer))
+        Payjp::Customer.retrieve("c_test_customer", { :payjp_account => 'acct_abc' })
+      end
+
+      should "passing in a payjp_account header should pass it through on save" do
+        Payjp.expects(:execute_request).with do |opts|
+          opts[:method] == :get &&
+            opts[:url] == "#{Payjp.api_base}/v1/customers/c_test_customer" &&
+            opts[:headers][:payjp_account] == 'acct_abc'
+        end.once.returns(test_response(test_customer))
+        c = Payjp::Customer.retrieve("c_test_customer", { :payjp_account => 'acct_abc' })
+
+        Payjp.expects(:execute_request).with do |opts|
+          opts[:method] == :post &&
+            opts[:url] == "#{Payjp.api_base}/v1/customers/c_test_customer" &&
+            opts[:headers][:payjp_account] == 'acct_abc' &&
+            opts[:payload] == 'description=FOO'
+        end.once.returns(test_response(test_customer))
+        c.description = 'FOO'
+        c.save
+      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))
+
+          rescued = false
+          begin
+            Payjp::Customer.new("test_customer").refresh
+            assert false # shouldn't get here either
+          rescue Payjp::InvalidRequestError => e # we don't use assert_raises because we want to examine e
+            rescued = true
+            assert e.is_a? Payjp::InvalidRequestError
+            assert_equal "id", e.param
+            assert_equal "Missing id", e.message
+          end
+
+          assert_equal true, rescued
+        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))
+
+          rescued = false
+          begin
+            Payjp::Customer.new("test_customer").refresh
+            assert false # shouldn't get here either
+          rescue Payjp::APIError => e # we don't use assert_raises because we want to examine e
+            rescued = true
+            assert e.is_a? Payjp::APIError
+          end
+
+          assert_equal true, rescued
+        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))
+
+          rescued = false
+          begin
+            Payjp::Customer.new("test_customer").refresh
+            assert false # shouldn't get here either
+          rescue Payjp::CardError => e # we don't use assert_raises because we want to examine e
+            rescued = true
+            assert e.is_a? Payjp::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
+          end
+
+          assert_equal true, rescued
+        end
+      end
+
+      should 'save nothing if nothing changes' do
+        ch = Payjp::Charge.construct_from({
+          :id => 'charge_id',
+          :customer => {
+            :object => 'customer',
+            :id => 'customer_id'
+          }
+        })
+
+        @mock.expects(:post).once.with("#{Payjp.api_base}/v1/charges/charge_id", nil, '').returns(test_response({ "id" => "charge_id" }))
+        ch.save
+      end
+
+      should 'not save nested API resources' do
+        ch = Payjp::Charge.construct_from({
+          :id => 'charge_id',
+          :customer => {
+            :object => 'customer',
+            :id => 'customer_id'
+          }
+        })
+
+        @mock.expects(:post).once.with("#{Payjp.api_base}/v1/charges/charge_id", nil, '').returns(test_response({ "id" => "charge_id" }))
+
+        ch.customer.description = 'Bob'
+        ch.save
+      end
+    end
+  end
+end