spree_komoju 0.0.5 → 0.0.6

data/db/migrate/20150402013829_create_spree_pay_easies.rb

@@ -0,0 +1,24 @@
+class CreateSpreePayEasies < ActiveRecord::Migration
+  def change
+    create_table :spree_pay_easies do |t|
+      t.string  :email
+      t.string  :phone
+      t.string  :given_name
+      t.string  :family_name
+      t.string  :given_name_kana
+      t.string  :family_name_kana
+      t.integer :user_id
+      t.integer :payment_method_id
+      t.string  :brand, default: "pay_easy"
+      t.string  :instructions_url
+      t.string  :bank_id
+      t.string  :customer_id
+      t.string  :confirmation_id
+      t.datetime :expires_at
+
+      t.timestamps null: false
+    end
+    add_index :spree_pay_easies, :user_id
+    add_index :spree_pay_easies, :payment_method_id
+  end
+end

data/db/migrate/20151209053401_create_spree_web_moneys.rb

@@ -0,0 +1,17 @@
+class CreateSpreeWebMoneys < ActiveRecord::Migration
+  def change
+    create_table :spree_web_moneys do |t|
+      t.string :email
+      t.string :payment_uuid
+      t.integer :short_amount
+      t.text :prepaid_cards
+      t.integer :user_id
+      t.integer :payment_method_id
+      t.string :brand, default: "web_moneys"
+
+      t.timestamps null: false
+    end
+    add_index :spree_web_moneys, :user_id
+    add_index :spree_web_moneys, :payment_method_id
+  end
+end

data/lib/active_merchant/billing/gateways/komoju.rb

@@ -24,6 +24,11 @@ module ActiveMerchant #:nodoc:
         super
       end
 
+      def continue(uuid, payment_details)
+        details = {payment_details: payment_details}
+        commit("/payments/#{uuid}", details, :patch)
+      end
+
       def purchase(money, payment, options = {})
         post = {}
         post[:amount] = amount(money)
@@ -91,10 +96,10 @@ module ActiveMerchant #:nodoc:
         post[:fraud_details] = details unless details.empty?
       end
 
-      def api_request(path, data)
+      def api_request(method, path, data)
         raw_response = nil
         begin
-          raw_response = ssl_post("#{url}#{path}", data, headers)
+          raw_response = ssl_request(method, "#{url}#{path}", data, headers)
         rescue ResponseError => e
           raw_response = e.response.body
         end
@@ -102,8 +107,8 @@ module ActiveMerchant #:nodoc:
         JSON.parse(raw_response)
       end
 
-      def commit(path, params)
-        response = api_request(path, params.to_json)
+      def commit(path, params, method = :post)
+        response = api_request(method, path, params.to_json)
         success = !response.key?("error")
         message = (success ? "Transaction succeeded" : response["error"]["message"])
         Response.new(

data/lib/ext/activemerchant/connection.rb

@@ -0,0 +1,47 @@
+module ActiveMerchant
+  class Connection
+    def request(method, body, headers = {})
+      request_start = Time.now.to_f
+
+      retry_exceptions(:max_retries => max_retries, :logger => logger, :tag => tag) do
+        begin
+          info "connection_http_method=#{method.to_s.upcase} connection_uri=#{endpoint}", tag
+
+          result = nil
+
+          realtime = Benchmark.realtime do
+            result = case method
+            when :get
+              raise ArgumentError, "GET requests do not support a request body" if body
+              http.get(endpoint.request_uri, headers)
+            when :post
+              debug body
+              http.post(endpoint.request_uri, body, RUBY_184_POST_HEADERS.merge(headers))
+            when :patch
+              debug body
+              http.patch(endpoint.request_uri, body, headers)
+            when :put
+              debug body
+              http.put(endpoint.request_uri, body, headers)
+            when :delete
+              # It's kind of ambiguous whether the RFC allows bodies
+              # for DELETE requests. But Net::HTTP's delete method
+              # very unambiguously does not.
+              raise ArgumentError, "DELETE requests do not support a request body" if body
+              http.delete(endpoint.request_uri, headers)
+            else
+              raise ArgumentError, "Unsupported request method #{method.to_s.upcase}"
+            end
+          end
+
+          info "--> %d %s (%d %.4fs)" % [result.code, result.message, result.body ? result.body.length : 0, realtime], tag
+          debug result.body
+          result
+        end
+      end
+
+    ensure
+      info "connection_request_total_time=%.4fs" % [Time.now.to_f - request_start], tag
+    end
+  end
+end

data/lib/spree_komoju/controller_helpers.rb

@@ -0,0 +1,29 @@
+module SpreeKomoju
+  module ControllerHelpers
+    def permitted_source_attributes
+      super.push(permitted_komoju_konbini_attributes)
+      super.push(permitted_komoju_banktransfer_attributes)
+      super.push(permitted_komoju_pay_easy_attributes)
+      super.push(permitted_komoju_web_money_attributes)
+      super.flatten.uniq
+    end
+
+    private
+
+    def permitted_komoju_konbini_attributes
+      :convenience
+    end
+
+    def permitted_komoju_banktransfer_attributes
+      [:email, :phone, :family_name, :given_name, :family_name_kana, :given_name_kana]
+    end
+
+    def permitted_komoju_pay_easy_attributes
+      [:email, :phone, :family_name, :given_name, :family_name_kana, :given_name_kana]
+    end
+
+    def permitted_komoju_web_money_attributes
+      [:email, :prepaid_number]
+    end
+  end
+end

data/lib/spree_komoju/engine.rb

@@ -1,5 +1,6 @@
 module SpreeKomoju
   mattr_accessor :enable_customer_profiles
+  mattr_accessor :komoju_webhook_secret_token
 
   class Engine < Rails::Engine
     require 'spree/core'
@@ -10,6 +11,8 @@ module SpreeKomoju
       app.config.spree.payment_methods << Spree::Gateway::KomojuCreditCard
       app.config.spree.payment_methods << Spree::Gateway::KomojuKonbini
       app.config.spree.payment_methods << Spree::Gateway::KomojuBankTransfer
+      app.config.spree.payment_methods << Spree::Gateway::KomojuPayEasy
+      app.config.spree.payment_methods << Spree::Gateway::KomojuWebMoney
     end
 
     # use rspec for tests

data/lib/spree_komoju/errors.rb

@@ -0,0 +1,5 @@
+module SpreeKomoju
+  module Errors
+    class UnsupportedCurrency < StandardError; end
+  end
+end

data/lib/spree_komoju.rb

@@ -1,2 +1,10 @@
 require 'spree_core'
 require 'spree_komoju/engine'
+require 'spree_komoju/errors'
+require 'spree_komoju/controller_helpers'
+
+# This extension adds HTTP PATCH to ssl_request.
+# This is needed for WebMoney multi-card in Komoju.
+if ActiveMerchant::VERSION == "1.47.0"
+  require 'ext/activemerchant/connection'
+end

data/spec/controllers/spree/checkout_controller_spec.rb

@@ -6,7 +6,7 @@ describe Spree::CheckoutController, type: :controller do
       source_attributes = [:number, :month, :year, :expiry, :verification_value, :first_name, :last_name, :cc_type,
                            :gateway_customer_profile_id, :gateway_payment_profile_id, :last_digits, :name,
                            :encrypted_data, :convenience, :email, :phone, :family_name, :given_name, :family_name_kana,
-                           :given_name_kana]
+                           :given_name_kana, :prepaid_number]
       expect(controller.permitted_source_attributes).to eq source_attributes
     end
   end

data/spec/controllers/spree/komoju_controller_spec.rb

@@ -0,0 +1,82 @@
+require "spec_helper"
+
+describe Spree::KomojuController, type: :controller do
+  routes { Spree::Core::Engine.routes }
+
+  describe "#callback" do
+    context 'when callback is verified' do
+      before do
+        allow(OpenSSL::HMAC).to receive(:hexdigest) { "signature" }
+        request.env["HTTP_X_KOMOJU_SIGNATURE"] = "signature"
+      end
+
+      context 'when type is ping' do
+        it 'returns a successful response' do
+          post :callback, {type: "ping"}
+
+          expect(response.status).to eq(200)
+        end
+      end
+
+      context 'when type is payment.captured' do
+        let(:payment) { double Spree::Payment, complete!: true, completed?: completed }
+        let(:capture_params) do
+          {
+            "type" => "payment.captured",
+            "data" => {
+              "external_order_num" => "SPREEORDER-PAYMENTID",
+            }
+          }
+        end
+
+        context 'when payment exists' do
+          context 'when payment has already been completed' do
+            let(:completed) { true }
+
+            it 'does nothing' do
+              allow(Spree::Payment).to receive(:find_by_number!) { payment }
+
+              post :callback, capture_params
+
+              expect(payment).to_not have_received(:complete!)
+            end 
+          end
+
+          context 'when payment has not been completed yet' do
+            let(:completed) { false }
+
+            it 'marks a payment as complete' do
+              allow(Spree::Payment).to receive(:find_by_number!) { payment }
+
+              post :callback, capture_params
+
+              expect(payment).to have_received(:complete!)
+            end 
+          end
+        end
+
+        context 'when payment doesnt exist' do
+          it 'raises an activerecord error' do
+            expect {
+              post :callback, capture_params
+            }.to raise_error(ActiveRecord::RecordNotFound)
+          end    
+        end
+      end
+
+      context 'when type is not recognized' do
+        it 'returns an unauthorized status code' do
+          post :callback, {type: "bad_type"} 
+          expect(response.status).to eq(401)
+        end 
+      end
+    end  
+
+    context 'when callback is unverified' do
+      it 'returns head unauthorized' do
+        post :callback
+        expect(response.status).to eq(401)
+      end 
+    end
+  end
+end

data/spec/models/spree/bank_transfer_spec.rb

@@ -4,63 +4,7 @@ describe Spree::BankTransfer, type: :model do
   subject { described_class.new }
 
   describe "#actions" do
-    it { expect(subject.actions).to eq ["capture", "void"] }
-  end
-
-  describe "#can_capture?" do
-    let(:payment) { double(Spree::Payment, state: state) }
-
-    before do
-      allow(subject).to receive(:payment) { payment }
-    end
-
-    context "when payment state is not checkout or pending" do
-      let(:state) { "void" }
-
-      it { expect(subject.can_capture?(payment)).to be_falsy }
-    end
-
-    context "when payment state is pending" do
-      let(:payment) { double(Spree::Payment, state: state, source: source) }
-      let(:state) { "pending" }
-      let(:source) { double(Spree::BankTransfer, expires_at: expires_at) }
-
-      before do
-        allow(subject).to receive(:payment) { payment }
-      end
-
-      context "when expires_at is tomorrow" do
-        let(:expires_at) { Date.tomorrow }
-
-        it { expect(subject.can_capture?(payment)).to be_truthy }
-      end
-
-      context "when expires_at is yesterday" do
-        let(:expires_at) { Date.yesterday}
-
-        it { expect(subject.can_capture?(payment)).to be_falsy }
-      end
-    end
-  end
-
-  describe "#can_void?" do
-    let(:payment) { double(Spree::Payment, state: state) }
-
-    before do
-      allow(subject).to receive(:payment) { payment }
-    end
-
-    context "when payment state is void" do
-      let(:state) { "void" }
-
-      it { expect(subject.can_void?(payment)).to be_falsy }
-    end
-
-    context "when payment state is pending" do
-      let(:state) { "pending" }
-
-      it { expect(subject.can_void?(payment)).to be_truthy }
-    end
+    it { expect(subject.actions).to eq [] }
   end
 
   describe "#instructions_partial_path" do

data/spec/models/spree/gateway/komoju_pay_easy_spec.rb

@@ -0,0 +1,92 @@
+require "spec_helper"
+
+describe Spree::Gateway::KomojuPayEasy, type: :model do
+  subject { described_class.new }
+
+  describe "#authorize" do
+    let(:money) { 1000.0 }
+    let(:source) do
+      Spree::PayEasy.create!(
+        email: "email",
+        given_name: "given_name",
+        family_name: "family_name",
+        given_name_kana: "given_name_kana",
+        family_name_kana: "family_name_kana"
+      )
+    end
+    let(:options) { { login: "api_key", shipping: 100.0, tax: 200.0, subtotal: 800.0, discount: 100.0,
+                      currency: currency } }
+    let(:details) do
+      {
+        type: "pay_easy",
+        phone: nil,
+        email: "email",
+        given_name: "given_name",
+        family_name: "family_name",
+        given_name_kana: "given_name_kana",
+        family_name_kana: "family_name_kana"
+      }
+    end
+    let(:params) do
+      {
+        "payment_deadline" => Time.now.iso8601.to_s,
+        "payment_details" => {
+          "bank_id" => "bank_id",
+          "customer_id" => "customer_id",
+          "confirmation_id" => "confirmation_id",
+          "instructions_url" => "instructions_url"
+        }
+      }
+    end
+
+    let(:response) { double(ActiveMerchant::Billing::Response, params: params, success?: true) }
+
+    before do
+      allow_any_instance_of(Spree::Gateway::KomojuPayEasy).to receive(:options) { options }
+    end
+
+    context "with currency is JPY" do
+      let(:currency) { "JPY" }
+
+      it 'updates the source payment' do
+        expect_any_instance_of(ActiveMerchant::Billing::KomojuGateway).to receive(:purchase) { response }
+
+        subject.authorize(money, source, options)
+        expect(source.bank_id).to eq("bank_id")
+        expect(source.customer_id).to eq("customer_id")
+        expect(source.confirmation_id).to eq("confirmation_id")
+        expect(source.instructions_url).to eq("instructions_url")
+      end
+
+      it "creates a payment with correct active merchant options" do
+        options_converted_to_dollars = { login: "api_key", shipping: 1.0, tax: 2.0, subtotal: 8.0, discount: 1.0, currency: currency }
+        expect_any_instance_of(ActiveMerchant::Billing::KomojuGateway).to receive(:purchase).with(998.0, details, options_converted_to_dollars) { response }
+
+        subject.authorize(money, source, options)
+      end
+    end
+
+    context "with currency is USD" do
+      let(:currency) { "USD" }
+
+      it "creates a payment with correct active merchant options" do
+        expect_any_instance_of(ActiveMerchant::Billing::KomojuGateway).to receive(:purchase).with(800.0, details, options) { response }
+
+        subject.authorize(money, source, options)
+      end
+    end
+
+    context 'when response is not successful' do
+      let(:currency) { "JPY" }
+
+      it 'does not update the source payment' do
+        response = double(ActiveMerchant::Billing::Response, params: params, success?: false)
+        expect_any_instance_of(ActiveMerchant::Billing::KomojuGateway).to receive(:purchase) { response }
+
+        subject.authorize(money, source, options)
+
+        expect(source.instructions_url).to be_nil
+      end
+    end
+  end
+end

data/spec/models/spree/gateway/komoju_web_money_spec.rb

@@ -0,0 +1,108 @@
+require "spec_helper"
+
+describe Spree::Gateway::KomojuWebMoney do
+  subject { described_class.new }
+
+  describe "#auto_captured?" do
+    it { should be_auto_capture }
+  end 
+
+  describe "#purchase" do
+    let(:money) { 1000.0 }
+    let(:source) { Spree::WebMoney.create!( email: "foo@bar.com", prepaid_number: "1111111111111111") }
+    let(:options) { { login: "api_key", shipping: 100.0, tax: 200.0, subtotal: 800.0, discount: 100.0, order_id: "ORDERID-PAYMENTID", currency: "JPY" } }
+    let(:order) { double Spree::Order, payments: [] }
+    let(:response) { ActiveMerchant::Billing::Response.new(true, "success", response_params) }
+    let(:response_params) do
+      {
+        "status" => "captured",
+        "payment_deadline" => Time.now.iso8601.to_s,
+        "payment_details" => {
+          "short_amount" => 1000,
+          "prepaid_cards" => [
+            {
+              "last_four_digits" => "1111",
+              "points" => 100 
+            }
+          ]
+        }
+      }
+    end
+
+    context 'with valid parameters' do
+      context 'when its a new webmoney request' do
+        it "updates the source payment" do
+          stub_order(order)
+          expect_any_instance_of(ActiveMerchant::Billing::KomojuGateway).to receive(:purchase) { response }
+
+          subject.purchase(money, source, options)
+          expect(source.prepaid_cards).to eq([{"last_four_digits" => "1111", "points" => 100}])
+          expect(source.short_amount).to eq(1000)
+        end
+
+        it "creates a payment with correct active merchant options" do
+          stub_order(order)
+          options_converted_to_dollars = options.merge({shipping: 1.0, tax: 2.0, subtotal: 8.0, discount: 1.0})
+          payment_details = {type: "web_money", email: "foo@bar.com", prepaid_number: "1111111111111111"}
+          expect_any_instance_of(ActiveMerchant::Billing::KomojuGateway).to receive(:purchase).with(998.0, payment_details, options_converted_to_dollars) { response }
+
+          subject.purchase(money, source, options)
+        end
+
+        context 'when the status is pending' do
+          it 'returns an insufficient funds error' do
+            stub_order(order)
+            expect_any_instance_of(ActiveMerchant::Billing::KomojuGateway).to receive(:purchase) { response }
+            response_params["status"] = 'pending'
+
+            response = subject.purchase(money, source, options)
+
+            expect(response).to_not be_success
+            expect(response.message).to eq(I18n.t('spree.komoju.web_money.insufficient_funds'))
+          end  
+        end
+      end
+
+      context 'when webmoney request is continued' do
+        let(:webmoney) { double Spree::WebMoney, payment_uuid: "123" }
+        let(:payment) { double Spree::Payment, source: webmoney }
+        let(:order) { double Spree::Order, payments: [payment, payment] }
+
+        it 'makes an activemerchant continue request' do
+          stub_order(order)
+          expect_any_instance_of(ActiveMerchant::Billing::KomojuGateway).to receive(:continue).
+            with("123", {type: "web_money", email: "foo@bar.com", prepaid_number: "1111111111111111"}).
+            and_return(response)
+
+          subject.purchase(money, source, options)
+        end
+
+        it 'updates the prepaid cards hash on source' do
+          stub_order(order)
+          allow_any_instance_of(ActiveMerchant::Billing::KomojuGateway).
+            to receive(:continue).and_return(response)
+
+          subject.purchase(money, source, options)
+
+          expect(source.prepaid_cards).to eq(response_params["payment_details"]["prepaid_cards"])
+          expect(source.short_amount).to eq(response_params["payment_details"]["short_amount"])
+        end
+      end 
+    end
+
+    context 'with invalid parameters' do
+      context 'when currency is not JPY' do
+        it 'raises an unsupported currency exception' do
+          expect {
+            subject.purchase(nil, nil, currency: "USD") 
+          }.to raise_error(SpreeKomoju::Errors::UnsupportedCurrency)
+        end 
+      end 
+    end
+  end
+
+  def stub_order(order)
+    allow_any_instance_of(Spree::Gateway::KomojuWebMoney).to receive(:options) { options }
+    allow(Spree::Order).to receive(:find_by_number) { order }
+  end
+end

data/spec/models/spree/konbini_spec.rb

@@ -4,63 +4,7 @@ describe Spree::Konbini, type: :model do
   subject { described_class.new }
 
   describe "#actions" do
-    it { expect(subject.actions).to eq ["capture", "void"] }
-  end
-
-  describe "#can_capture?" do
-    let(:payment) { double(Spree::Payment, state: state) }
-
-    before do
-      allow(subject).to receive(:payment) { payment }
-    end
-
-    context "when payment state is not checkout or pending" do
-      let(:state) { "void" }
-
-      it { expect(subject.can_capture?(payment)).to be_falsy }
-    end
-
-    context "when payment state is pending" do
-      let(:payment) { double(Spree::Payment, state: state, source: source) }
-      let(:state) { "pending" }
-      let(:source) { double(Spree::Konbini, expires_at: expires_at) }
-
-      before do
-        allow(subject).to receive(:payment) { payment }
-      end
-
-      context "when expires_at is tomorrow" do
-        let(:expires_at) { Date.tomorrow }
-
-        it { expect(subject.can_capture?(payment)).to be_truthy }
-      end
-
-      context "when expires_at is yesterday" do
-        let(:expires_at) { Date.yesterday}
-
-        it { expect(subject.can_capture?(payment)).to be_falsy }
-      end
-    end
-  end
-
-  describe "#can_void?" do
-    let(:payment) { double(Spree::Payment, state: state) }
-
-    before do
-      allow(subject).to receive(:payment) { payment }
-    end
-
-    context "when payment state is void" do
-      let(:state) { "void" }
-
-      it { expect(subject.can_void?(payment)).to be_falsy }
-    end
-
-    context "when payment state is pending" do
-      let(:state) { "pending" }
-
-      it { expect(subject.can_void?(payment)).to be_truthy }
-    end
+    it { expect(subject.actions).to eq [] }
   end
 
   describe "#instructions_partial_path" do

data/spec/models/spree/pay_easy_spec.rb

@@ -0,0 +1,13 @@
+require "spec_helper"
+
+describe Spree::PayEasy, type: :model do
+  subject { described_class.new }
+
+  describe "#actions" do
+    it { expect(subject.actions).to eq [] }
+  end
+
+  describe "#instructions_partial_path" do
+    it { expect(subject.instructions_partial_path).to eq "spree/orders/pay_easy" }
+  end
+end

data/spec/models/spree/web_money_decorator_spec.rb

@@ -0,0 +1,24 @@
+require "spec_helper"
+
+describe Spree::WebMoneyDecorator, type: :model do
+  context 'when source is webmoney' do
+    it 'delegates methods' do
+      source = Spree::WebMoney.new(prepaid_cards: [], short_amount: 1000, payment_uuid: "123")
+      decorator = Spree::WebMoneyDecorator.new(source)
+
+      expect(decorator.prepaid_cards).to eq([])
+      expect(decorator.payment_uuid).to eq("123")
+      expect(decorator.short_amount).to eq(1000)
+    end
+  end
+
+  context 'when source is nill' do
+    it 'delegates methods to nil' do
+      decorator = Spree::WebMoneyDecorator.new(nil) 
+
+      expect(decorator.prepaid_cards).to be_nil
+      expect(decorator.payment_uuid).to be_nil
+      expect(decorator.short_amount).to be_nil
+    end
+  end
+end

data/spec/models/spree/web_money_spec.rb

@@ -0,0 +1,13 @@
+require "spec_helper"
+
+describe Spree::WebMoney, type: :model do
+  subject { described_class.new } 
+
+  describe "#actions" do
+    it { expect(subject.actions).to eq [] }
+  end
+
+  describe "#instructions_partial_path" do
+    it { expect(subject.instructions_partial_path).to eq "spree/orders/web_money" }
+  end
+end

data/spree_komoju.gemspec

@@ -2,7 +2,7 @@
 Gem::Specification.new do |s|
   s.platform    = Gem::Platform::RUBY
   s.name        = 'spree_komoju'
-  s.version     = '0.0.5'
+  s.version     = '0.0.6'
   s.summary     = 'Spree Komoju Payment Gateway'
   s.description = 'Spree Payment gateway for Komoju payment gateway'
   s.authors     = ['Masahiro Saito', 'Chris Salzberg', 'Richard Ramsden']