solidus_afterpay 0.1.0 → 0.3.0

data/spec/models/solidus_afterpay/payment_source_spec.rb

@@ -1,61 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe SolidusAfterpay::PaymentSource, type: :model do
-  let(:payment_source) { described_class.new }
-
-  describe '#actions' do
-    subject { payment_source.actions }
-
-    it 'supports capture, void, and credit' do
-      is_expected.to eq(%w[capture void credit])
-    end
-  end
-
-  describe '#can_void?' do
-    subject { payment_source.can_void?(payment) }
-
-    let(:deferred?) { false }
-    let(:payment_method) { build(:afterpay_payment_method, preferred_deferred: deferred?) }
-    let(:payment) { build(:afterpay_payment, payment_method: payment_method) }
-
-    context 'with the immediate flow' do
-      it 'is always false' do
-        is_expected.to be(false)
-      end
-    end
-
-    context 'with the deferred flow' do
-      let(:deferred?) { true }
-
-      let(:payment_state) { 'AUTH_APPROVED' }
-      let(:gateway_response) { { paymentState: payment_state } }
-      let(:gateway) { instance_double(SolidusAfterpay::Gateway, find_payment: gateway_response) }
-
-      before do
-        allow(payment_method).to receive(:gateway).and_return(gateway)
-      end
-
-      context 'when the payment exists and the payment state is voidable' do
-        it 'returns true' do
-          is_expected.to be(true)
-        end
-      end
-
-      context 'when the payment exists when the payment state is not voidable' do
-        let(:payment_state) { 'NOT_VOIDABLE' }
-
-        it 'returns false' do
-          is_expected.to be(false)
-        end
-      end
-
-      context "when the payment doesn't exist" do
-        let(:gateway_response) { nil }
-
-        it 'returns false' do
-          is_expected.to be(false)
-        end
-      end
-    end
-  end
-end

data/spec/models/solidus_afterpay/user_agent_generator_spec.rb

@@ -1,22 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe SolidusAfterpay::UserAgentGenerator do
-  describe '#generate' do
-    subject { user_agent_generator.generate }
-
-    let(:user_agent_generator) { described_class.new(merchant_id: merchant_id) }
-    let(:merchant_id) { 'MERCHANT_ID' }
-    let(:default_store) { build(:store, url: 'test.com') }
-
-    before do
-      stub_const('SolidusAfterpay::VERSION', '0.1.0')
-      allow(::Spree).to receive(:solidus_gem_version).and_return('3.0.1')
-      stub_const('RUBY_VERSION', '2.6.6')
-      allow(::Spree::Store).to receive(:default).and_return(default_store)
-    end
-
-    it 'includes the production javascript' do
-      is_expected.to eq('SolidusAfterpay/0.1.0 (Solidus/3.0.1; Ruby/2.6.6; Merchant/MERCHANT_ID) https://test.com')
-    end
-  end
-end

data/spec/models/spree/order_spec.rb

@@ -1,158 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe Spree::Order, type: :model do
-  let(:store) { create(:store) }
-  let(:user) { create(:user, email: "solidus@example.com") }
-  let(:order) { create(:order, user: user, store: store) }
-
-  describe "#available_payment_methods" do
-    it "includes frontend payment methods" do
-      payment_method = Spree::PaymentMethod::Check.create!({
-        name: "Fake",
-        active: true,
-        available_to_users: true,
-        available_to_admin: false
-      })
-      expect(order.available_payment_methods).to include(payment_method)
-    end
-
-    it "includes 'both' payment methods" do
-      payment_method = Spree::PaymentMethod::Check.create!({
-        name: "Fake",
-        active: true,
-        available_to_users: true,
-        available_to_admin: true
-      })
-      expect(order.available_payment_methods).to include(payment_method)
-    end
-
-    # rubocop:disable RSpec/MultipleExpectations
-    it "does not include a payment method twice" do
-      payment_method = Spree::PaymentMethod::Check.create!({
-        name: "Fake",
-        active: true,
-        available_to_users: true,
-        available_to_admin: true
-      })
-      expect(order.available_payment_methods.count).to eq(1)
-      expect(order.available_payment_methods).to include(payment_method)
-    end
-    # rubocop:enable RSpec/MultipleExpectations
-
-    it "does not include inactive payment methods" do
-      Spree::PaymentMethod::Check.create!({
-        name: "Fake",
-        active: false,
-        available_to_users: true,
-        available_to_admin: true
-      })
-      expect(order.available_payment_methods.count).to eq(0)
-    end
-
-    context "with more than one payment method" do
-      subject { order.available_payment_methods }
-
-      let!(:first_method) {
-        FactoryBot.create(:payment_method, available_to_users: true,
-                                               available_to_admin: true)
-      }
-      let!(:second_method) {
-        FactoryBot.create(:payment_method, available_to_users: true,
-                                               available_to_admin: true)
-      }
-
-      before do
-        second_method.move_to_top
-      end
-
-      it "respects the order of methods based on position" do
-        is_expected.to eq([second_method, first_method])
-      end
-
-      context 'when a payment method responds to #available_for_order?' do
-        let(:third_method) {
-          FakePaymentMethod.create(name: 'Fake', available_to_users: true, available_to_admin: true)
-        }
-
-        before do
-          fake_payment_method_class = Class.new(SolidusSupport.payment_method_parent_class)
-          stub_const('FakePaymentMethod', fake_payment_method_class)
-
-          third_method
-        end
-
-        context 'when it responds with true' do
-          before do
-            FakePaymentMethod.class_eval { def available_for_order?(_order); true; end }
-          end
-
-          it 'includes it in the result' do
-            is_expected.to eq([second_method, first_method, third_method])
-          end
-        end
-
-        context 'when it responds with false' do
-          before do
-            FakePaymentMethod.class_eval { def available_for_order?(_order); false; end }
-          end
-
-          it "doesn't include it in the result" do
-            is_expected.to eq([second_method, first_method])
-          end
-        end
-      end
-    end
-
-    context 'when the order has a store' do
-      let(:order) { create(:order) }
-
-      let!(:store_with_payment_methods) do
-        create(:store,
-          payment_methods: [payment_method_with_store])
-      end
-      let!(:payment_method_with_store) { create(:payment_method) }
-      let!(:store_without_payment_methods) { create(:store) }
-      let!(:payment_method_without_store) { create(:payment_method) }
-
-      context 'when the store has payment methods' do
-        before { order.update!(store: store_with_payment_methods) }
-
-        it 'returns only the matching payment methods for that store' do
-          expect(order.available_payment_methods).to match_array(
-            [payment_method_with_store]
-          )
-        end
-
-        context 'when the store has an extra payment method unavailable to users' do
-          let!(:admin_only_payment_method) do
-            create(:payment_method,
-              available_to_users: false,
-              available_to_admin: true)
-          end
-
-          before do
-            store_with_payment_methods.payment_methods << admin_only_payment_method
-          end
-
-          it 'returns only the payment methods available to users for that store' do
-            expect(order.available_payment_methods).to match_array(
-              [payment_method_with_store]
-            )
-          end
-        end
-      end
-
-      context 'when the store does not have payment methods' do
-        before { order.update!(store: store_without_payment_methods) }
-
-        it 'returns all matching payment methods regardless of store' do
-          expect(order.available_payment_methods).to match_array(
-            [payment_method_with_store, payment_method_without_store]
-          )
-        end
-      end
-    end
-  end
-end

data/spec/requests/solidus_afterpay/callbacks_controller_spec.rb

@@ -1,127 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe SolidusAfterpay::CallbacksController, type: :request do
-  describe 'GET cancel' do
-    subject(:request) { get '/solidus_afterpay/callbacks/cancel', params: params }
-
-    let(:order) { create(:order_with_totals, state: 'payment') }
-
-    let(:params) { { order_number: order.number } }
-
-    it 'redirects to the order current checkout state page' do
-      request
-      expect(response).to redirect_to('/checkout/payment')
-    end
-  end
-
-  describe 'GET confirm' do
-    subject(:request) { get '/solidus_afterpay/callbacks/confirm', params: params }
-
-    let(:order) { create(:order_with_totals, state: 'payment', user: user) }
-    let(:payment_method) { create(:afterpay_payment_method) }
-    let(:user) { create(:user) }
-
-    let(:order_token) { 'ORDER_TOKEN' }
-    let(:order_number) { order.number }
-    let(:payment_method_id) { payment_method.id }
-
-    let(:params) { { orderToken: order_token, order_number: order_number, payment_method_id: payment_method_id } }
-
-    context 'when the user is logged in', with_signed_in_user: true do
-      context 'with valid data' do
-        it 'redirects to the order next checkout state page' do
-          request
-          expect(response).to redirect_to('/checkout/confirm')
-        end
-
-        it 'moves the order to its next state' do
-          expect { request }.to change { order.reload.state }.from('payment').to('confirm')
-        end
-
-        it 'creates a payment' do
-          expect { request }.to change { order.payments.count }.from(0).to(1)
-        end
-
-        it 'sets the payment total equal to the order total' do
-          request
-          expect(order.payments.last.amount).to eq(order.total)
-        end
-
-        it 'creates a payment source and assigns the order token to it' do
-          request
-          expect(order.payments.last.payment_source.token).to eq(order_token)
-        end
-      end
-
-      context 'when the order_token is missing' do
-        let(:order_token) { nil }
-
-        it 'redirects to the order current checkout state page' do
-          request
-          expect(response).to redirect_to('/checkout/payment')
-        end
-      end
-
-      context 'when the order_number is invalid' do
-        let(:order_number) { 'INVALID_ORDER_NUMBER' }
-
-        it 'redirects to the cart page' do
-          request
-          expect(response).to redirect_to('/cart')
-        end
-
-        it 'sets a resource not found flash message' do
-          request
-          expect(flash[:notice]).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 }
-
-        it 'redirects to the cart page' do
-          request
-          expect(response).to redirect_to('/cart')
-        end
-
-        it 'sets a resource not found flash message' do
-          request
-          expect(flash[:notice]).to eq('The resource you were looking for could not be found.')
-        end
-      end
-
-      context 'when the order is already in confirm state' do
-        let(:order) { create(:order_with_totals, state: 'confirm') }
-
-        it "doesn't move the order to its next state" do
-          expect { request }.not_to(change { order.reload.state })
-        end
-      end
-
-      context 'when the order is already completed' do
-        let(:order) { create(:completed_order_with_totals) }
-
-        it 'redirects to the order detail page' do
-          request
-          expect(response).to redirect_to("/orders/#{order.number}")
-        end
-      end
-    end
-
-    context 'when the user is a guest user', with_guest_session: true do
-      it 'redirects to the order next checkout state page' do
-        request
-        expect(response).to redirect_to('/checkout/confirm')
-      end
-    end
-
-    context 'when the user is not logged in' do
-      it 'redirects the user to vallalah' do
-        request
-        expect(response).to redirect_to('/cart')
-      end
-    end
-  end
-end

data/spec/requests/solidus_afterpay/checkouts_controller_spec.rb

@@ -1,190 +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
-              )
-            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
-              )
-            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 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/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/preferences.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.configure do |config|
-  def described_class_source_location
-    described_class.instance_methods(false).map do |method|
-      described_class.instance_method(method).source_location.first
-    end.uniq.first
-  end
-
-  config.before(:each, use_solidus_api: true) do
-    SolidusAfterpay.configure do |c|
-      c.use_solidus_api = true
-    end
-
-    class_name = described_class.to_s.split('::').last
-    source_location = described_class_source_location
-
-    SolidusAfterpay.send(:remove_const, class_name)
-    load source_location
-  end
-
-  config.after(:each, use_solidus_api: true) do
-    SolidusAfterpay.configure do |c|
-      c.use_solidus_api = false
-    end
-
-    class_name = described_class.to_s.split('::').last
-    source_location = described_class_source_location
-
-    SolidusAfterpay.send(:remove_const, class_name)
-    load source_location
-  end
-end

data/spec/support/vcr.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-require 'vcr'
-
-VCR.configure do |config|
-  config.ignore_localhost = true
-  config.cassette_library_dir = "spec/fixtures/vcr_casettes"
-  config.hook_into :webmock
-  config.configure_rspec_metadata!
-  config.allow_http_connections_when_no_cassette = false
-
-  config.filter_sensitive_data('<ENCODED_AUTH_HEADER>') do
-    Base64.strict_encode64(
-      "#{ENV.fetch('AFTERPAY_MERCHANT_ID',
-        'dummy_merchant_id')}:#{ENV.fetch('AFTERPAY_SECRET_KEY', 'dummy_secret_key')}"
-    )
-  end
-end