diff --git a/app/assets/javascripts/admin/subscriptions/controllers/details_controller.js.coffee b/app/assets/javascripts/admin/subscriptions/controllers/details_controller.js.coffee index cb331a62f3..dea96a800c 100644 --- a/app/assets/javascripts/admin/subscriptions/controllers/details_controller.js.coffee +++ b/app/assets/javascripts/admin/subscriptions/controllers/details_controller.js.coffee @@ -16,7 +16,7 @@ angular.module("admin.subscriptions").controller "DetailsController", ($scope, $ return if !newValue? paymentMethod = ($scope.paymentMethods.filter (pm) -> pm.id == newValue)[0] return unless paymentMethod? - $scope.cardRequired = (paymentMethod.type == "Spree::Gateway::StripeConnect" || paymentMethod.type == "Spree::Gateway::StripeSCA") + $scope.cardRequired = paymentMethod.type == "Spree::Gateway::StripeSCA" $scope.loadCustomer() if $scope.cardRequired && !$scope.customer $scope.loadCustomer = -> diff --git a/app/serializers/api/admin/payment_method_serializer.rb b/app/serializers/api/admin/payment_method_serializer.rb index 1d80e2025b..116504cfde 100644 --- a/app/serializers/api/admin/payment_method_serializer.rb +++ b/app/serializers/api/admin/payment_method_serializer.rb @@ -6,8 +6,7 @@ module Api delegate :serializable_hash, to: :method_serializer def method_serializer - if object.type == 'Spree::Gateway::StripeConnect' || - object.type == 'Spree::Gateway::StripeSCA' + if object.type == 'Spree::Gateway::StripeSCA' Api::Admin::PaymentMethod::StripeSerializer.new(object) else Api::Admin::PaymentMethod::BaseSerializer.new(object) diff --git a/app/views/spree/admin/payment_methods/_provider_settings.html.haml b/app/views/spree/admin/payment_methods/_provider_settings.html.haml index 735b6052ab..a60a4ecd49 100644 --- a/app/views/spree/admin/payment_methods/_provider_settings.html.haml +++ b/app/views/spree/admin/payment_methods/_provider_settings.html.haml @@ -1,6 +1,4 @@ - case @payment_method -- when Spree::Gateway::StripeConnect - = render 'stripe_connect' - when Spree::Gateway::StripeSCA = render 'stripe_connect' - else diff --git a/engines/order_management/app/services/order_management/subscriptions/stripe_payment_setup.rb b/engines/order_management/app/services/order_management/subscriptions/stripe_payment_setup.rb index 6a5cf33acb..df79b45ddd 100644 --- a/engines/order_management/app/services/order_management/subscriptions/stripe_payment_setup.rb +++ b/engines/order_management/app/services/order_management/subscriptions/stripe_payment_setup.rb @@ -28,8 +28,7 @@ module OrderManagement end def stripe_payment_method? - [Spree::Gateway::StripeConnect, - Spree::Gateway::StripeSCA].include? @payment.payment_method.class + @payment.payment_method.type == "Spree::Gateway::StripeSCA" end def card_set? diff --git a/engines/order_management/app/services/order_management/subscriptions/validator.rb b/engines/order_management/app/services/order_management/subscriptions/validator.rb index 6fdc0aa9ea..eaa73822e5 100644 --- a/engines/order_management/app/services/order_management/subscriptions/validator.rb +++ b/engines/order_management/app/services/order_management/subscriptions/validator.rb @@ -93,8 +93,7 @@ module OrderManagement end def stripe_payment_method?(payment_method) - payment_method.type == "Spree::Gateway::StripeConnect" || - payment_method.type == "Spree::Gateway::StripeSCA" + payment_method.type == "Spree::Gateway::StripeSCA" end def subscription_line_items_present? diff --git a/spec/controllers/spree/admin/orders/payments/payments_controller_refunds_spec.rb b/spec/controllers/spree/admin/orders/payments/payments_controller_refunds_spec.rb index 62400b8392..8c995de106 100644 --- a/spec/controllers/spree/admin/orders/payments/payments_controller_refunds_spec.rb +++ b/spec/controllers/spree/admin/orders/payments/payments_controller_refunds_spec.rb @@ -16,126 +16,6 @@ describe Spree::Admin::PaymentsController, type: :controller do order.reload.update_totals end - context "Stripe Connect" do - context "requesting a refund on a payment" do - let(:params) { { id: payment.id, order_id: order.number, e: :void } } - - # Required for the respond override in the controller decorator to work - before { @request.env['HTTP_REFERER'] = spree.admin_order_payments_url(payment) } - - context "that was processed by stripe" do - let!(:payment_method) { create(:stripe_connect_payment_method, distributors: [shop]) } - let!(:payment) do - create(:payment, :completed, order: order, payment_method: payment_method, - response_code: 'ch_1a2b3c', amount: order.total) - end - - before do - Stripe.api_key = "sk_test_12345" - end - - context "where the request succeeds" do - before do - stub_request(:post, "https://api.stripe.com/v1/charges/ch_1a2b3c/refunds"). - with(basic_auth: ["sk_test_12345", ""]). - to_return(status: 200, - body: JSON.generate(id: 're_123', object: 'refund', status: 'succeeded') ) - end - - it "voids the payment" do - order.reload - expect(order.payment_total).to_not eq 0 - expect(order.outstanding_balance.to_f).to eq 0 - spree_put :fire, params - expect(payment.reload.state).to eq 'void' - order.reload - expect(order.payment_total).to eq 0 - expect(order.outstanding_balance.to_f).to_not eq 0 - end - end - - context "where the request fails" do - before do - stub_request(:post, "https://api.stripe.com/v1/charges/ch_1a2b3c/refunds"). - with(basic_auth: ["sk_test_12345", ""]). - to_return(status: 200, body: JSON.generate(error: { message: "Bup-bow!" }) ) - end - - it "does not void the payment" do - order.reload - expect(order.payment_total).to_not eq 0 - expect(order.outstanding_balance.to_f).to eq 0 - spree_put :fire, params - expect(payment.reload.state).to eq 'completed' - order.reload - expect(order.payment_total).to_not eq 0 - expect(order.outstanding_balance.to_f).to eq 0 - expect(flash[:error]).to eq "Bup-bow!" - end - end - end - end - - context "requesting a partial credit on a payment" do - let(:params) { { id: payment.id, order_id: order.number, e: :credit } } - - # Required for the respond override in the controller decorator to work - before { @request.env['HTTP_REFERER'] = spree.admin_order_payments_url(payment) } - - context "that was processed by stripe" do - let!(:payment_method) { create(:stripe_connect_payment_method, distributors: [shop]) } - let!(:payment) do - create(:payment, :completed, order: order, payment_method: payment_method, - response_code: 'ch_1a2b3c', amount: order.total + 5) - end - - before do - Stripe.api_key = "sk_test_12345" - end - - context "where the request succeeds" do - before do - stub_request(:post, "https://api.stripe.com/v1/charges/ch_1a2b3c/refunds"). - with(basic_auth: ["sk_test_12345", ""]). - to_return(status: 200, - body: JSON.generate(id: 're_123', object: 'refund', status: 'succeeded') ) - end - - it "partially refunds the payment" do - order.reload - expect(order.payment_total).to eq order.total + 5 - expect(order.outstanding_balance.to_f).to eq(-5) - spree_put :fire, params - expect(payment.reload.state).to eq 'completed' - order.reload - expect(order.payment_total).to eq order.total - expect(order.outstanding_balance.to_f).to eq 0 - end - end - - context "where the request fails" do - before do - stub_request(:post, "https://api.stripe.com/v1/charges/ch_1a2b3c/refunds"). - with(basic_auth: ["sk_test_12345", ""]). - to_return(status: 200, body: JSON.generate(error: { message: "Bup-bow!" }) ) - end - - it "does not void the payment" do - order.reload - expect(order.payment_total).to eq order.total + 5 - expect(order.outstanding_balance.to_f).to eq(-5) - spree_put :fire, params - expect(payment.reload.state).to eq 'completed' - order.reload - expect(order.payment_total).to eq order.total + 5 - expect(order.outstanding_balance.to_f).to eq(-5) - expect(flash[:error]).to eq "Bup-bow!" - end - end - end - end - end - context "StripeSCA" do context "voiding a payment" do let(:params) { { id: payment.id, order_id: order.number, e: :void } } diff --git a/spec/factories/payment_method_factory.rb b/spec/factories/payment_method_factory.rb index 0e796b050a..aadb01f9d6 100644 --- a/spec/factories/payment_method_factory.rb +++ b/spec/factories/payment_method_factory.rb @@ -23,13 +23,6 @@ FactoryBot.define do environment { 'test' } end - factory :stripe_connect_payment_method, class: Spree::Gateway::StripeConnect do - name { 'StripeConnect' } - environment { 'test' } - distributors { [FactoryBot.create(:enterprise)] } - preferred_enterprise_id { distributors.first.id } - end - factory :stripe_sca_payment_method, class: Spree::Gateway::StripeSCA do name { 'StripeSCA' } environment { 'test' } diff --git a/spec/models/spree/payment_method_spec.rb b/spec/models/spree/payment_method_spec.rb index 324b1aebd5..d82b794b0a 100644 --- a/spec/models/spree/payment_method_spec.rb +++ b/spec/models/spree/payment_method_spec.rb @@ -60,7 +60,6 @@ module Spree it "generates a clean name for known Payment Method types" do expect(Spree::PaymentMethod::Check.clean_name).to eq(I18n.t("spree.admin.payment_methods.providers.check")) expect(Spree::Gateway::PayPalExpress.clean_name).to eq(I18n.t("spree.admin.payment_methods.providers.paypalexpress")) - expect(Spree::Gateway::StripeConnect.clean_name).to eq(I18n.t("spree.admin.payment_methods.providers.stripeconnect")) expect(Spree::Gateway::StripeSCA.clean_name).to eq(I18n.t("spree.admin.payment_methods.providers.stripesca")) expect(Spree::Gateway::BogusSimple.clean_name).to eq(I18n.t("spree.admin.payment_methods.providers.bogussimple")) expect(Spree::Gateway::Bogus.clean_name).to eq(I18n.t("spree.admin.payment_methods.providers.bogus")) diff --git a/spec/requests/checkout/stripe_connect_spec.rb b/spec/requests/checkout/stripe_connect_spec.rb deleted file mode 100644 index 6b47efdb59..0000000000 --- a/spec/requests/checkout/stripe_connect_spec.rb +++ /dev/null @@ -1,310 +0,0 @@ -# frozen_string_literal: true - -require 'spec_helper' - -describe "checking out an order with a Stripe Connect payment method", type: :request do - include ShopWorkflow - include AuthenticationHelper - include OpenFoodNetwork::ApiHelper - - let!(:order_cycle) { create(:simple_order_cycle) } - let!(:enterprise) { create(:distributor_enterprise) } - let!(:shipping_method) do - create( - :shipping_method, - calculator: Calculator::FlatRate.new(preferred_amount: 0), - distributors: [enterprise] - ) - end - let!(:payment_method) { create(:stripe_connect_payment_method, distributors: [enterprise]) } - let!(:stripe_account) { create(:stripe_account, enterprise: enterprise) } - let!(:line_item) { create(:line_item, price: 12.34) } - let!(:order) { line_item.order } - let(:address) { create(:address) } - let(:token) { "token123" } - let(:new_token) { "newtoken123" } - let(:card_id) { "card_XyZ456" } - let(:customer_id) { "cus_A123" } - let(:payments_attributes) do - { - payment_method_id: payment_method.id, - source_attributes: { - gateway_payment_profile_id: token, - cc_type: "visa", - last_digits: "4242", - month: 10, - year: 2025, - first_name: 'Jill', - last_name: 'Jeffreys' - } - } - end - let(:allowed_address_attributes) do - [ - "firstname", - "lastname", - "address1", - "address2", - "phone", - "city", - "zipcode", - "state_id", - "country_id" - ] - end - let(:params) do - { - format: :json, order: { - shipping_method_id: shipping_method.id, - payments_attributes: [payments_attributes], - bill_address_attributes: address.attributes.slice(*allowed_address_attributes), - ship_address_attributes: address.attributes.slice(*allowed_address_attributes) - } - } - end - - before do - order_cycle_distributed_variants = double(:order_cycle_distributed_variants) - allow(OrderCycleDistributedVariants).to receive(:new) { order_cycle_distributed_variants } - allow(order_cycle_distributed_variants).to receive(:distributes_order_variants?) { true } - - Stripe.api_key = "sk_test_12345" - order.update(distributor_id: enterprise.id, order_cycle_id: order_cycle.id) - order.reload.update_totals - set_order order - end - - context "when a new card is submitted" do - let(:store_response_mock) do - { - status: 200, - body: JSON.generate( - id: customer_id, - default_card: card_id, - sources: { data: [{ id: "1" }] } - ) - } - end - let(:token_response_mock) do - { status: 200, body: JSON.generate(id: new_token) } - end - let(:charge_response_mock) do - { status: 200, body: JSON.generate(id: "ch_1234", object: "charge", amount: 2000) } - end - - context "and the user doesn't request that the card is saved for later" do - before do - # Charges the card - stub_request(:post, "https://api.stripe.com/v1/charges") - .with(basic_auth: ["sk_test_12345", ""], body: /#{token}.*#{order.number}/) - .to_return(charge_response_mock) - end - - context "and the charge request is successful" do - it "should process the payment without storing card details" do - put update_checkout_path, params: params - - expect(json_response["path"]).to eq order_path(order, order_token: order.token) - expect(order.payments.completed.count).to be 1 - - card = order.payments.completed.first.source - - expect(card.gateway_customer_profile_id).to eq nil - expect(card.gateway_payment_profile_id).to eq token - expect(card.cc_type).to eq "visa" - expect(card.last_digits).to eq "4242" - expect(card.first_name).to eq "Jill" - expect(card.last_name).to eq "Jeffreys" - end - end - - context "when the charge request returns an error message" do - let(:charge_response_mock) do - { status: 402, body: JSON.generate(error: { message: "charge-failure" }) } - end - - it "should not process the payment" do - put update_checkout_path, params: params - - expect(response.status).to be 400 - - expect(json_response["flash"]["error"]).to eq "charge-failure" - expect(order.payments.completed.count).to be 0 - end - end - end - - context "and the customer requests that the card is saved for later" do - before do - source_attributes = params[:order][:payments_attributes][0][:source_attributes] - source_attributes[:save_requested_by_customer] = '1' - - # Saves the card against the user - stub_request(:post, "https://api.stripe.com/v1/customers") - .with(basic_auth: ["sk_test_12345", ""], body: { card: token, email: order.email }) - .to_return(store_response_mock) - - # Requests a token from the newly saved card - stub_request(:post, "https://api.stripe.com/v1/tokens") - .with(body: { card: card_id, customer: customer_id }) - .to_return(token_response_mock) - - # Charges the card - stub_request(:post, "https://api.stripe.com/v1/charges") - .with( - basic_auth: ["sk_test_12345", ""], - body: /#{token}.*#{order.number}/ - ).to_return(charge_response_mock) - end - - context "and the store, token and charge requests are successful" do - it "should process the payment, and stores the card/customer details" do - put update_checkout_path, params: params - - expect(json_response["path"]).to eq order_path(order, order_token: order.token) - expect(order.payments.completed.count).to be 1 - - card = order.payments.completed.first.source - - expect(card.gateway_customer_profile_id).to eq customer_id - expect(card.gateway_payment_profile_id).to eq card_id - expect(card.cc_type).to eq "visa" - expect(card.last_digits).to eq "4242" - expect(card.first_name).to eq "Jill" - expect(card.last_name).to eq "Jeffreys" - end - end - - context "when the store request returns an error message" do - let(:store_response_mock) do - { status: 402, body: JSON.generate(error: { message: "store-failure" }) } - end - - it "should not process the payment" do - put update_checkout_path, params: params - - expect(response.status).to be 400 - - expect(json_response["flash"]["error"]) - .to eq(I18n.t(:spree_gateway_error_flash_for_checkout, error: 'store-failure')) - expect(order.payments.completed.count).to be 0 - end - end - - context "when the charge request returns an error message" do - let(:charge_response_mock) do - { status: 402, body: JSON.generate(error: { message: "charge-failure" }) } - end - - it "should not process the payment" do - put update_checkout_path, params: params - - expect(response.status).to be 400 - - expect(json_response["flash"]["error"]).to eq "charge-failure" - expect(order.payments.completed.count).to be 0 - end - end - - context "when the token request returns an error message" do - let(:token_response_mock) do - { status: 402, body: JSON.generate(error: { message: "token-failure" }) } - end - - # Note, no requests have been stubbed - it "should not process the payment" do - put update_checkout_path, params: params - - expect(response.status).to be 400 - - expect(json_response["flash"]["error"]).to eq "token-failure" - expect(order.payments.completed.count).to be 0 - end - end - end - end - - context "when an existing card is submitted" do - let(:credit_card) do - create( - :credit_card, - user_id: order.user_id, - gateway_payment_profile_id: card_id, - gateway_customer_profile_id: customer_id, - last_digits: "4321", - cc_type: "master", - first_name: "Sammy", - last_name: "Signpost", - month: 11, year: 2026 - ) - end - - let(:token_response_mock) { { status: 200, body: JSON.generate(id: new_token) } } - let(:charge_response_mock) do - { status: 200, body: JSON.generate(id: "ch_1234", object: "charge", amount: 2000) } - end - - before do - params[:order][:existing_card_id] = credit_card.id - login_as(order.user) - - # Requests a token - stub_request(:post, "https://api.stripe.com/v1/tokens") - .with(body: { "card" => card_id, "customer" => customer_id }) - .to_return(token_response_mock) - - # Charges the card - stub_request(:post, "https://api.stripe.com/v1/charges") - .with(basic_auth: ["sk_test_12345", ""], body: /#{token}.*#{order.number}/) - .to_return(charge_response_mock) - end - - context "and the charge and token requests are accepted" do - it "should process the payment, and keep the profile ids and other card details" do - put update_checkout_path, params: params - - expect(json_response["path"]).to eq order_path(order, order_token: order.token) - expect(order.payments.completed.count).to be 1 - - card = order.payments.completed.first.source - - expect(card.gateway_customer_profile_id).to eq customer_id - expect(card.gateway_payment_profile_id).to eq card_id - expect(card.cc_type).to eq "master" - expect(card.last_digits).to eq "4321" - expect(card.first_name).to eq "Sammy" - expect(card.last_name).to eq "Signpost" - end - end - - context "when the charge request returns an error message" do - let(:charge_response_mock) do - { status: 402, body: JSON.generate(error: { message: "charge-failure" }) } - end - - it "should not process the payment" do - put update_checkout_path, params: params - - expect(response.status).to be 400 - - expect(json_response["flash"]["error"]).to eq "charge-failure" - expect(order.payments.completed.count).to be 0 - end - end - - context "when the token request returns an error message" do - let(:token_response_mock) do - { status: 402, body: JSON.generate(error: { message: "token-error" }) } - end - - it "should not process the payment" do - put update_checkout_path, params: params - - expect(response.status).to be 400 - - expect(json_response["flash"]["error"]).to eq "token-error" - expect(order.payments.completed.count).to be 0 - end - end - end -end