stripe-ruby-mock 2.5.8 → 4.0.0

data/lib/stripe_mock/request_handlers/invoices.rb

@@ -6,7 +6,8 @@ module StripeMock
         klass.add_handler 'post /v1/invoices',               :new_invoice
         klass.add_handler 'get /v1/invoices/upcoming',       :upcoming_invoice
         klass.add_handler 'get /v1/invoices/(.*)/lines',     :get_invoice_line_items
-        klass.add_handler 'get /v1/invoices/(.*)',           :get_invoice
+        klass.add_handler 'get /v1/invoices/((?!search).*)', :get_invoice
+        klass.add_handler 'get /v1/invoices/search',         :search_invoices
         klass.add_handler 'get /v1/invoices',                :list_invoices
         klass.add_handler 'post /v1/invoices/(.*)/pay',      :pay_invoice
         klass.add_handler 'post /v1/invoices/(.*)',          :update_invoice
@@ -25,6 +26,14 @@ module StripeMock
         invoices[$1].merge!(params)
       end
 
+      SEARCH_FIELDS = ["currency", "customer", "number", "receipt_number", "subscription", "total"].freeze
+      def search_invoices(route, method_url, params, headers)
+        require_param(:query) unless params[:query]
+
+        results = search_results(invoices.values, params[:query], fields: SEARCH_FIELDS, resource_name: "invoices")
+        Data.mock_list_object(results, params)
+      end
+
       def list_invoices(route, method_url, params, headers)
         params[:offset] ||= 0
         params[:limit] ||= 10
@@ -53,16 +62,22 @@ module StripeMock
         route =~ method_url
         assert_existence :invoice, $1, invoices[$1]
         charge = invoice_charge(invoices[$1])
-        invoices[$1].merge!(:paid => true, :attempted => true, :charge => charge[:id])
+        invoices[$1].merge!(
+          :paid => true,
+          :status => "paid",
+          :attempted => true,
+          :charge => charge[:id],
+        )
       end
 
-      def upcoming_invoice(route, method_url, params, headers)
+      def upcoming_invoice(route, method_url, params, headers = {})
+        stripe_account = headers && headers[:stripe_account] || Stripe.api_key
         route =~ method_url
-        raise Stripe::InvalidRequestError.new('Missing required param: customer', nil, http_status: 400) if params[:customer].nil?
+        raise Stripe::InvalidRequestError.new('Missing required param: customer if subscription is not provided', nil, http_status: 400) if params[:customer].nil? && params[:subscription].nil?
         raise Stripe::InvalidRequestError.new('When previewing changes to a subscription, you must specify either `subscription` or `subscription_items`', nil, http_status: 400) if !params[:subscription_proration_date].nil? && params[:subscription].nil? && params[:subscription_plan].nil?
         raise Stripe::InvalidRequestError.new('Cannot specify proration date without specifying a subscription', nil, http_status: 400) if !params[:subscription_proration_date].nil? && params[:subscription].nil?
 
-        customer = customers[params[:customer]]
+        customer = customers[stripe_account][params[:customer]]
         assert_existence :customer, params[:customer], customer
 
         raise Stripe::InvalidRequestError.new("No upcoming invoices for customer: #{customer[:id]}", nil, http_status: 404) if customer[:subscriptions][:data].length == 0
@@ -99,7 +114,12 @@ module StripeMock
         invoice_lines = []
 
         if prorating
-          unused_amount = subscription[:plan][:amount] * subscription[:quantity] * (subscription[:current_period_end] - subscription_proration_date.to_i) / (subscription[:current_period_end] - subscription[:current_period_start])
+          unused_amount = (
+            subscription[:plan][:amount].to_f *
+              subscription[:quantity] *
+              (subscription[:current_period_end] - subscription_proration_date.to_i) / (subscription[:current_period_end] - subscription[:current_period_start])
+            ).ceil
+
           invoice_lines << Data.mock_line_item(
                                    id: new_id('ii'),
                                    amount: -unused_amount,

data/lib/stripe_mock/request_handlers/payment_intents.rb

@@ -0,0 +1,202 @@
+module StripeMock
+  module RequestHandlers
+    module PaymentIntents
+      ALLOWED_PARAMS = [:description, :metadata, :receipt_email, :shipping, :destination, :payment_method, :payment_method_types, :setup_future_usage, :transfer_data, :amount, :currency]
+
+      def PaymentIntents.included(klass)
+        klass.add_handler 'post /v1/payment_intents',               :new_payment_intent
+        klass.add_handler 'get /v1/payment_intents',                :get_payment_intents
+        klass.add_handler 'get /v1/payment_intents/((?!search).*)', :get_payment_intent
+        klass.add_handler 'get /v1/payment_intents/search',         :search_payment_intents
+        klass.add_handler 'post /v1/payment_intents/(.*)/confirm',  :confirm_payment_intent
+        klass.add_handler 'post /v1/payment_intents/(.*)/capture',  :capture_payment_intent
+        klass.add_handler 'post /v1/payment_intents/(.*)/cancel',   :cancel_payment_intent
+        klass.add_handler 'post /v1/payment_intents/(.*)',          :update_payment_intent
+      end
+
+      def new_payment_intent(route, method_url, params, headers)
+        id = new_id('pi')
+
+        ensure_payment_intent_required_params(params)
+        status = case params[:amount]
+        when 3184 then 'requires_action'
+        when 3178 then 'requires_payment_method'
+        when 3055 then 'requires_capture'
+        else
+          'succeeded'
+        end
+        last_payment_error = params[:amount] == 3178 ? last_payment_error_generator(code: 'card_declined', decline_code: 'insufficient_funds', message: 'Not enough funds.') : nil
+        payment_intents[id] = Data.mock_payment_intent(
+          params.merge(
+            id: id,
+            status: status,
+            last_payment_error: last_payment_error
+          )
+        )
+
+        if params[:confirm] && status == 'succeeded'
+          payment_intents[id] = succeeded_payment_intent(payment_intents[id])
+        end
+
+        payment_intents[id].clone
+      end
+
+      def update_payment_intent(route, method_url, params, headers)
+        route =~ method_url
+        id = $1
+
+        payment_intent = assert_existence :payment_intent, id, payment_intents[id]
+        payment_intents[id] = Util.rmerge(payment_intent, params.select{ |k,v| ALLOWED_PARAMS.include?(k)})
+      end
+
+      def get_payment_intents(route, method_url, params, headers)
+        params[:offset] ||= 0
+        params[:limit] ||= 10
+
+        clone = payment_intents.clone
+
+        if params[:customer]
+          clone.delete_if { |k,v| v[:customer] != params[:customer] }
+        end
+
+        Data.mock_list_object(clone.values, params)
+      end
+
+      def get_payment_intent(route, method_url, params, headers)
+        route =~ method_url
+        payment_intent_id = $1 || params[:payment_intent]
+        payment_intent = assert_existence :payment_intent, payment_intent_id, payment_intents[payment_intent_id]
+
+        payment_intent = payment_intent.clone
+        payment_intent
+      end
+
+      SEARCH_FIELDS = ["amount", "currency", "customer", "status"].freeze
+      def search_payment_intents(route, method_url, params, headers)
+        require_param(:query) unless params[:query]
+
+        results = search_results(payment_intents.values, params[:query], fields: SEARCH_FIELDS, resource_name: "payment_intents")
+        Data.mock_list_object(results, params)
+      end
+
+      def capture_payment_intent(route, method_url, params, headers)
+        route =~ method_url
+        payment_intent = assert_existence :payment_intent, $1, payment_intents[$1]
+
+        succeeded_payment_intent(payment_intent)
+      end
+
+      def confirm_payment_intent(route, method_url, params, headers)
+        route =~ method_url
+        payment_intent = assert_existence :payment_intent, $1, payment_intents[$1]
+
+        if params[:payment_method]
+          payment_intent[:payment_method] = params[:payment_method]
+        end
+
+        succeeded_payment_intent(payment_intent)
+      end
+
+      def cancel_payment_intent(route, method_url, params, headers)
+        route =~ method_url
+        payment_intent = assert_existence :payment_intent, $1, payment_intents[$1]
+
+        payment_intent[:status] = 'canceled'
+        payment_intent
+      end
+
+      private
+
+      def ensure_payment_intent_required_params(params)
+        if params[:amount].nil?
+          require_param(:amount)
+        elsif params[:currency].nil?
+          require_param(:currency)
+        elsif non_integer_charge_amount?(params)
+          raise Stripe::InvalidRequestError.new("Invalid integer: #{params[:amount]}", 'amount', http_status: 400)
+        elsif non_positive_charge_amount?(params)
+          raise Stripe::InvalidRequestError.new('Invalid positive integer', 'amount', http_status: 400)
+        end
+      end
+
+      def non_integer_charge_amount?(params)
+        params[:amount] && !params[:amount].is_a?(Integer)
+      end
+
+      def non_positive_charge_amount?(params)
+        params[:amount] && params[:amount] < 1
+      end
+
+      def last_payment_error_generator(code: nil, message: nil, decline_code: nil)
+        {
+          code: code,
+          doc_url: "https://stripe.com/docs/error-codes/payment-intent-authentication-failure",
+          message: message,
+          decline_code: decline_code,
+          payment_method: {
+            id: "pm_1EwXFA2eZvKYlo2C0tlY091l",
+            object: "payment_method",
+            billing_details: {
+              address: {
+                city: nil,
+                country: nil,
+                line1: nil,
+                line2: nil,
+                postal_code: nil,
+                state: nil
+              },
+              email: nil,
+              name: "seller_08072019090000",
+              phone: nil
+            },
+            card: {
+              brand: "visa",
+              checks: {
+                address_line1_check: nil,
+                address_postal_code_check: nil,
+                cvc_check: "unchecked"
+              },
+              country: "US",
+              exp_month: 12,
+              exp_year: 2021,
+              fingerprint: "LQBhEmJnItuj3mxf",
+              funding: "credit",
+              generated_from: nil,
+              last4: "1629",
+              three_d_secure_usage: {
+                supported: true
+              },
+              wallet: nil
+            },
+            created: 1563208900,
+            customer: nil,
+            livemode: false,
+            metadata: {},
+            type: "card"
+          },
+          type: "invalid_request_error"
+        }
+      end
+
+      def succeeded_payment_intent(payment_intent)
+        payment_intent[:status] = 'succeeded'
+        btxn = new_balance_transaction('txn', { source: payment_intent[:id] })
+
+        charge_id = new_id('ch')
+
+        charges[charge_id] = Data.mock_charge(
+          id: charge_id,
+          balance_transaction: btxn,
+          payment_intent: payment_intent[:id],
+          amount: payment_intent[:amount],
+          currency: payment_intent[:currency],
+          payment_method: payment_intent[:payment_method]
+        )
+
+        payment_intent[:charges][:data] << charges[charge_id].clone
+
+        payment_intent
+      end
+    end
+  end
+end

data/lib/stripe_mock/request_handlers/payment_methods.rb

@@ -0,0 +1,124 @@
+module StripeMock
+  module RequestHandlers
+    module PaymentMethods
+      ALLOWED_PARAMS = [:customer, :type]
+
+      def PaymentMethods.included(klass)
+        klass.add_handler 'post /v1/payment_methods',             :new_payment_method
+        klass.add_handler 'get /v1/payment_methods/(.*)',         :get_payment_method
+        klass.add_handler 'get /v1/payment_methods',              :get_payment_methods
+        klass.add_handler 'post /v1/payment_methods/(.*)/attach', :attach_payment_method
+        klass.add_handler 'post /v1/payment_methods/(.*)/detach', :detach_payment_method
+        klass.add_handler 'post /v1/payment_methods/(.*)',        :update_payment_method
+      end
+
+      # post /v1/payment_methods
+      def new_payment_method(route, method_url, params, headers)
+        id = new_id('pm')
+
+        ensure_payment_method_required_params(params)
+
+        payment_methods[id] = Data.mock_payment_method(
+          params.merge(
+            id: id
+          )
+        )
+
+        payment_methods[id].clone
+      end
+
+      #
+      # params: {:type=>"card", :customer=>"test_cus_3"}
+      #
+      # get /v1/payment_methods/:id
+      def get_payment_method(route, method_url, params, headers)
+        id = method_url.match(route)[1] || params[:payment_method]
+        payment_method = assert_existence :payment_method, id, payment_methods[id]
+
+        payment_method.clone
+      end
+
+      # get /v1/payment_methods
+      def get_payment_methods(route, method_url, params, headers)
+        params[:offset] ||= 0
+        params[:limit] ||= 10
+
+        clone = payment_methods.clone
+
+        if params[:customer]
+          clone.delete_if { |_k, v| v[:customer] != params[:customer] }
+        end
+
+        Data.mock_list_object(clone.values, params)
+      end
+
+      # post /v1/payment_methods/:id/attach
+      def attach_payment_method(route, method_url, params, headers)
+        stripe_account = headers && headers[:stripe_account] || Stripe.api_key
+        allowed_params = [:customer]
+
+        id = method_url.match(route)[1]
+
+        assert_existence :customer, params[:customer], customers[stripe_account][params[:customer]]
+
+        payment_method = assert_existence :payment_method, id, payment_methods[id]
+        payment_methods[id] = Util.rmerge(payment_method, params.select { |k, _v| allowed_params.include?(k) })
+        payment_methods[id].clone
+      end
+
+      # post /v1/payment_methods/:id/detach
+      def detach_payment_method(route, method_url, params, headers)
+        id = method_url.match(route)[1]
+
+        payment_method = assert_existence :payment_method, id, payment_methods[id]
+        payment_method[:customer] = nil
+
+        payment_method.clone
+      end
+
+      # post /v1/payment_methods/:id
+      def update_payment_method(route, method_url, params, headers)
+        allowed_params = [:billing_details, :card, :metadata]
+        disallowed_params = params.keys - allowed_params
+        unless disallowed_params.empty?
+          raise Stripe::InvalidRequestError.new("Received unknown parameter: #{disallowed_params.first}", disallowed_params.first)
+        end
+
+        id = method_url.match(route)[1]
+
+        payment_method = assert_existence :payment_method, id, payment_methods[id]
+
+        if payment_method[:customer].nil?
+          raise Stripe::InvalidRequestError.new(
+            'You must save this PaymentMethod to a customer before you can update it.',
+            nil,
+            http_status: 400
+          )
+        end
+
+        payment_methods[id] =
+          Util.rmerge(payment_method, params.select { |k, _v| allowed_params.include?(k)} )
+
+        payment_methods[id].clone
+      end
+
+      private
+
+      def ensure_payment_method_required_params(params)
+        require_param(:type) if params[:type].nil?
+
+        if invalid_type?(params[:type])
+          raise Stripe::InvalidRequestError.new(
+            'Invalid type: must be one of card, ideal or sepa_debit',
+            nil,
+            http_status: 400
+          )
+        end
+      end
+
+      def invalid_type?(type)
+        !%w(card ideal sepa_debit).include?(type)
+      end
+    end
+  end
+end

data/lib/stripe_mock/request_handlers/plans.rb

@@ -34,7 +34,7 @@ module StripeMock
 
       def list_plans(route, method_url, params, headers)
         limit = params[:limit] ? params[:limit] : 10
-        Data.mock_list_object(plans.values.first(limit), limit: limit)
+        Data.mock_list_object(plans.values.first(limit), params.merge!(limit: limit))
       end
 
     end

data/lib/stripe_mock/request_handlers/prices.rb

@@ -0,0 +1,71 @@
+module StripeMock
+  module RequestHandlers
+    module Prices
+
+      def Prices.included(klass)
+        klass.add_handler 'post /v1/prices',               :new_price
+        klass.add_handler 'post /v1/prices/(.*)',          :update_price
+        klass.add_handler 'get /v1/prices/((?!search).*)', :get_price
+        klass.add_handler 'get /v1/prices/search',         :search_prices
+        klass.add_handler 'get /v1/prices',                :list_prices
+      end
+
+      def new_price(route, method_url, params, headers)
+        params[:id] ||= new_id('price')
+
+        if params[:product_data]
+          params[:product] = create_product(nil, nil, params[:product_data], nil)[:id] unless params[:product]
+          params.delete(:product_data)
+        end
+
+        validate_create_price_params(params)
+        prices[ params[:id] ] = Data.mock_price(params)
+      end
+
+      def update_price(route, method_url, params, headers)
+        route =~ method_url
+        assert_existence :price, $1, prices[$1]
+        prices[$1].merge!(params)
+      end
+
+      def get_price(route, method_url, params, headers)
+        route =~ method_url
+        assert_existence :price, $1, prices[$1]
+      end
+
+      def list_prices(route, method_url, params, headers)
+        limit = params[:limit] ? params[:limit] : 10
+        price_data = prices.values
+        validate_list_prices_params(params)
+
+        if params.key?(:lookup_keys)
+          price_data.select! do |price|
+            params[:lookup_keys].include?(price[:lookup_key])
+          end
+        end
+
+        if params.key?(:currency)
+          price_data.select! do |price|
+            params[:currency] == price[:currency]
+          end
+        end
+
+        if params.key?(:product)
+          price_data.select! do |price|
+            params[:product] == price[:product]
+          end
+        end
+
+        Data.mock_list_object(price_data.first(limit), params.merge!(limit: limit))
+      end
+
+      SEARCH_FIELDS = ["active", "currency", "lookup_key", "product", "type"].freeze
+      def search_prices(route, method_url, params, headers)
+        require_param(:query) unless params[:query]
+
+        results = search_results(prices.values, params[:query], fields: SEARCH_FIELDS, resource_name: "prices")
+        Data.mock_list_object(results, params)
+      end
+    end
+  end
+end

data/lib/stripe_mock/request_handlers/products.rb

@@ -2,15 +2,17 @@ module StripeMock
   module RequestHandlers
     module Products
       def self.included(base)
-        base.add_handler 'post /v1/products',        :create_product
-        base.add_handler 'get /v1/products/(.*)',    :retrieve_product
-        base.add_handler 'post /v1/products/(.*)',   :update_product
-        base.add_handler 'get /v1/products',         :list_products
-        base.add_handler 'delete /v1/products/(.*)', :destroy_product
+        base.add_handler 'post /v1/products',               :create_product
+        base.add_handler 'get /v1/products/((?!search).*)', :retrieve_product
+        base.add_handler 'get /v1/products/search',         :search_products
+        base.add_handler 'post /v1/products/(.*)',          :update_product
+        base.add_handler 'get /v1/products',                :list_products
+        base.add_handler 'delete /v1/products/(.*)',        :destroy_product
       end
 
       def create_product(_route, _method_url, params, _headers)
         params[:id] ||= new_id('prod')
+        validate_create_product_params(params)
         products[params[:id]] = Data.mock_product(params)
       end
 
@@ -31,6 +33,14 @@ module StripeMock
         Data.mock_list_object(products.values.take(limit), params)
       end
 
+      SEARCH_FIELDS = ["active", "description", "name", "shippable", "url"].freeze
+      def search_products(route, method_url, params, headers)
+        require_param(:query) unless params[:query]
+
+        results = search_results(products.values, params[:query], fields: SEARCH_FIELDS, resource_name: "products")
+        Data.mock_list_object(results, params)
+      end
+
       def destroy_product(route, method_url, _params, _headers)
         id = method_url.match(route).captures.first
         assert_existence :product, id, products[id]

data/lib/stripe_mock/request_handlers/promotion_codes.rb

@@ -0,0 +1,43 @@
+module StripeMock
+  module RequestHandlers
+    module PromotionCodes
+
+      def PromotionCodes.included(klass)
+        klass.add_handler 'post /v1/promotion_codes',         :new_promotion_code
+        klass.add_handler 'post /v1/promotion_codes/([^/]*)', :update_promotion_code
+        klass.add_handler 'get /v1/promotion_codes/([^/]*)',  :get_promotion_code
+        klass.add_handler 'get /v1/promotion_codes',          :list_promotion_code
+      end
+
+      def new_promotion_code(route, method_url, params, headers)
+        params[:id] ||= new_id("promo")
+        raise Stripe::InvalidRequestError.new("Missing required param: coupon", "promotion_code", http_status: 400) unless params[:coupon]
+
+        if params[:restrictions]
+          if params[:restrictions][:minimum_amount] && !params[:restrictions][:minimum_amount_currency]
+            raise Stripe::InvalidRequestError.new(
+              "You must pass minimum_amount_currency when passing minimum_amount", "minimum_amount_currency", http_status: 400
+            )
+          end
+        end
+
+        promotion_codes[ params[:id] ] = Data.mock_promotion_code(params)
+      end
+
+      def update_promotion_code(route, method_url, params, headers)
+        route =~ method_url
+        assert_existence :promotion_code, $1, promotion_codes[$1]
+        promotion_codes[$1].merge!(params)
+      end
+
+      def get_promotion_code(route, method_url, params, headers)
+        route =~ method_url
+        assert_existence :promotion_code, $1, promotion_codes[$1]
+      end
+
+      def list_promotion_code(route, method_url, params, headers)
+        Data.mock_list_object(promotion_codes.values, params)
+      end
+    end
+  end
+end

data/lib/stripe_mock/request_handlers/refunds.rb

@@ -18,7 +18,18 @@ module StripeMock
           end
         end
 
-        charge = assert_existence :charge, params[:charge], charges[params[:charge]]
+        if params[:payment_intent]
+          payment_intent = assert_existence(
+            :payment_intent,
+            params[:payment_intent],
+            payment_intents[params[:payment_intent]]
+          )
+          charge = {}
+        else
+          charge = assert_existence :charge, params[:charge], charges[params[:charge]]
+          payment_intent = {}
+        end
+        params[:amount] ||= payment_intent[:amount]
         params[:amount] ||= charge[:amount]
         id = new_id('re')
         bal_trans_params = {
@@ -32,7 +43,7 @@ module StripeMock
           :id => id,
           :charge => charge[:id],
         )
-        add_refund_to_charge(refund, charge)
+        add_refund_to_charge(refund, charge) unless charge.empty?
         refunds[id] = refund
 
         if params[:expand] == ['balance_transaction']

data/lib/stripe_mock/request_handlers/setup_intents.rb

@@ -0,0 +1,100 @@
+module StripeMock
+  module RequestHandlers
+    module SetupIntents
+      ALLOWED_PARAMS = [
+        :confirm,
+        :customer,
+        :description,
+        :metadata,
+        :on_behalf_of,
+        :payment_method,
+        :payment_method_options,
+        :payment_method_types,
+        :return_url,
+        :usage
+      ]
+
+      def SetupIntents.included(klass)
+        klass.add_handler 'post /v1/setup_intents', :new_setup_intent
+        klass.add_handler 'get /v1/setup_intents', :get_setup_intents
+        klass.add_handler 'get /v1/setup_intents/(.*)', :get_setup_intent
+        klass.add_handler 'post /v1/setup_intents/(.*)/confirm', :confirm_setup_intent
+        klass.add_handler 'post /v1/setup_intents/(.*)/cancel', :cancel_setup_intent
+        klass.add_handler 'post /v1/setup_intents/(.*)', :update_setup_intent
+      end
+
+      def new_setup_intent(route, method_url, params, headers)
+        id = new_id('si')
+        status = params[:payment_method] ? 'requires_action' : 'requires_payment_method'
+
+        setup_intents[id] = Data.mock_setup_intent(
+          params.merge(
+            id: id,
+            status: status
+          )
+        )
+
+        setup_intents[id].clone
+      end
+
+      def update_setup_intent(route, method_url, params, headers)
+        route =~ method_url
+        id = $1
+
+        setup_intent = assert_existence :setup_intent, id, setup_intents[id]
+        setup_intents[id] = Util.rmerge(setup_intent, params.select { |k, v| ALLOWED_PARAMS.include?(k) })
+      end
+
+      def get_setup_intents(route, method_url, params, headers)
+        params[:offset] ||= 0
+        params[:limit] ||= 10
+
+        clone = setup_intents.clone
+
+        if params[:customer]
+          clone.delete_if { |k, v| v[:customer] != params[:customer] }
+        end
+
+        Data.mock_list_object(clone.values, params)
+      end
+
+      def get_setup_intent(route, method_url, params, headers)
+        route =~ method_url
+        setup_intent_id = $1 || params[:setup_intent]
+        setup_intent = assert_existence :setup_intent, setup_intent_id, setup_intents[setup_intent_id]
+
+        setup_intent = setup_intent.clone
+
+        if params[:expand]&.include?("payment_method")
+          setup_intent[:payment_method] = assert_existence :payment_method, setup_intent[:payment_method], payment_methods[setup_intent[:payment_method]]
+        end
+
+        setup_intent
+      end
+
+      def capture_setup_intent(route, method_url, params, headers)
+        route =~ method_url
+        setup_intent = assert_existence :setup_intent, $1, setup_intents[$1]
+
+        setup_intent[:status] = 'succeeded'
+        setup_intent
+      end
+
+      def confirm_setup_intent(route, method_url, params, headers)
+        route =~ method_url
+        setup_intent = assert_existence :setup_intent, $1, setup_intents[$1]
+
+        setup_intent[:status] = 'succeeded'
+        setup_intent
+      end
+
+      def cancel_setup_intent(route, method_url, params, headers)
+        route =~ method_url
+        setup_intent = assert_existence :setup_intent, $1, setup_intents[$1]
+
+        setup_intent[:status] = 'canceled'
+        setup_intent
+      end
+    end
+  end
+end