solidus_stripe 4.4.0 → 5.0.0.alpha.1

data/spec/models/solidus_stripe/prepare_order_for_payment_service_spec.rb

@@ -1,65 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe SolidusStripe::PrepareOrderForPaymentService do
-  let(:service) { described_class.new(address, controller) }
-
-  let(:address) { create :address }
-  let(:user) { double("Spree::User") }
-  let(:email) { "foo@example.com" }
-  let(:order) { create :order_with_line_items, state: :cart, ship_address: nil, bill_address: nil }
-  let!(:shipping_method) { create :shipping_method, name: 'Air Mail', cost: 15 }
-  let!(:other_shipping_method) { create :shipping_method, name: 'DHL', cost: 7 }
-  let(:controller) do
-    double(
-      current_order: order,
-      spree_current_user: user,
-      params: {
-        email: email,
-        shipping_option: { id: shipping_method.id }
-      }
-    )
-  end
-
-  before do
-    Spree::ZoneMember.create!(zone: Spree::Zone.first, zoneable: address.country)
-  end
-
-  describe "#call" do
-    subject { service.call }
-
-    it "sets the order ship and bill address" do
-      expect { subject }.to change { order.ship_address }.to(address)
-        .and change { order.bill_address }.to(address)
-    end
-
-    context "when the user is not logged in" do
-      let(:user) { nil }
-
-      it "sets the order email to allow guest checkout" do
-        expect { subject }.to change { order.email }.to(email)
-      end
-    end
-
-    it "sets the right shipping rate" do
-      expect { subject }.to change {
-        order.shipments.first.selected_shipping_rate.shipping_method_id
-      }.to(shipping_method.id)
-    end
-
-    context "when the order can be advanced to payment state" do
-      it "advances the order to 'payment'" do
-        expect { subject }.to change { order.state }.to("payment")
-      end
-    end
-
-    context "when the order fails to be advanced to payment state" do
-      before { order.line_items.destroy_all }
-
-      it "leaves the order to a previous state" do
-        expect { subject }.not_to change { order.state }
-      end
-    end
-  end
-end

data/spec/models/solidus_stripe/shipping_rates_service_spec.rb

@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe SolidusStripe::ShippingRatesService do
-  let(:service) { described_class.new(order, user, params) }
-
-  let(:order) { create :order }
-  let(:user) { Spree::User.new }
-
-  let(:params) do
-    {
-      country: Spree::ZoneMember.first.zoneable.iso,
-      city: "Metropolis",
-      postalCode: "12345",
-      recipient: "",
-      addressLine: []
-    }
-  end
-
-  let(:ups_ground) { create(:shipping_method, cost: 5, available_to_all: false) }
-  let(:air_mail) { create(:shipping_method, cost: 8, name: "Air Mail", available_to_all: false) }
-
-  let(:fl_warehouse) { create(:stock_location, name: "FL Warehouse", shipping_methods: [ups_ground]) }
-  let(:ca_warehouse) { create(:stock_location, name: "CA Warehouse", shipping_methods: [air_mail]) }
-
-  before do
-    2.times { create :inventory_unit, order: order }
-    Spree::StockLocation.update_all backorderable_default: false
-    Spree::StockItem.find_by(stock_location: fl_warehouse, variant: order.variants.first).set_count_on_hand(1)
-    Spree::StockItem.find_by(stock_location: ca_warehouse, variant: order.variants.last).set_count_on_hand(1)
-    order.create_proposed_shipments
-  end
-
-  describe "#call" do
-    subject { service.call }
-
-    context "when there are no common shipping methods for all order shipments" do
-      it "cannot find any shipping rate" do
-        expect(subject).to be_empty
-      end
-    end
-
-    context "when there are common shipping methods for all order shipments" do
-      before { fl_warehouse.shipping_methods << ca_warehouse.shipping_methods.first }
-
-      context "when one shipping method is available for all shipments" do
-        it "sums the shipping rates for the shared shipping method" do
-          expect(subject).to eql [{ amount: 1600, id: air_mail.id.to_s, label: air_mail.name }]
-        end
-      end
-    end
-  end
-end

data/spec/models/spree/payment_method/stripe_credit_card_spec.rb

@@ -1,350 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Spree::PaymentMethod::StripeCreditCard do
-  let(:secret_key) { 'key' }
-  let(:email) { 'customer@example.com' }
-  let(:source) { Spree::CreditCard.new }
-
-  let(:bill_address) { nil }
-
-  let(:order) {
-    double('Spree::Order',
-      email: email,
-      bill_address: bill_address,
-      currency: 'USD',
-      number: 'NUMBER',
-      total: 10.99
-    )
-  }
-
-  let(:payment) {
-    double('Spree::Payment',
-      source: source,
-      order: order,
-      amount: order.total
-    )
-  }
-
-  let(:gateway) do
-    double('gateway').tap do |p|
-      allow(p).to receive(:purchase)
-      allow(p).to receive(:authorize)
-      allow(p).to receive(:capture)
-    end
-  end
-
-  before do
-    subject.preferences = { secret_key: secret_key }
-    allow(subject).to receive(:options_for_purchase_or_auth).and_return(['money', 'cc', 'opts'])
-    allow(subject).to receive(:gateway).and_return gateway
-  end
-
-  it 'can enable Stripe.js V3 Elements via preference setting' do
-    expect do
-      subject.preferred_v3_elements = true
-    end.to change { subject.v3_elements? }.from(false).to true
-  end
-
-  describe '#stripe_config' do
-    context 'when payment request feature is disabled' do
-      before { subject.preferences = { publishable_key: 'stripe_key' } }
-
-      it 'includes the basic configuration' do
-        config = subject.stripe_config(order)
-        expect(config.keys).to eq %i[id publishable_key]
-        expect(config[:publishable_key]).to include('stripe_key')
-      end
-    end
-
-    context 'when the payment request feature is enabled' do
-      before do
-        subject.preferences = {
-          publishable_key: 'stripe_key',
-          stripe_country: 'US',
-          v3_intents: true
-        }
-      end
-
-      it 'includes the payment request configuration as well' do
-        config = subject.stripe_config(order)
-        expect(config.keys).to eq %i[id publishable_key payment_request]
-        expect(config[:payment_request][:currency]).to eq 'usd'
-        expect(config[:payment_request][:amount]).to be 1099
-        expect(config[:payment_request][:label]).to include 'NUMBER'
-      end
-    end
-  end
-
-  describe '#create_profile' do
-    before do
-      allow(payment.source).to receive(:update_attributes!)
-    end
-
-    context 'with an order that has a bill address' do
-      let(:bill_address) {
-        double('Spree::Address',
-          address1: '123 Happy Road',
-          address2: 'Apt 303',
-          city: 'Suzarac',
-          zipcode: '95671',
-          state: double('Spree::State', name: 'Oregon'),
-          country: double('Spree::Country', name: 'United States'))
-      }
-
-      it 'stores the bill address with the gateway' do
-        expect(subject.gateway).to receive(:store).with(payment.source, {
-          email: email,
-          login: secret_key,
-
-          address: {
-            address1: '123 Happy Road',
-            address2: 'Apt 303',
-            city: 'Suzarac',
-            zip: '95671',
-            state: 'Oregon',
-            country: 'United States'
-          }
-        }).and_return double.as_null_object
-
-        subject.create_profile payment
-      end
-    end
-
-    context 'with an order that does not have a bill address' do
-      it 'does not store a bill address with the gateway' do
-        expect(subject.gateway).to receive(:store).with(payment.source, {
-          email: email,
-          login: secret_key,
-        }).and_return double.as_null_object
-
-        subject.create_profile payment
-      end
-
-      # Regression test for #141
-      context "correcting the card type" do
-        before do
-          # We don't care about this method for these tests
-          allow(subject.gateway).to receive(:store).and_return(double.as_null_object)
-        end
-
-        it "converts 'American Express' to 'american_express'" do
-          payment.source.cc_type = 'American Express'
-          subject.create_profile(payment)
-          expect(payment.source.cc_type).to eq('american_express')
-        end
-
-        it "converts 'Diners Club' to 'diners_club'" do
-          payment.source.cc_type = 'Diners Club'
-          subject.create_profile(payment)
-          expect(payment.source.cc_type).to eq('diners_club')
-        end
-
-        it "converts 'Visa' to 'visa'" do
-          payment.source.cc_type = 'Visa'
-          subject.create_profile(payment)
-          expect(payment.source.cc_type).to eq('visa')
-        end
-      end
-    end
-
-    context 'with a card represents payment_profile' do
-      let(:source) { Spree::CreditCard.new(gateway_payment_profile_id: 'tok_profileid') }
-      let(:bill_address) { nil }
-
-      it 'stores the profile_id as a card' do
-        expect(subject.gateway).to receive(:store).with(source.gateway_payment_profile_id, anything).and_return double.as_null_object
-
-        subject.create_profile payment
-      end
-    end
-  end
-
-  context 'purchasing' do
-    after do
-      subject.purchase(19.99, 'credit card', {})
-    end
-
-    it 'send the payment to the gateway' do
-      expect(gateway).to receive(:purchase).with('money', 'cc', 'opts')
-    end
-  end
-
-  context 'purchasing with fractionless currency' do
-    after do
-      subject.purchase(1999, 'credit card', { currency: 'JPY' })
-    end
-
-    it 'send the payment to the gateway' do
-      expect(gateway).to receive(:purchase).with('money', 'cc', 'opts')
-    end
-  end
-
-  context 'authorizing' do
-    after do
-      subject.authorize(19.99, 'credit card', {})
-    end
-
-    it 'send the authorization to the gateway' do
-      expect(gateway).to receive(:authorize).with('money', 'cc', 'opts')
-    end
-  end
-
-  context 'authorizing with fractionless currency' do
-    after do
-      subject.authorize(1999, 'credit card', { currency: 'JPY' })
-    end
-
-    it 'send the authorization to the gateway' do
-      expect(gateway).to receive(:authorize).with('money', 'cc', 'opts')
-    end
-  end
-
-  context 'capturing' do
-    after do
-      subject.capture(1234, 'response_code', {})
-    end
-
-    it 'convert the amount to cents' do
-      expect(gateway).to receive(:capture).with(1234, anything, anything)
-    end
-
-    it 'use the response code as the authorization' do
-      expect(gateway).to receive(:capture).with(anything, 'response_code', anything)
-    end
-  end
-
-  context 'capturing with fractionless currency' do
-    after do
-      subject.capture(1234, 'response_code', { currency: 'JPY' })
-    end
-
-    it 'amount not converted to cents' do
-      expect(gateway).to receive(:capture).with(Spree::Money.new(123_400, { currency: 'JPY' }), anything, anything)
-    end
-
-    it 'use the response code as the authorization' do
-      expect(gateway).to receive(:capture).with(anything, 'response_code', anything)
-    end
-  end
-
-  context 'capture with payment class' do
-    let(:payment_method) do
-      payment_method = described_class.new(active: true)
-      payment_method.set_preference :secret_key, secret_key
-      allow(payment_method).to receive(:options_for_purchase_or_auth).and_return(['money', 'cc', 'opts'])
-      allow(payment_method).to receive(:gateway).and_return gateway
-      allow(payment_method).to receive_messages source_required: true
-      payment_method
-    end
-
-    let!(:store) { FactoryBot.create(:store) }
-    let(:order) { Spree::Order.create! }
-
-    let(:card) do
-      FactoryBot.create(
-        :credit_card,
-        gateway_customer_profile_id: 'cus_abcde',
-        imported: false
-      )
-    end
-
-    let(:payment) do
-      payment = Spree::Payment.new
-      payment.source = card
-      payment.order = order
-      payment.payment_method = payment_method
-      payment.amount = 98.55
-      payment.state = 'pending'
-      payment.response_code = '12345'
-      payment
-    end
-
-    let!(:success_response) do
-      double('success_response', success?: true,
-                               authorization: '123',
-                               avs_result: { 'code' => 'avs-code' },
-                               cvv_result: { 'code' => 'cvv-code', 'message' => "CVV Result" })
-    end
-
-    after do
-      payment.capture!
-    end
-
-    it 'gets correct amount' do
-      expect(gateway).to receive(:capture).with(9855, '12345', anything).and_return(success_response)
-    end
-  end
-
-  describe '#try_void' do
-    let(:payment) { create :payment, amount: order.total }
-
-    shared_examples 'voids the payment transaction' do
-      it 'voids the payment transaction' do
-        expect(gateway).to receive(:void)
-
-        subject.try_void(payment)
-      end
-    end
-
-    context 'when using Payment Intents' do
-      before { subject.preferred_v3_intents = true }
-
-      context 'when the payment is completed' do
-        before do
-          allow(payment).to receive(:completed?) { true }
-        end
-
-        it 'creates a refund' do
-          expect { subject.try_void(payment) }.to change { Spree::Refund.count }.by(1)
-        end
-      end
-
-      context 'when the payment is not completed' do
-        it_behaves_like 'voids the payment transaction'
-      end
-    end
-
-    context 'when not using Payment Intents' do
-      before { subject.preferred_v3_intents = false }
-
-      context 'when the payment is completed' do
-        it_behaves_like 'voids the payment transaction'
-      end
-
-      context 'when the payment is not completed' do
-        it_behaves_like 'voids the payment transaction'
-      end
-    end
-  end
-
-  describe '#options_for_purchase_or_auth' do
-    let(:card) do
-      FactoryBot.create(
-        :credit_card,
-        gateway_customer_profile_id: 'cus_abcde',
-        imported: false
-      )
-    end
-
-    before do
-      allow(subject).to receive(:options_for_purchase_or_auth).and_call_original
-    end
-
-    context 'transaction_options' do
-      it 'includes basic values and keys' do
-        options = subject.send(:options_for_purchase_or_auth, 19.99, card, {})
-        expect(options[0]).to eq(19.99)
-        expect(options[1]).to eq(card)
-        expect(options[2].keys).to eq([:description, :currency, :customer])
-      end
-
-      it 'includes statement_descriptor_suffix within options' do
-        transaction_options = { statement_descriptor_suffix: 'FFFFFFF' }
-        options = subject.send(:options_for_purchase_or_auth, 19.99, card, transaction_options)
-        expect(options.last[:statement_descriptor_suffix]).to eq('FFFFFFF')
-      end
-    end
-  end
-end

data/spec/requests/payment_requests_spec.rb

@@ -1,152 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-RSpec.describe "Payment Request", type: :request do
-  describe "POST /stripe/update_order" do
-    it "responds with { success: true } when the order is correctly updated" do
-      order = create(:order_ready_to_complete)
-      allow_any_instance_of(SolidusStripe::PaymentRequestController).to receive(:current_order).and_return(order)
-
-      with_disabled_forgery_protection do
-        post "/stripe/update_order", params: stripe_update_request_params(order: order)
-      end
-
-      json = JSON.parse(response.body)
-      expect(json["success"]).to be_truthy
-    end
-
-    context "when phone number is provided as param and already set on the address" do
-      it "overrides the address field" do
-        order = create(:order_ready_to_complete)
-        allow_any_instance_of(SolidusStripe::PaymentRequestController).to receive(:current_order).and_return(order)
-
-        expect {
-          with_disabled_forgery_protection do
-            post "/stripe/update_order", params: stripe_update_request_params(order: order, shipping_address: default_shipping_address(phone: nil), phone: '911')
-          end
-        }.to change { order.shipping_address.phone }.to('911')
-      end
-    end
-
-    context "when phone number is provided both as shipping address param and main param, and already set on the address" do
-      it "overrides the address field giving precedence to the shipping address param" do
-        order = create(:order_ready_to_complete)
-        allow_any_instance_of(SolidusStripe::PaymentRequestController).to receive(:current_order).and_return(order)
-
-        expect {
-          with_disabled_forgery_protection do
-            post "/stripe/update_order", params: stripe_update_request_params(order: order, shipping_address: default_shipping_address(phone: '555'), phone: '911')
-          end
-        }.to change { order.shipping_address.phone }.to('555')
-      end
-    end
-
-    context "when phone number is not required, not provided as param and not set on the shipping address" do
-      it "does not populate the address field" do
-        with_address_phone_not_required
-        order = create(:order_ready_to_complete, shipping_address: create(:address, phone: nil))
-        allow_any_instance_of(SolidusStripe::PaymentRequestController).to receive(:current_order).and_return(order)
-
-        expect {
-          with_disabled_forgery_protection do
-            post "/stripe/update_order", params: stripe_update_request_params(order: order, shipping_address: default_shipping_address(phone: nil), phone: nil)
-          end
-        }.not_to change { order.shipping_address.phone }
-      end
-    end
-
-    context "when phone number is not required, provided as param and not set on the shipping address" do
-      it "populates the address field with the phone passed as param" do
-        with_address_phone_not_required
-        order = create(:order_ready_to_complete, shipping_address: create(:address, phone: nil))
-        allow_any_instance_of(SolidusStripe::PaymentRequestController).to receive(:current_order).and_return(order)
-
-        expect {
-          with_disabled_forgery_protection do
-            post "/stripe/update_order", params: stripe_update_request_params(order: order, shipping_address: default_shipping_address(phone: nil), phone: '911')
-          end
-        }.to change { order.shipping_address.phone }.from(nil).to('911')
-      end
-    end
-
-    context "when phone number is not required, provided as param but already set on the shipping address" do
-      it "populates the address field with the phone passed in the shipping field" do
-        with_address_phone_not_required
-        order = create(:order_ready_to_complete, shipping_address: create(:address, phone: nil))
-        allow_any_instance_of(SolidusStripe::PaymentRequestController).to receive(:current_order).and_return(order)
-
-        expect {
-          with_disabled_forgery_protection do
-            post "/stripe/update_order", params: stripe_update_request_params(order: order, shipping_address: default_shipping_address(phone: '555'), phone: '911')
-          end
-        }.to change { order.shipping_address.phone }.from(nil).to('555')
-      end
-    end
-  end
-
-  private
-
-  def with_address_phone_not_required
-    if Spree::Config.respond_to?(:address_requires_phone)
-      stub_spree_preferences(address_requires_phone: false)
-    else
-      allow_any_instance_of(Spree::Address).to receive(:require_phone?).and_return(false)
-    end
-  end
-
-  def with_disabled_forgery_protection
-    original_allow_forgery_protection_value = ActionController::Base.allow_forgery_protection
-    ActionController::Base.allow_forgery_protection = false
-
-    yield
-
-    ActionController::Base.allow_forgery_protection = original_allow_forgery_protection_value
-  end
-
-  def stripe_update_request_params(
-    order:,
-    shipping_address: nil,
-    name: 'Clark Kent',
-    phone: '555-555-0199'
-    )
-
-    {
-      shipping_address: shipping_address || default_shipping_address,
-      shipping_option: {
-        id: order.shipments.first.shipping_rates.first.shipping_method.id
-      },
-      name: name,
-      phone: phone,
-      email: order.email
-    }
-  end
-
-  def default_shipping_address(
-    country: nil,
-    region: nil,
-    recipient: 'Clark Kent',
-    city: 'Metropolis',
-    postal_code: '12345',
-    address_line: ['12, Lincoln Rd'],
-    phone: '555-555-0199'
-    )
-
-    if country.blank? || region.blank?
-      state = create(:state)
-
-      country ||= state.country.iso
-      region ||= state.abbr
-    end
-
-    {
-      country: country,
-      region: region,
-      recipient: recipient,
-      city: city,
-      postalCode: postal_code,
-      addressLine: address_line,
-      phone: phone
-    }
-  end
-end

data/spec/spec_helper.rb

@@ -1,37 +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_stripe/testing_support/factories.rb
-SolidusDevSupport::TestingSupport::Factories.load_for(SolidusStripe::Engine)
-
-# Requires card input helper defined in lib/solidus_stripe/testing_support/card_input_helper.rb
-require 'solidus_stripe/testing_support/card_input_helper'
-
-RSpec.configure do |config|
-  config.infer_spec_type_from_file_location!
-  config.use_transactional_fixtures = false
-
-  config.include SolidusAddressNameHelper, type: :feature
-  config.include SolidusCardInputHelper, type: :feature
-
-  if Spree.solidus_gem_version < Gem::Version.new('2.11')
-    config.extend Spree::TestingSupport::AuthorizationHelpers::Request, type: :system
-  end
-end

data/spec/support/solidus_address_helper.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-# Since https://github.com/solidusio/solidus/pull/3524 was merged,
-# we need to verify if we're using the single "Name" field or the
-# previous first/last name combination.
-module SolidusAddressNameHelper
-  def fill_in_name
-    if SolidusSupport.combined_first_and_last_name_in_address?
-      fill_in "Name", with: "Han Solo"
-    else
-      fill_in "First Name", with: "Han"
-      fill_in "Last Name", with: "Solo"
-    end
-  end
-end