dune-balanced-bankaccount 1.0.0

data/spec/controllers/dune/balanced/bankaccount/payments_controller_spec.rb

@@ -0,0 +1,158 @@
+require 'spec_helper'
+
+describe Dune::Balanced::Bankaccount::PaymentsController do
+  routes { Dune::Balanced::Bankaccount::Engine.routes }
+
+  let(:current_user) { double('User').as_null_object }
+
+  let(:bank_account) do
+    double('::Balanced::BankAccount', href: '/ABANK').as_null_object
+  end
+
+  let(:customer) do
+    double('::Balanced::Customer',
+           bank_accounts: [bank_account],
+           href:           '/qwertyuiop').as_null_object
+  end
+
+  before do
+    ::Balanced::Customer.stub(:find).and_return(customer)
+    ::Balanced::Customer.stub(:new).and_return(customer)
+    ::Balanced::BankAccount.stub(:find).and_return(bank_account)
+    Dune::Balanced::Bankaccount::PaymentGenerator.any_instance.stub(:complete)
+  end
+
+  context 'authenticated' do
+    before { sign_in FactoryGirl.create(:user) }
+
+    describe 'get new' do
+      it 'should use accounts controller new action' do
+        expect_any_instance_of(
+          Dune::Balanced::Bankaccount::AccountsController
+        ).to receive(:new)
+        get :new, contribution_id: 42
+      end
+    end
+
+    describe 'POST create' do
+      shared_examples_for '#create' do
+        let(:payment) do
+          double('Payment', status: :succeeded).as_null_object
+        end
+        let(:params) do
+          {
+            'payment' => {
+              resource_id_name => resource.id.to_s,
+              'use_bank'       => '/ABANK',
+              'user'           => {}
+            },
+          }
+        end
+        let(:resource) { FactoryGirl.create(resource_class.to_s.underscore) }
+
+        it 'should receive authenticate_user!' do
+          expect(controller).to receive(:authenticate_user!)
+          post :create, params
+        end
+
+        before do
+          Dune::Balanced::Bankaccount::PaymentGenerator.
+            any_instance.
+            stub(:status).
+            and_return(:succeeded)
+        end
+
+        it 'generates new payment with given params' do
+          Dune::Balanced::Bankaccount::PaymentGenerator.should_receive(:new).
+            with(customer, an_instance_of(resource_class), params['payment']).
+            and_return(payment)
+          post :create, params
+        end
+
+        it 'completes a payment of the resource' do
+          Dune::Balanced::Bankaccount::PaymentGenerator.any_instance.should_receive(:complete)
+          post :create, params
+        end
+
+        context 'with successul checkout' do
+          it 'redirects to contribute page' do
+            post :create, params
+            expect(response).to redirect_to(resource_path)
+          end
+        end
+
+        context 'with pending checkout status' do
+          before do
+            Dune::Balanced::Bankaccount::PaymentGenerator.
+              any_instance.
+              stub(:status).
+              and_return(:pending)
+          end
+
+          it 'redirects to contribute page' do
+            post :create, params
+            expect(response).to redirect_to(resource_path)
+          end
+        end
+
+        context 'with unsuccessul checkout' do
+          before do
+            Dune::Balanced::Bankaccount::PaymentGenerator.
+              any_instance.
+              stub(:status).
+              and_return(:failed)
+          end
+
+          it 'redirects to resource edit page' do
+            post :create, params
+            expect(response).to redirect_to(edit_resource_path)
+          end
+        end
+
+        describe 'insertion of bank account to a customer' do
+          it 'should use accounts controller attach_bank_to_customer method' do
+            expect_any_instance_of(
+              Dune::Balanced::Bankaccount::AccountsController
+            ).to receive(:attach_bank_to_customer)
+            post :create, params
+          end
+        end
+
+        describe 'update customer' do
+          it 'update user attributes and balanced customer' do
+            expect_any_instance_of(
+              Dune::Balanced::Customer
+            ).to receive(:update!)
+            post :create, params
+          end
+        end
+      end
+
+      context 'when resource is Contribution' do
+        let(:resource_class)     { Contribution }
+        let(:resource_id_name)   { 'contribution_id' }
+        let(:resource_path) do
+          project_contribution_path(resource.project, resource)
+        end
+        let(:edit_resource_path) do
+          edit_project_contribution_path(resource.project, resource)
+        end
+
+        it_should_behave_like '#create'
+      end
+
+      context 'when resource is Match' do
+        let(:resource_class)     { Match }
+        let(:resource_id_name)   { 'match_id' }
+        let(:resource_path) do
+          project_match_path(resource.project, resource)
+        end
+        let(:edit_resource_path) do
+          edit_project_match_path(resource.project, resource)
+        end
+
+        it_should_behave_like '#create'
+      end
+    end
+  end
+end

data/spec/controllers/dune/balanced/bankaccount/routing_numbers_controller_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+module Dune::Balanced::Bankaccount
+  describe RoutingNumbersController do
+    routes { Dune::Balanced::Bankaccount::Engine.routes }
+
+    describe '#show' do
+      context 'when routing number is incorrect' do
+        before { get :show, id: 123 }
+        it { expect(response.status).to eq 200 }
+        it { expect(response.body).to eq({ ok: false, bank_name: nil }.to_json) }
+      end
+
+      context 'when routing number is correct' do
+        let(:routing_number) { RoutingNumber.create! number: 123456, bank_name: 'Bank of America' }
+        before { get :show, id: routing_number.number }
+        it { expect(response.status).to eq 200 }
+        it { expect(response.body).to eq({ ok: true, bank_name: 'Bank of America' }.to_json) }
+      end
+    end
+  end
+end

data/spec/factories.rb

@@ -0,0 +1,47 @@
+FactoryGirl.define do
+  factory :category do
+    name_pt { "category-#{rand}" }
+  end
+
+  factory :contribution do
+    confirmed_at { Time.now }
+    credits      false
+    value        10
+    state        :confirmed
+    association :project, factory: :online_project
+    user
+  end
+
+  factory :match do |f|
+    finishes_at { project.expires_at }
+    starts_at   { Time.now.utc.to_date }
+    state       :confirmed
+    value       1_500
+    value_unit  2
+    association :project, factory: :online_project
+    user
+  end
+
+  factory :project do
+    about    'a-big-text-about-the-project'
+    goal     10_000
+    headline 'attractive-headline'
+    location 'New York, NY'
+    name     'a-project'
+    user
+    category
+
+    factory :online_project do
+      online_date { Time.now }
+      online_days 30
+      state       'online'
+    end
+  end
+
+  factory :user do
+    name         'Joãozinho'
+    password     'right-password'
+    email        { "person#{rand}@example.com" }
+    confirmed_at { Time.now }
+  end
+end

data/spec/lib/dune/balanced/bankaccount/interface_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Dune::Balanced::Bankaccount::Interface do
+
+  it 'should return the engine name' do
+    expect(subject.name).to eq 'balanced-bankaccount'
+  end
+
+  it 'should return account path' do
+    expect(subject.account_path).to eq Dune::Balanced::Bankaccount::Engine.
+        routes.url_helpers.new_account_path
+  end
+
+  it 'should return an instance of TransactionAdditionalFeeCalculator' do
+    expect(subject.fee_calculator(10)).to be_an_instance_of(Dune::Balanced::Bankaccount::TransactionAdditionalFeeCalculator)
+  end
+
+  describe '#payment_path' do
+    context 'when resource is a Contribution' do
+      let(:resource) { Contribution.new(id: 42) }
+
+      it 'should return payment path' do
+        expect(subject.payment_path(resource)).to eq Dune::Balanced::Bankaccount::Engine.
+            routes.url_helpers.new_payment_path(contribution_id: resource)
+      end
+    end
+
+    context 'when resource is a Match' do
+      let(:resource) { Match.new(id: 42) }
+
+      it 'should return payment path' do
+        expect(subject.payment_path(resource)).to eq Dune::Balanced::Bankaccount::Engine.
+            routes.url_helpers.new_payment_path(match_id: resource)
+      end
+    end
+  end
+end

data/spec/models/dune/balanced/bankaccount/delayed_payment_processing_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe Dune::Balanced::Bankaccount::DelayedPaymentProcessing do
+  let(:contributor) { double('Contributor', href: '/MYID') }
+  let(:customer)    { double('Customer') }
+  subject { described_class.new(contributor, contributions) }
+  before do
+    ::Balanced::Customer.stub(:find).and_return(customer)
+  end
+
+  describe 'completion' do
+    let(:contribution_1) { double('Contribution') }
+    let(:contribution_2) { contribution_1.dup }
+    let(:contributions)  { [contribution_1, contribution_2] }
+
+    it 'generates a Payment for each contribution' do
+      expect(
+        Dune::Balanced::Bankaccount::Payment
+      ).to receive(:new).with(anything, anything, contribution_1, anything).
+                         and_return(double.as_null_object)
+      expect(
+        Dune::Balanced::Bankaccount::Payment
+      ).to receive(:new).with(anything, anything, contribution_2, anything).
+                         and_return(double.as_null_object)
+      subject.complete
+    end
+
+    it 'checkouts a Payment for each contribution' do
+      payment = double('Dune::Balanced::Bankaccount::Payment').as_null_object
+      Dune::Balanced::Bankaccount::Payment.
+        stub(:new).
+        and_return(payment)
+
+      expect(payment).to receive(:checkout!).twice
+      subject.complete
+    end
+  end
+end

data/spec/models/dune/balanced/bankaccount/delayed_payment_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+describe Dune::Balanced::Bankaccount::DelayedPayment do
+  let(:customer)     { double('::Balanced::Customer') }
+  let(:contribution) { double('Contribution', value: 1234).as_null_object }
+  let(:bank_account) { double('::Balanced::BankAccount', href: '/ABANK') }
+  let(:attributes)   { { pay_fee: '1', use_bank: bank_account.href } }
+  subject do
+    described_class.new('balanced-bankaccount',
+                        customer,
+                        contribution,
+                        attributes)
+  end
+
+  describe 'checkout' do
+    it 'authorizes payment of contribution' do
+      expect(contribution).to receive(:wait_confirmation!)
+      subject.checkout!
+    end
+
+    it 'defines given engine\'s name as payment method of the contribution' do
+      contribution.should_receive(:update_attributes).
+                   with(hash_including(payment_method: 'balanced-bankaccount'))
+      subject.checkout!
+    end
+
+    it 'saves paid fees on contribution object' do
+      calculator = double('FeeCalculator', fees: 0.42).as_null_object
+      subject.stub(:fee_calculator).and_return(calculator)
+      contribution.should_receive(:update_attributes).
+                   with(hash_including(payment_service_fee: 0.42))
+      subject.checkout!
+    end
+
+    it 'saves who paid the fees' do
+      calculator = double('FeeCalculator', fees: 0.42).as_null_object
+      subject.stub(:fee_calculator).and_return(calculator)
+      contribution.should_receive(:update_attributes).
+                   with(hash_including(payment_service_fee_paid_by_user: '1'))
+      subject.checkout!
+    end
+  end
+
+  describe 'status' do
+    context 'after checkout' do
+      before do
+        subject.checkout!
+      end
+
+      it 'is succeeded' do
+        expect(subject.status).to eql(:succeeded)
+        expect(subject).to        be_successful
+      end
+    end
+
+    context 'before checkout' do
+      it 'is nil' do
+        expect(subject.status).to be_nil
+      end
+
+      it 'is not succeeded' do
+        expect(subject).to_not be_successful
+      end
+    end
+  end
+end

data/spec/models/dune/balanced/bankaccount/payment_generator_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+describe Dune::Balanced::Bankaccount::PaymentGenerator do
+  let(:customer)     { double('::Balanced::Customer') }
+  let(:contribution) { double('Contribution', value: 1234).as_null_object }
+  let(:attrs)        { { use_bank: '/ABANK' } }
+  let(:bank_account) { double('::Balanced::BankAccount', bank_account_verifications: []) }
+  subject { described_class.new(customer, contribution, attrs) }
+
+  before do
+    ::Balanced::BankAccount.stub(:find).and_return(bank_account)
+  end
+
+  describe 'ability to debit resource' do
+    before do
+      bank_account.stub(:bank_account_verifications).and_return(verifications)
+    end
+
+    context 'with confirmed verification' do
+      let(:verifications) do
+        [double('::Balanced::BankAccountVerification', verification_status: 'succeeded')]
+      end
+
+      it 'is able to debit resource' do
+        expect(subject.can_debit_resource?).to be_truthy
+      end
+    end
+
+    context 'with verification started' do
+      let(:verifications) do
+        [double('::Balanced::BankAccountVerification', state: 'deposit_succeeded')]
+      end
+
+      it 'isn\'t able to debit resource' do
+        expect(subject.can_debit_resource?).to be_falsey
+      end
+    end
+
+    context 'without verifications' do
+      let(:verifications) { [] }
+
+      it 'isn\'t able to debit resource' do
+        expect(subject.can_debit_resource?).to be_falsey
+      end
+    end
+  end
+
+  describe 'completion' do
+    it 'checkouts using Payment class when is able to debit resource' do
+      subject.stub(:can_debit_resource?).and_return(true)
+      expect_any_instance_of(
+        Dune::Balanced::Bankaccount::Payment
+      ).to receive(:checkout!)
+      subject.complete
+    end
+
+    it 'checkouts using DelayedPayment when is not able to debit resource' do
+      subject.stub(:can_debit_resource?).and_return(false)
+      expect_any_instance_of(
+        Dune::Balanced::Bankaccount::DelayedPayment
+      ).to receive(:checkout!)
+      subject.complete
+    end
+  end
+end

data/spec/models/dune/balanced/bankaccount/payment_spec.rb

@@ -0,0 +1,252 @@
+require 'spec_helper'
+
+describe Dune::Balanced::Bankaccount::Payment do
+  shared_examples_for 'payable' do
+    let(:customer)     { double('::Balanced::Customer', href: '/CUSTOMER-ID') }
+    let(:debit)        { double('::Balanced::Debit').as_null_object }
+    let(:bank_account) { double('::Balanced::BankAccount', href: '/ABANK') }
+    let(:attributes)   { { use_bank: bank_account.href } }
+    subject do
+      described_class.new('balanced-bankaccount',
+                          customer,
+                          resource,
+                          attributes)
+    end
+    before do
+      Balanced::BankAccount.stub(:find).with(bank_account.href).
+        and_return(bank_account)
+      subject.stub_chain(:contributor, :projects).and_return([])
+
+      User.any_instance.stub(:balanced_contributor).and_return(
+        double('BalancedContributor', href: 'project-owner-href')
+      )
+
+      allow_any_instance_of(Dune::Balanced::OrderProxy).to receive(:debit_from).and_return(debit)
+      resource.stub(:value).and_return(1234)
+      described_class.any_instance.stub(:meta).and_return({})
+    end
+
+    describe '#amount_in_cents' do
+      context 'when customer is paying fees' do
+        let(:attributes) { { pay_fee: '1', use_bank: bank_account.href } }
+
+        it 'returns gross amount from TransactionAdditionalFeeCalculator' do
+          Dune::Balanced::Bankaccount::TransactionAdditionalFeeCalculator.
+            any_instance.stub(:gross_amount).and_return(15)
+          expect(subject.amount_in_cents).to eql(1500)
+        end
+      end
+
+      context 'when customer is not paying fees' do
+        let(:attributes) { { pay_fee: '0', use_bank: bank_account.href } }
+
+        it 'returns gross amount from TransactionInclusiveFeeCalculator' do
+          Dune::Balanced::Bankaccount::TransactionInclusiveFeeCalculator.
+            any_instance.stub(:gross_amount).and_return(10)
+          expect(subject.amount_in_cents).to eql(1000)
+        end
+      end
+    end
+
+    describe 'checkout' do
+      shared_examples 'updates resource object' do
+        let(:attributes)  { { pay_fee: '1', use_bank: bank_account.href } }
+
+        context 'when a use_bank is provided' do
+          before do
+            allow(Balanced::BankAccount).to receive(:find).
+              with(bank_account.href).and_return(bank_account)
+          end
+
+          it 'debits customer on selected funding instrument' do
+            expect_any_instance_of(
+              Dune::Balanced::OrderProxy
+            ).to receive(:debit_from).with(hash_including(source: bank_account)).
+              and_return(debit)
+            subject.checkout!
+          end
+        end
+
+        context 'when no use_bank is provided' do
+          let(:contributor) do
+            double('Dune::Balanced::Contributor',
+              bank_account_href: '/MY-DEFAULT-BANK',
+              projects:         []
+            )
+          end
+          let(:attributes) { { pay_fee: '1' } }
+          before do
+            subject.stub(:contributor).and_return(contributor)
+            allow(Balanced::BankAccount).to receive(:find).
+              with(contributor.bank_account_href).and_return(bank_account)
+          end
+
+          it 'debits customer on default funding instrument' do
+            expect_any_instance_of(
+              Dune::Balanced::OrderProxy
+            ).to receive(:debit_from).with(hash_including(source: bank_account)).
+              and_return(debit)
+            subject.checkout!
+          end
+        end
+
+        it 'defines given engine\'s name as payment method of the resource' do
+          resource.should_receive(:update_attributes).
+                       with(hash_including(payment_method: 'balanced-bankaccount'))
+          subject.checkout!
+        end
+
+        it 'saves paid fees on resource object' do
+          calculator = double('FeeCalculator', fees: 0.42).as_null_object
+          subject.stub(:fee_calculator).and_return(calculator)
+          resource.should_receive(:update_attributes).
+                       with(hash_including(payment_service_fee: 0.42))
+          subject.checkout!
+        end
+
+        it 'saves who paid the fees' do
+          calculator = double('FeeCalculator', fees: 0.42).as_null_object
+          subject.stub(:fee_calculator).and_return(calculator)
+          resource.should_receive(:update_attributes).
+                       with(hash_including(payment_service_fee_paid_by_user: '1'))
+          subject.checkout!
+        end
+      end
+
+      context 'with successful debit' do
+        before do
+          allow_any_instance_of(
+            Dune::Balanced::OrderProxy
+          ).to receive(:debit_from).and_return(debit)
+        end
+
+        include_examples 'updates resource object'
+
+        it 'confirms the resource' do
+          expect(resource).to receive(:confirm)
+          subject.checkout!
+        end
+
+        it 'defines appears_on_statement_as on debit' do
+          ::Configuration.stub(:[]).with(:balanced_appears_on_statement_as).
+            and_return('www.dune-investissement.fr')
+
+          expect_any_instance_of(
+            Dune::Balanced::OrderProxy
+          ).to receive(:debit_from).with(hash_including(appears_on_statement_as: 'dune-investissement')).
+            and_return(debit)
+          subject.checkout!
+        end
+
+        it 'defines id as payment id of the resource' do
+          debit.stub(:id).and_return('i-am-an-id!')
+          resource.should_receive(:update_attributes).
+                       with(hash_including(payment_id: 'i-am-an-id!'))
+          subject.checkout!
+        end
+
+        it 'defines meta on debit' do
+          described_class.any_instance.stub(:meta).and_return({ payment_service_fee: 5.0 })
+          expect_any_instance_of(
+            Dune::Balanced::OrderProxy
+          ).to receive(:debit_from).with(hash_including(meta: { payment_service_fee: 5.0 })).
+            and_return(debit)
+          subject.checkout!
+        end
+      end
+
+      context 'when raising Balanced::BadRequest exception' do
+        before do
+          allow_any_instance_of(
+            Dune::Balanced::OrderProxy
+          ).to receive(:debit_from).
+            and_raise(Balanced::BadRequest.new({}))
+        end
+
+        include_examples 'updates resource object'
+
+        it 'cancels the resource' do
+          expect(resource).to receive(:cancel)
+          subject.checkout!
+        end
+      end
+
+      context 'when a description is provided to debit' do
+        it 'defines description on debit' do
+          Project.any_instance.stub(:name).and_return('Awesome Project')
+          expect_any_instance_of(
+            Dune::Balanced::OrderProxy
+          ).to receive(:debit_from).with(hash_including(description: debit_description)).
+            and_return(debit)
+          subject.checkout!
+        end
+      end
+    end
+
+    describe 'status' do
+      context 'after checkout' do
+        before do
+          subject.checkout!
+        end
+
+        it 'returns the debit status symbolized' do
+          debit.stub(:status).and_return('my_status')
+          expect(subject.status).to eql(:my_status)
+        end
+      end
+
+      context 'before checkout' do
+        it 'is nil' do
+          expect(subject.status).to be_nil
+        end
+      end
+    end
+
+    describe 'successful state' do
+      before do
+        allow_any_instance_of(
+          Dune::Balanced::OrderProxy
+        ).to receive(:debit_from).and_return(debit)
+      end
+
+      context 'after checkout' do
+        before { subject.checkout! }
+
+        it 'is successfull when the debit has \'succeeded\' status' do
+          debit.stub(:status).and_return('succeeded')
+          expect(subject).to be_successful
+        end
+
+        it 'is successfull when the debit has \'pending\' status' do
+          debit.stub(:status).and_return('pending')
+          expect(subject).to be_successful
+        end
+
+        it 'is not successfull when the debit has others statuses' do
+          debit.stub(:status).and_return('failed')
+          expect(subject).to_not be_successful
+        end
+      end
+
+      context 'before checkout' do
+        it 'is not successfull' do
+          expect(subject).to_not be_successful
+        end
+      end
+    end
+  end
+
+  context 'when resource is Contribution' do
+    let(:resource)          { FactoryGirl.create(:contribution) }
+    let(:debit_description) { 'Contribution to Awesome Project' }
+
+    it_should_behave_like 'payable'
+  end
+
+  context 'when resource is Match' do
+    let(:resource)          { FactoryGirl.create(:match) }
+    let(:debit_description) { 'Match for Awesome Project' }
+
+    it_should_behave_like 'payable'
+  end
+end