solidus_afterpay 0.2.0 → 0.3.0

data/spec/requests/solidus_afterpay/checkouts_controller_spec.rb

@@ -1,258 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe SolidusAfterpay::CheckoutsController, type: :request do
-  describe 'POST create' do
-    subject(:request) { post '/solidus_afterpay/checkouts.json', params: params, headers: headers }
-
-    let(:order) { create(:order_with_totals, state: 'payment', user: user) }
-    let(:payment_method) { create(:afterpay_payment_method) }
-    let(:user) { create(:user, :with_api_key) }
-
-    let(:order_number) { order.number }
-    let(:payment_method_id) { payment_method.id }
-
-    let(:params) { { order_number: order_number, payment_method_id: payment_method_id } }
-
-    let(:order_token) { 'ORDER_TOKEN' }
-    let(:gateway_response_success?) { true }
-    let(:gateway_response_message) { 'Success message' }
-    let(:gateway_response_error_code) { nil }
-    let(:gateway_response_params) { { 'token' => order_token } }
-    let(:headers) { {} }
-
-    let(:gateway_response) do
-      ActiveMerchant::Billing::Response.new(
-        gateway_response_success?,
-        gateway_response_message,
-        gateway_response_params,
-        { error_code: gateway_response_error_code }
-      )
-    end
-
-    let(:gateway) { instance_double(SolidusAfterpay::Gateway, create_checkout: gateway_response) }
-
-    before do
-      allow(SolidusAfterpay::Gateway).to receive(:new).and_return(gateway)
-    end
-
-    context 'when the use solidus api config is set to false' do
-      context 'when the user is logged in', with_signed_in_user: true do
-        context 'with valid data' do
-          before do
-            allow(Spree::Order).to receive(:find_by!).with(number: order.number).and_return(order)
-            request
-          end
-
-          it 'returns a 201 status code' do
-            expect(response).to have_http_status(:created)
-          end
-
-          it 'returns the order_token' do
-            expect(JSON.parse(response.body)['token']).to eq(order_token)
-          end
-
-          it 'returns the correct params' do
-            expect(JSON.parse(response.body)).to include('token', 'expires', 'redirectCheckoutUrl')
-          end
-
-          context 'when no redirect URLs are passed as params' do
-            let(:redirect_confirm_url) do
-              "http://www.example.com/solidus_afterpay/callbacks/confirm?order_number=#{order.number}&payment_method_id=#{payment_method.id}"
-            end
-
-            let(:redirect_cancel_url) do
-              "http://www.example.com/solidus_afterpay/callbacks/cancel?order_number=#{order.number}&payment_method_id=#{payment_method.id}"
-            end
-
-            it 'calls the create_checkout with the correct arguments' do
-              expect(gateway).to have_received(:create_checkout).with(
-                order,
-                redirect_confirm_url: redirect_confirm_url,
-                redirect_cancel_url: redirect_cancel_url,
-                mode: nil,
-                popup_origin_url: nil
-              )
-            end
-          end
-
-          context 'when redirect URLs are passed as params' do
-            let(:redirect_confirm_url) { 'http://www.example.com/confirm_url' }
-            let(:redirect_cancel_url) { 'http://www.example.com/cancel_url' }
-
-            let(:params) do
-              {
-                order_number: order_number,
-                payment_method_id: payment_method_id,
-                redirect_confirm_url: redirect_confirm_url,
-                redirect_cancel_url: redirect_cancel_url
-              }
-            end
-
-            it 'calls the create_checkout with the correct arguments' do
-              expect(gateway).to have_received(:create_checkout).with(
-                order,
-                redirect_confirm_url: redirect_confirm_url,
-                redirect_cancel_url: redirect_cancel_url,
-                mode: nil,
-                popup_origin_url: nil
-              )
-            end
-          end
-
-          context 'when the mode is passed as params' do
-            let(:params) do
-              {
-                order_number: order_number,
-                payment_method_id: payment_method_id,
-                mode: 'express'
-              }
-            end
-
-            let(:redirect_confirm_url) do
-              "http://www.example.com/solidus_afterpay/callbacks/confirm?order_number=#{order.number}&payment_method_id=#{payment_method.id}"
-            end
-
-            let(:redirect_cancel_url) do
-              "http://www.example.com/solidus_afterpay/callbacks/cancel?order_number=#{order.number}&payment_method_id=#{payment_method.id}"
-            end
-
-            it 'calls the create_checkout with the correct arguments' do
-              expect(gateway).to have_received(:create_checkout).with(
-                order,
-                redirect_confirm_url: redirect_confirm_url,
-                redirect_cancel_url: redirect_cancel_url,
-                popup_origin_url: nil,
-                mode: 'express'
-              )
-            end
-          end
-        end
-
-        context 'when the order_number is invalid' do
-          let(:order_number) { 'INVALID_ORDER_NUMBER' }
-
-          before { request }
-
-          it 'returns a 404 status code' do
-            expect(response).to have_http_status(:not_found)
-          end
-
-          it 'returns a resource not found error message' do
-            expect(JSON.parse(response.body)['error']).to eq('The resource you were looking for could not be found.')
-          end
-        end
-
-        context 'when the payment_method_id is invalid' do
-          let(:payment_method_id) { 0 }
-
-          before { request }
-
-          it 'returns a 404 status code' do
-            expect(response).to have_http_status(:not_found)
-          end
-
-          it 'returns a resource not found error message' do
-            expect(JSON.parse(response.body)['error']).to eq('The resource you were looking for could not be found.')
-          end
-        end
-
-        context 'when the payment_method_id is not passed as param' do
-          let(:redirect_confirm_url) do
-            "http://www.example.com/solidus_afterpay/callbacks/confirm?order_number=#{order.number}&payment_method_id=#{payment_method.id}"
-          end
-
-          let(:redirect_cancel_url) do
-            "http://www.example.com/solidus_afterpay/callbacks/cancel?order_number=#{order.number}&payment_method_id=#{payment_method.id}"
-          end
-
-          let(:params) do
-            {
-              order_number: order_number,
-              mode: 'express'
-            }
-          end
-
-          before do
-            payment_method
-            request
-          end
-
-          it 'uses the first solidus afterpay payment method' do
-            expect(gateway).to have_received(:create_checkout).with(
-              order,
-              redirect_confirm_url: redirect_confirm_url,
-              redirect_cancel_url: redirect_cancel_url,
-              popup_origin_url: nil,
-              mode: 'express'
-            )
-          end
-        end
-
-        context 'when the gateway responds with error' do
-          let(:gateway_response_success?) { false }
-          let(:gateway_response_message) { 'Error message' }
-          let(:gateway_response_error_code) { 'errorCode' }
-
-          before { request }
-
-          it 'returns a 422 status code' do
-            expect(response).to have_http_status(:unprocessable_entity)
-          end
-
-          it 'returns a resource not found error message' do
-            expect(JSON.parse(response.body)['error']).to eq(gateway_response_message)
-          end
-
-          it 'returns the error_code' do
-            expect(JSON.parse(response.body)['errorCode']).to eq(gateway_response_error_code)
-          end
-        end
-      end
-
-      context 'when the user is a guest user', with_guest_session: true do
-        it 'returns a 201 status code' do
-          request
-          expect(response).to have_http_status(:created)
-        end
-      end
-
-      context 'when the user is not logged in' do
-        it 'returns a 401 status code' do
-          request
-          expect(response).to have_http_status(:unauthorized)
-        end
-      end
-    end
-
-    context 'when the use solidus api config is set to true', use_solidus_api: true do
-      context 'when the user is logged in' do
-        let(:headers) { { Authorization: "Bearer #{user.spree_api_key}" } }
-
-        it 'returns a 201 status code' do
-          request
-          expect(response).to have_http_status(:created)
-        end
-      end
-
-      context 'when the user is a guest user' do
-        let(:headers) { { 'X-Spree-Order-Token': order.guest_token } }
-
-        it 'returns a 201 status code' do
-          request
-          expect(response).to have_http_status(:created)
-        end
-      end
-
-      context 'when the user is not logged in' do
-        let(:headers) { { Authorization: 'Bearer 1234' } }
-
-        it 'returns a 401 status code' do
-          request
-          expect(response).to have_http_status(:unauthorized)
-        end
-      end
-    end
-  end
-end

data/spec/requests/solidus_afterpay/express_callbacks_controller_spec.rb

@@ -1,167 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe SolidusAfterpay::ExpressCallbacksController, type: :request do
-  describe 'PATCH update' do
-    subject(:request) { patch "/solidus_afterpay/express_callbacks/#{order.number}.json", params: params }
-
-    let(:user) { create(:user) }
-    let(:order) { create(:order_with_line_items, state: 'address', line_items_count: 2, user: user) }
-
-    let(:params) do
-      {
-        address: {
-          name: 'John Doe',
-          address1: '8125 Centre St',
-          address2: '',
-          suburb: 'Citronelle',
-          postcode: '36522-2156',
-          phoneNumber: '1234567',
-          countryCode: 'US',
-          state: 'AL'
-        }
-      }
-    end
-
-    context 'when the user is not authorized' do
-      it 'returns 401 status code' do
-        request
-        expect(response).to have_http_status(:unauthorized)
-      end
-    end
-
-    context 'when the user is a guest user', with_guest_session: true do
-      it 'returns 200 status code' do
-        request
-        expect(response).to have_http_status(:ok)
-      end
-    end
-
-    context 'when the user is logged in', with_signed_in_user: true do
-      let(:update_order_address_service_result) { true }
-
-      before do
-        allow(SolidusAfterpay::UpdateOrderAddressesService)
-          .to receive(:call)
-          .and_return(update_order_address_service_result)
-
-        allow(SolidusAfterpay.shipping_rate_builder_service_class)
-          .to receive(:call)
-      end
-
-      it 'returns 200 status code' do
-        request
-        expect(response).to have_http_status(:ok)
-      end
-
-      it 'calls the update order addresses service' do
-        request
-        expect(SolidusAfterpay::UpdateOrderAddressesService)
-          .to have_received(:call)
-          .with(order: order, address_params: ActionController::Parameters.new(params[:address]))
-      end
-
-      it 'changes the order status' do
-        expect { request }.to change { order.reload.state }.from('address').to('delivery')
-      end
-
-      it 'changes the order email if it has a dummy email' do
-        order.update!(email: SolidusAfterpay.configuration.dummy_email)
-        expect { request }.to change { order.reload.email }.from(SolidusAfterpay.configuration.dummy_email).to(nil)
-      end
-
-      it 'calls the shipping rate builder service class' do
-        request
-        expect(SolidusAfterpay.shipping_rate_builder_service_class)
-          .to have_received(:call)
-          .with(order: order)
-      end
-
-      context 'when the update order addresses service returns false' do
-        let(:update_order_address_service_result) { false }
-
-        it 'retuns an internal server error' do
-          request
-          expect(response).to have_http_status(:internal_server_error)
-        end
-      end
-    end
-  end
-
-  describe 'POST create' do
-    subject(:request) { post "/solidus_afterpay/express_callbacks/#{order.number}.json", params: params }
-
-    let(:user) { create(:user) }
-    let(:order) { create(:order_with_line_items, state: 'delivery', line_items_count: 2, user: user) }
-    let(:payment_method) { create(:afterpay_payment_method) }
-
-    let(:order_token) { 'TOKEN' }
-    let(:update_order_attributes_service_result) { true }
-
-    let(:params) do
-      {
-        token: order_token,
-        order_number: order.number,
-        payment_method_id: payment_method.id,
-      }
-    end
-
-    before do
-      allow(SolidusAfterpay.update_order_attributes_service_class)
-        .to receive(:call)
-        .and_return(update_order_attributes_service_result)
-    end
-
-    context 'when the user is not authorized' do
-      it 'returns 401 status code' do
-        request
-        expect(response).to have_http_status(:unauthorized)
-      end
-    end
-
-    context 'when the user is a guest user', with_guest_session: true do
-      it 'returns 200 status code' do
-        request
-        expect(response).to have_http_status(:ok)
-      end
-    end
-
-    context 'when the user is logged in', with_signed_in_user: true do
-      it 'returns 200 status code' do
-        request
-        expect(response).to have_http_status(:ok)
-      end
-
-      it 'calls the update order attributes service class' do
-        request
-        expect(SolidusAfterpay.update_order_attributes_service_class)
-          .to have_received(:call)
-          .with(
-            order: order,
-            afterpay_order_token: order_token,
-            payment_method: payment_method,
-            request_env: an_instance_of(Hash)
-          )
-      end
-
-      it 'changes the order state to confirm' do
-        expect { request }.to change { order.reload.state }.from('delivery').to('confirm')
-      end
-
-      it 'redirects the user to the checkout confirm step' do
-        request
-        expect(JSON.parse(response.body)['redirect_url']).to eq('http://www.example.com/checkout/confirm')
-      end
-
-      context 'when the update order attributes service fails' do
-        let(:update_order_attributes_service_result) { false }
-
-        it 'returns 500 status code' do
-          request
-          expect(response).to have_http_status(:internal_server_error)
-        end
-      end
-    end
-  end
-end

data/spec/services/solidus_afterpay/base_service_spec.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe SolidusAfterpay::BaseService do
-  describe '#call' do
-    subject(:service) { described_class.new.call }
-
-    it 'raises a not implemented error' do
-      expect { service }.to raise_error(::NotImplementedError)
-    end
-  end
-end

data/spec/services/solidus_afterpay/shipping_rate_builder_service_spec.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe SolidusAfterpay::ShippingRateBuilderService do
-  subject(:service) { described_class.call(order: order) }
-
-  let(:order) { ::Spree::TestingSupport::OrderWalkthrough.up_to(:delivery) }
-
-  context 'when the order is in a valid state' do
-    it 'returns the afterpay compliant shipping rate object' do
-      expect(service).to eq(
-        [
-          {
-            id: order.reload.shipments.first.shipping_rates.first.id.to_s,
-            name: 'UPS Ground',
-            description: '$10.00',
-            shipping_amount: '10.0',
-            currency: 'USD',
-            order_amount: '20.0'
-          }
-        ]
-      )
-    end
-  end
-
-  context 'when the order is not in a valid state' do
-    before { order.shipments = [] }
-
-    it 'returns an empty array' do
-      expect(service).to be_empty
-    end
-  end
-end

data/spec/services/solidus_afterpay/update_order_addresses_service_spec.rb

@@ -1,82 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe SolidusAfterpay::UpdateOrderAddressesService do
-  subject(:service) { described_class.call(order: order, address_params: address_params) }
-
-  let(:order) { create(:order, state: 'payment', ship_address: nil, bill_address: nil) }
-
-  before do
-    country = create(:country)
-    create(:state, country: country)
-  end
-
-  context 'when the address params are valid' do
-    let(:address_params) do
-      {
-        address1: '8125 Centre St',
-        address2: '',
-        name: 'John Doe',
-        suburb: 'Citronelle',
-        postcode: '36522-2156',
-        phoneNumber: '12345',
-        countryCode: 'US',
-        state: 'AL'
-      }
-    end
-
-    it 'returns true' do
-      expect(service).to be_truthy
-    end
-
-    it 'changes the order state to address' do
-      expect { service }.to change { order.reload.state }.from('payment').to('address')
-    end
-
-    context 'when the order has an email set' do
-      it 'does not change the order email' do
-        expect { service }.not_to(change { order.reload.email })
-      end
-    end
-
-    context 'when the order does not have an email set' do
-      # rubocop:disable Rails/SkipsModelValidations
-      before { order.update_columns(email: nil) }
-      # rubocop:enable Rails/SkipsModelValidations
-
-      it 'changes the order email with a dummy one' do
-        expect { service }
-          .to change { order.reload.email }
-          .to(SolidusAfterpay.configuration.dummy_email)
-      end
-    end
-  end
-
-  context 'when the address params are not valid' do
-    let(:address_params) do
-      {
-        address1: '',
-        address2: '',
-        name: 'John Doe',
-        suburb: '',
-        postcode: '36522-2156',
-        phoneNumber: '12345',
-        countryCode: 'US',
-        state: 'AL'
-      }
-    end
-
-    it 'returns false' do
-      expect(service).to be_falsey
-    end
-
-    it 'changes the order state to address' do
-      expect { service }.not_to(change { order.reload.state })
-    end
-
-    it 'does not change the order email' do
-      expect { service }.not_to(change { order.reload.email })
-    end
-  end
-end

data/spec/services/solidus_afterpay/update_order_attributes_service_spec.rb

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe SolidusAfterpay::UpdateOrderAttributesService do
-  subject(:service) do
-    described_class.call(
-      order: order,
-      afterpay_order_token: afterpay_order_token,
-      payment_method: payment_method,
-      request_env: 'env'
-    )
-  end
-
-  let!(:order) { create(:order_with_line_items, line_items_count: 2, state: 'delivery') }
-  let!(:payment_method) { create(:afterpay_payment_method) }
-
-  before do
-    allow(Spree::ShippingRate).to receive(:find).and_return(Spree::ShippingRate.first)
-    allow(order).to receive(:available_payment_methods).and_return(Spree::PaymentMethod.all)
-  end
-
-  context 'when the afterpay find order is a success', vcr: 'find_order/valid' do
-    let(:afterpay_order_token) { '002.cb9qevbs1o4el3adh817hqkotkbv4b8u1jkekofd3nb2m8lu' }
-
-    it 'returns true' do
-      expect(service).to be_truthy
-    end
-
-    it 'updates the order email with the Afterpay order email' do
-      expect { service }.to change { order.reload.email }.to('andreavassallo@nebulab.com')
-    end
-
-    # rubocop:disable RSpec/MultipleExpectations
-    it 'updates the payments information with the afterpay payment information' do
-      expect { service }.to change { order.payments.reload.count }.from(0).to(1)
-      expect(order.payments.first.amount).to eq(53.53)
-      expect(order.payments.first.source.token).to eq(afterpay_order_token)
-    end
-    # rubocop:enable RSpec/MultipleExpectations
-  end
-
-  context 'when the afterpay find order is a failure', vcr: 'find_order/invalid' do
-    let(:afterpay_order_token) { 'INVALID_TOKEN' }
-
-    it 'returns false' do
-      expect(service).to be_falsey
-    end
-
-    it 'does not change the order email' do
-      expect { service }.not_to(change { order.reload.email })
-    end
-
-    it 'does not change the payments count' do
-      expect { service }.not_to(change { order.payments.reload.count })
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-# Configure Rails Environment
-ENV['RAILS_ENV'] = 'test'
-
-# Run Coverage report
-require 'solidus_dev_support/rspec/coverage'
-
-# Create the dummy app if it's still missing.
-dummy_env = "#{__dir__}/dummy/config/environment.rb"
-system 'bin/rake extension:test_app' unless File.exist? dummy_env
-require dummy_env
-
-# Requires factories and other useful helpers defined in spree_core.
-require 'solidus_dev_support/rspec/feature_helper'
-
-# Requires supporting ruby files with custom matchers and macros, etc,
-# in spec/support/ and its subdirectories.
-Dir["#{__dir__}/support/**/*.rb"].sort.each { |f| require f }
-
-# Requires factories defined in lib/solidus_afterpay/testing_support/factories.rb
-SolidusDevSupport::TestingSupport::Factories.load_for(SolidusAfterpay::Engine)
-
-RSpec.configure do |config|
-  config.infer_spec_type_from_file_location!
-  config.use_transactional_fixtures = false
-
-  if Spree.solidus_gem_version < Gem::Version.new('2.11')
-    config.extend Spree::TestingSupport::AuthorizationHelpers::Request, type: :system
-  end
-end

data/spec/support/auth.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.configure do |config|
-  config.include Devise::Test::IntegrationHelpers, type: :request
-
-  config.before(:each, with_signed_in_user: true) { login_as user }
-
-  config.before(:each, with_guest_session: true) do
-    # rubocop:disable RSpec/AnyInstance
-    allow_any_instance_of(ActionDispatch::Cookies::CookieJar).to(
-      receive(:signed).and_return({ guest_token: order.guest_token })
-    )
-    # rubocop:enable RSpec/AnyInstance
-  end
-end

data/spec/support/cache.rb

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.configure do |config|
-  config.after { Rails.cache.clear }
-end