solidus_stripe 4.4.0 → 5.0.0.rc.1

data/spec/models/solidus_stripe/address_from_params_service_spec.rb

@@ -1,87 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe SolidusStripe::AddressFromParamsService do
-  let(:service) { described_class.new(params, user) }
-  let(:state) { create :state }
-
-  describe '#call' do
-    let(:params) do
-      {
-        country: state.country.iso,
-        region: state.abbr,
-        recipient: 'Clark Kent',
-        city: 'Metropolis',
-        postalCode: '12345',
-        addressLine: [ '12, Lincoln Rd'],
-        phone: '555-555-0199'
-      }
-    end
-
-    subject { service.call }
-
-    context "when there is no user" do
-      let(:user) { nil }
-
-      it "returns a non-persisted address model" do
-        expect(subject).to be_new_record
-      end
-    end
-
-    context "when there is a user" do
-      let(:user) { create :user }
-
-      context "when the user has an address compatible with the params" do
-        before do
-          name_attributes = if SolidusSupport.combined_first_and_last_name_in_address?
-            {
-              name: 'Clark Kent'
-            }
-          else
-            {
-              firstname: 'Clark',
-              lastname: 'Kent',
-            }
-          end
-
-          address_attributes = {
-            city: params[:city],
-            zipcode: params[:postalCode],
-            address1: params[:addressLine].first,
-            address2: nil,
-            phone: '555-555-0199',
-          }.merge!(name_attributes)
-
-          user.addresses << create(:address, address_attributes)
-        end
-
-        it "returns an existing user's address" do
-          expect(subject).to eql user.addresses.first
-        end
-      end
-
-      context "when no user's address is compatible with the params" do
-        before do
-          user.addresses << create(:address, state: state)
-        end
-
-        it "returns a non-persisted valid address" do
-          aggregate_failures do
-            expect(subject).to be_new_record
-            expect(subject).to be_valid
-            expect(subject.state).to eq state
-          end
-        end
-
-        context "when the region is the state name" do
-          before { params[:region] = state.name }
-
-          it "still can set the address state attribute" do
-            expect(subject.state).to eq state
-          end
-        end
-      end
-    end
-  end
-end

data/spec/models/solidus_stripe/create_intents_payment_service_spec.rb

@@ -1,127 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe SolidusStripe::CreateIntentsPaymentService do
-  let(:service) { described_class.new(intent_id, stripe, controller) }
-
-  let(:stripe) {
-    Spree::PaymentMethod::StripeCreditCard.create!(
-      name: "Stripe",
-      preferred_secret_key: "sk_test_VCZnDv3GLU15TRvn8i2EsaAN",
-      preferred_publishable_key: "pk_test_Cuf0PNtiAkkMpTVC2gwYDMIg",
-      preferred_v3_elements: false,
-      preferred_v3_intents: true
-    )
-  }
-
-  let(:order) { create :order, state: :payment, total: 19.99 }
-
-  let(:intent_id) { "pi_123123ABC" }
-  let(:controller) { double(current_order: order.reload, params: params, request: spy) }
-
-  let(:params) do
-    {
-      spree_payment_method_id: stripe.id,
-      stripe_payment_intent_id: intent_id,
-      form_data: {
-        addressLine: ["31 Cotton Rd"],
-        city: order.bill_address.city,
-        country: order.bill_address.country.iso,
-        region: order.bill_address.state.abbr,
-        phone: "+188836412312",
-        postalCode: "12345",
-        recipient: "James Edwards",
-      }
-    }
-  end
-
-  let(:intent) do
-    double(params: {
-      "id" => intent_id,
-      "charges" => {
-        "data" => [{
-          "billing_details" => {
-            "name" => "John Doe"
-          },
-          "payment_method_details" => {
-            "card" => {
-              "brand" => "visa",
-              "exp_month" => 1,
-              "exp_year" => 2022,
-              "last4" => "4242"
-            },
-          }
-        }]
-      }
-    })
-  end
-
-  describe '#call' do
-    subject { service.call }
-
-    before do
-      allow(stripe).to receive(:show_intent) { intent }
-      allow_any_instance_of(Spree::CreditCard).to receive(:require_card_numbers?) { false }
-      allow_any_instance_of(Spree::PaymentMethod::StripeCreditCard).to receive(:create_profile) { true }
-    end
-
-    it { expect(subject).to be true }
-
-    it "creates a new pending payment" do
-      expect { subject }.to change { order.payments.count }
-      expect(order.payments.last.reload).to be_pending
-    end
-
-    it "creates a credit card with the correct information" do
-      expect { subject }.to change { Spree::CreditCard.count }
-      card = Spree::CreditCard.last
-
-      aggregate_failures do
-        expect(card.name).to eq "John Doe"
-        expect(card.cc_type).to eq "visa"
-        expect(card.month).to eq "1"
-        expect(card.year).to eq "2022"
-        expect(card.last_digits).to eq "4242"
-      end
-    end
-
-    context "when for any reason the payment could not be created" do
-      before { params[:form_data].delete(:city) }
-
-      it "returns false" do
-        expect(subject).to be false
-      end
-    end
-
-    context "when there are previous pending payments" do
-      let!(:payment) do
-        create(:payment, order: order, amount: order.total).tap do |payment|
-          payment.update!(state: :pending)
-        end
-      end
-
-      before do
-        response = double(success?: true, authorization: payment.response_code)
-        allow_any_instance_of(Spree::PaymentMethod::StripeCreditCard).to receive(:void) { response }
-      end
-
-      context "when one of them is a Payment Intent" do
-        before do
-          payment.update!(payment_method: stripe)
-          payment.source.update!(payment_method: stripe)
-        end
-
-        it "invalidates it" do
-          expect { subject }.to change { payment.reload.state }.to 'void'
-        end
-      end
-
-      context "when none is a Payment Intent" do
-        it "does not invalidate them" do
-          expect { subject }.not_to change { payment.reload.state }
-        end
-      end
-    end
-  end
-end

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