nihaopay-ruby 0.1.0

data/lib/nihaopay/transactions/purchase.rb

@@ -0,0 +1,11 @@
+module Nihaopay
+  module Transactions
+    class Purchase < Authorize
+      class << self
+        def capture_param
+          true
+        end
+      end
+    end
+  end
+end

data/lib/nihaopay/transactions/refund.rb

@@ -0,0 +1,31 @@
+module Nihaopay
+  module Transactions
+    class Refund < Base
+      VALID_OPTIONS = %i(reason).freeze
+
+      attr_accessor :refunded, :refund_transaction_id
+
+      class << self
+        def start(transaction_id, amount, currency, options = {})
+          @token = options.delete(:token)
+          url = request_url(transaction_id)
+          params = Nihaopay::HashUtil.slice(options, *VALID_OPTIONS).merge(amount: amount, currency: currency)
+          response = HTTParty.post(url, headers: request_headers, body: request_body(params))
+          build_from_response!(response)
+        end
+
+        def request_url(transaction_id)
+          "#{base_url}/transactions/#{transaction_id}/refund"
+        end
+
+        def valid_attributes
+          %i(transaction_id status refunded refund_transaction_id)
+        end
+
+        def response_keys_map
+          { id: :transaction_id, transaction_id: :refund_transaction_id }
+        end
+      end
+    end
+  end
+end

data/lib/nihaopay/transactions/release.rb

@@ -0,0 +1,28 @@
+module Nihaopay
+  module Transactions
+    class Release < Base
+      attr_accessor :released, :release_transaction_id
+
+      class << self
+        def start(transaction_id, options = {})
+          @token = options.delete(:token)
+          url = request_url(transaction_id)
+          response = HTTParty.post(url, headers: request_headers, body: request_body)
+          build_from_response!(response)
+        end
+
+        def request_url(transaction_id)
+          "#{base_url}/transactions/#{transaction_id}/release"
+        end
+
+        def valid_attributes
+          %i(transaction_id status released release_transaction_id)
+        end
+
+        def response_keys_map
+          { id: :transaction_id, transaction_id: :release_transaction_id }
+        end
+      end
+    end
+  end
+end

data/lib/nihaopay/util/hash_util.rb

@@ -0,0 +1,30 @@
+# Emulates Hash methods from ActiveSupport without monkey-patching the Hash class directly.
+module Nihaopay
+  module HashUtil
+    class << self
+      def symbolize_keys(hash)
+        result = {}
+        hash.each_key do |key|
+          result[(key.to_sym rescue key)] = hash[key]
+        end
+        result
+      end
+
+      def stringify_keys(hash)
+        result = {}
+        hash.each_key do |key|
+          result[(key.to_s rescue key)] = hash[key]
+        end
+        result
+      end
+
+      def slice(hash, *keys)
+        result = {}
+        keys.each do |key|
+          result[key] = hash[key] if hash.key?(key)
+        end
+        result
+      end
+    end
+  end
+end

data/lib/nihaopay/version.rb

@@ -0,0 +1,3 @@
+module Nihaopay
+  VERSION = '0.1.0'.freeze
+end

data/spec/credit_card_spec.rb

@@ -0,0 +1,56 @@
+require_relative 'spec_helper'
+
+describe Nihaopay::CreditCard do
+  let(:number) { '6221558812340000' }
+  let(:attributes) { { number: number, expiry_year: 17, expiry_month: 11, cvv: '123' } }
+  let(:cc) { described_class.new(attributes) }
+
+  describe '#attr_accessor' do
+    subject { described_class.new }
+    it { is_expected.to respond_to :number= }
+    it { is_expected.to respond_to :number }
+    it { is_expected.to respond_to :expiry_year= }
+    it { is_expected.to respond_to :expiry_year }
+    it { is_expected.to respond_to :expiry_month= }
+    it { is_expected.to respond_to :expiry_month }
+    it { is_expected.to respond_to :cvv= }
+    it { is_expected.to respond_to :cvv }
+  end
+
+  describe '#initialize' do
+    context 'when attributes not passed' do
+      subject { described_class.new }
+      it { is_expected.to be_a Nihaopay::CreditCard }
+    end
+
+    context 'when attributes passed as stringified hash' do
+      subject { described_class.new(Nihaopay::HashUtil.stringify_keys(attributes)) }
+      it { expect(subject.number).to eq number }
+      it { expect(subject.expiry_year).to eq 17 }
+      it { expect(subject.expiry_month).to eq 11 }
+      it { expect(subject.cvv).to eq '123' }
+    end
+
+    context 'with invalid attributes' do
+      subject { described_class.new(foo: 'bar') }
+      it { is_expected.to be_a Nihaopay::CreditCard }
+      it { expect(subject.number).to be_nil }
+      it { expect(subject.expiry_year).to be_nil }
+      it { expect(subject.expiry_month).to be_nil }
+      it { expect(subject.cvv).to be_nil }
+    end
+
+    context 'with valid attributes' do
+      subject { cc }
+      it { expect(subject.number).to eq number }
+      it { expect(subject.expiry_year).to eq 17 }
+      it { expect(subject.expiry_month).to eq 11 }
+      it { expect(subject.cvv).to eq '123' }
+    end
+  end
+
+  describe '#to_params_hash' do
+    let(:expected) { { card_number: number, card_exp_year: 17, card_exp_month: 11, card_cvv: '123' } }
+    it { expect(cc.to_params_hash).to eq expected }
+  end
+end

data/spec/merchant_spec.rb

@@ -0,0 +1,142 @@
+require_relative 'spec_helper'
+
+describe Nihaopay::Merchant do
+  let(:token) { '6c4dc4828474fa73c5f438a9eb2' }
+  let(:merchant) { described_class.new(token) }
+
+  describe '#attr_accessor' do
+    subject { merchant }
+    it { is_expected.to respond_to :token= }
+    it { is_expected.to respond_to :token }
+  end
+
+  describe '#initialize' do
+    it { expect(merchant.token).to eq token }
+  end
+
+  describe '#union_pay' do
+    context 'when options not passed' do
+      it { expect(Nihaopay::SecurePay::UnionPay).to receive(:start).with(100, 'JPY', token: token) }
+      after { merchant.union_pay(100, 'JPY') }
+    end
+
+    context 'when options passed' do
+      let(:options) do
+        { reference: '3461fcc31aec471780ad1a4dc6111947',
+          ipn_url: 'http://website.com/ipn',
+          callback_url: 'http://website.com/callback' }
+      end
+      let(:expected_opts) { options.merge(token: token) }
+      it { expect(Nihaopay::SecurePay::UnionPay).to receive(:start).with(100, 'JPY', expected_opts) }
+      after { merchant.union_pay(100, 'JPY', options) }
+    end
+  end
+
+  describe '#ali_pay' do
+    context 'when options not passed' do
+      it { expect(Nihaopay::SecurePay::AliPay).to receive(:start).with(100, 'JPY', token: token) }
+      after { merchant.ali_pay(100, 'JPY') }
+    end
+
+    context 'when options passed' do
+      let(:options) do
+        { reference: '3461fcc31aec471780ad1a4dc6111947',
+          ipn_url: 'http://website.com/ipn',
+          callback_url: 'http://website.com/callback' }
+      end
+      let(:expected_opts) { options.merge(token: token) }
+      it { expect(Nihaopay::SecurePay::AliPay).to receive(:start).with(100, 'JPY', expected_opts) }
+      after { merchant.ali_pay(100, 'JPY', options) }
+    end
+  end
+
+  describe '#wechat_pay' do
+    context 'when options not passed' do
+      it { expect(Nihaopay::SecurePay::WeChatPay).to receive(:start).with(100, 'JPY', token: token) }
+      after { merchant.wechat_pay(100, 'JPY') }
+    end
+
+    context 'when options passed' do
+      let(:options) do
+        { reference: '3461fcc31aec471780ad1a4dc6111947',
+          ipn_url: 'http://website.com/ipn',
+          callback_url: 'http://website.com/callback' }
+      end
+      let(:expected_opts) { options.merge(token: token) }
+      it { expect(Nihaopay::SecurePay::WeChatPay).to receive(:start).with(100, 'JPY', expected_opts) }
+      after { merchant.wechat_pay(100, 'JPY', options) }
+    end
+  end
+
+  describe '#authorize' do
+    let(:cc_attrs) { { number: '6221558812340000', expiry_year: 17, expiry_month: 11, cvv: '123' } }
+    let(:cc) { Nihaopay::CreditCard.new(cc_attrs) }
+
+    context 'when options not passed' do
+      it { expect(Nihaopay::Transactions::Authorize).to receive(:start).with(100, cc, token: token) }
+      after { merchant.authorize(100, cc) }
+    end
+
+    context 'when options passed' do
+      let(:options) do
+        { currency: 'USD',
+          description: 'Lorem Ipsum',
+          reference: '3461fcc31aec471780ad1a4dc6111947' }
+      end
+      let(:expected_opts) { options.merge(token: token) }
+      it { expect(Nihaopay::Transactions::Authorize).to receive(:start).with(100, cc, expected_opts) }
+      after { merchant.authorize(100, cc, options) }
+    end
+  end
+
+  describe '#capture' do
+    it do
+      expect(Nihaopay::Transactions::Capture).to receive(:start).with('20160718111604002633',
+                                                                      100, 'JPY', token: token)
+    end
+    after { merchant.capture('20160718111604002633', 100, 'JPY') }
+  end
+
+  describe '#purchase' do
+    let(:cc_attrs) { { number: '6221558812340000', expiry_year: 17, expiry_month: 11, cvv: '123' } }
+    let(:cc) { Nihaopay::CreditCard.new(cc_attrs) }
+
+    context 'when options not passed' do
+      it { expect(Nihaopay::Transactions::Purchase).to receive(:start).with(100, cc, token: token) }
+      after { merchant.purchase(100, cc) }
+    end
+
+    context 'when options passed' do
+      let(:options) do
+        { currency: 'USD',
+          description: 'Lorem Ipsum',
+          reference: '3461fcc31aec471780ad1a4dc6111947' }
+      end
+      let(:expected_opts) { options.merge(token: token) }
+      it { expect(Nihaopay::Transactions::Purchase).to receive(:start).with(100, cc, expected_opts) }
+      after { merchant.purchase(100, cc, options) }
+    end
+  end
+
+  describe '#release' do
+    let(:txn_id) { '20160718111604002633' }
+    it { expect(Nihaopay::Transactions::Release).to receive(:start).with(txn_id, token: token) }
+    after { merchant.release(txn_id) }
+  end
+
+  describe '#refund' do
+    let(:txn_id) { '20160718111604002633' }
+
+    context 'when options not passed' do
+      it { expect(Nihaopay::Transactions::Refund).to receive(:start).with(txn_id, 100, 'JPY', token: token) }
+      after { merchant.refund(txn_id, 100, 'JPY') }
+    end
+
+    context 'when options passed' do
+      let(:options) { { reason: 'Out of stock' } }
+      let(:expected_opts) { options.merge(token: token) }
+      it { expect(Nihaopay::Transactions::Refund).to receive(:start).with(txn_id, 100, 'JPY', expected_opts) }
+      after { merchant.refund(txn_id, 100, 'JPY', options) }
+    end
+  end
+end

data/spec/mixins/api_spec.rb

@@ -0,0 +1,81 @@
+require_relative '../spec_helper'
+
+class ApiTest
+  include Nihaopay::Api
+end
+
+describe Nihaopay::Api do
+  let(:token) { '6c4dc4828474fa73c5f438a9eb2f' }
+
+  before do
+    Nihaopay.test_mode = true
+    Nihaopay.token = token
+  end
+
+  describe 'ClassMethods' do
+    describe '.host' do
+      context 'when test mode' do
+        it { expect(ApiTest.host).to eq 'http://api.test.nihaopay.com' }
+      end
+
+      context 'when not test mode' do
+        before { Nihaopay.test_mode = false }
+        it { expect(ApiTest.host).to eq 'https://api.nihaopay.com' }
+      end
+    end
+
+    describe '.base_url' do
+      it { expect(ApiTest.base_url).to eq 'http://api.test.nihaopay.com/v1.1' }
+    end
+
+    describe '.authorization' do
+      let(:expected) { { 'Authorization' => "Bearer #{token}" } }
+      it { expect(ApiTest.authorization).to eq expected }
+    end
+
+    describe '.merchant_token' do
+      context 'when local' do
+        let(:token_2) { 'bf3092e441d9f2ea5fbcf93b51a2' }
+        before { ApiTest.instance_variable_set(:@token, token_2) }
+        it { expect(ApiTest.merchant_token).to eq token_2 }
+        after { ApiTest.instance_variable_set(:@token, nil) }
+      end
+
+      context 'when global' do
+        it { expect(ApiTest.merchant_token).to eq token }
+      end
+    end
+
+    describe '.validate_resource!' do
+      before { allow(response).to receive(:parsed_response) { parsed_response } }
+      let(:response) { Object.new }
+      let(:parsed_response) { nil }
+
+      context 'when parsed_response not contains :id' do
+        let(:parsed_response) { { 'code' => 200 } }
+        it { expect { ApiTest.validate_resource!(response) }.to raise_error(Nihaopay::TransactionError) }
+      end
+
+      context 'when parsed_response contains :id' do
+        let(:parsed_response) { { 'id' => '20160714132438002485', 'code' => 200 } }
+        it { expect { ApiTest.validate_resource!(response) }.to_not raise_error(Nihaopay::TransactionError) }
+      end
+    end
+
+    describe '.validate_collection!' do
+      before { allow(response).to receive(:parsed_response) { parsed_response } }
+      let(:response) { Object.new }
+      let(:parsed_response) { nil }
+
+      context 'when parsed_response not contains :transactions' do
+        let(:parsed_response) { { 'code' => 200 } }
+        it { expect { ApiTest.validate_collection!(response) }.to raise_error(Nihaopay::TransactionError) }
+      end
+
+      context 'when parsed_response contains :transactions' do
+        let(:parsed_response) { { 'transactions' => [{ 'id' => '20160714132438002485', 'code' => 200 }] } }
+        it { expect { ApiTest.validate_collection!(response) }.to_not raise_error(Nihaopay::TransactionError) }
+      end
+    end
+  end
+end

data/spec/mixins/queryable_spec.rb

@@ -0,0 +1,95 @@
+require_relative '../spec_helper'
+
+describe Nihaopay::Queryable do
+  describe 'ClassMethods' do
+    describe '.delegate' do
+      before { allow(Nihaopay::Transactions::Base).to receive(:q) { q } }
+      let(:q) { Nihaopay::Query.new }
+
+      describe '.limit' do
+        it { expect(q).to receive(:limit) }
+        after { Nihaopay::Transactions::Base.limit(1) }
+      end
+
+      describe '.before' do
+        it { expect(q).to receive(:before) }
+        after { Nihaopay::Transactions::Base.before(Time.now) }
+      end
+
+      describe '.after' do
+        it { expect(q).to receive(:after) }
+        after { Nihaopay::Transactions::Base.after(Time.now) }
+      end
+    end
+
+    describe '.find' do
+      before do
+        allow(response).to receive(:parsed_response) { parsed_response }
+        allow(HTTParty).to receive(:get) { response }
+      end
+      let(:response) { Object.new }
+      let(:parsed_response) { nil }
+
+      context 'when response does not contain transaction details' do
+        let(:parsed_response) do
+          { 'status' => 'success',
+            'type' => 'charge',
+            'amount' => 1000 }
+        end
+        it 'should raise an error' do
+          err = Nihaopay::TransactionLookUpError
+          expect { Nihaopay::Transactions::Base.find('20160714132438002485') }.to raise_error(err)
+        end
+      end
+
+      context 'when response contains transaction details' do
+        let(:parsed_response) do
+          { 'id' => '20160714132438002485',
+            'status' => 'success',
+            'type' => 'charge',
+            'amount' => 1000 }
+        end
+        it 'should return a transaction object' do
+          txn = Nihaopay::Transactions::Base.find('20160714132438002485')
+          expect(txn).to be_a Nihaopay::Transactions::Base
+          expect(txn.transaction_id).to eq '20160714132438002485'
+          expect(txn.status).to eq 'success'
+          expect(txn.type).to eq 'charge'
+          expect(txn.amount).to eq 1000
+        end
+      end
+    end
+
+    describe '.fetch' do
+      before { allow(Nihaopay::Transactions::Base).to receive(:q) { q } }
+      let(:q) { Nihaopay::Query.new }
+
+      context 'when :after present in options' do
+        let(:options) { { after: '2016-06-01T01:00:00Z', limit: 5 } }
+        it { expect(q).to receive(:fetch).with(starting_after: '2016-06-01T01:00:00Z', limit: 5) }
+        after { Nihaopay::Transactions::Base.fetch(options) }
+      end
+
+      context 'when :before present in options' do
+        let(:options) { { before: '2016-06-01T01:00:00Z', limit: 5 } }
+        it { expect(q).to receive(:fetch).with(ending_before: '2016-06-01T01:00:00Z', limit: 5) }
+        after { Nihaopay::Transactions::Base.fetch(options) }
+      end
+
+      context 'when :after and :before not present in options' do
+        let(:options) { { limit: 5 } }
+        it { expect(q).to receive(:fetch).with(limit: 5) }
+        after { Nihaopay::Transactions::Base.fetch(options) }
+      end
+
+      context 'when options not passed' do
+        it { expect(q).to receive(:fetch).with({}) }
+        after { Nihaopay::Transactions::Base.fetch }
+      end
+    end
+
+    describe '.q' do
+      it { expect(Nihaopay::Transactions::Base.send(:q)).to be_a Nihaopay::Query }
+    end
+  end
+end