stripe-ruby-mock 3.1.0.rc3 → 4.0.0

data/lib/stripe_mock/request_handlers/checkout_session.rb

@@ -3,7 +3,135 @@ module StripeMock
     module Checkout
       module Session
         def Session.included(klass)
-          klass.add_handler 'get /v1/checkout/sessions/(.*)', :get_checkout_session
+          klass.add_handler 'post /v1/checkout/sessions', :new_session
+          klass.add_handler 'get /v1/checkout/sessions', :list_checkout_sessions
+          klass.add_handler 'get /v1/checkout/sessions/([^/]*)', :get_checkout_session
+          klass.add_handler 'get /v1/checkout/sessions/([^/]*)/line_items', :list_line_items
+        end
+
+        def new_session(route, method_url, params, headers)
+          id = params[:id] || new_id('cs')
+
+          [:cancel_url, :success_url].each do |p|
+            require_param(p) if params[p].nil? || params[p].empty?
+          end
+
+          line_items = nil
+          if params[:line_items]
+            line_items = params[:line_items].each_with_index.map do |line_item, i|
+              throw Stripe::InvalidRequestError("Quantity is required. Add `quantity` to `line_items[#{i}]`") unless line_item[:quantity]
+              unless line_item[:price] || line_item[:price_data] || (line_item[:amount] && line_item[:currency] && line_item[:name])
+                throw Stripe::InvalidRequestError("Price or amount and currency is required. Add `price`, `price_data`, or `amount`, `currency` and `name` to `line_items[#{i}]`")
+              end
+              {
+                id: new_id("li"),
+                price: if line_item[:price]
+                  line_item[:price]
+                elsif line_item[:price_data]
+                  new_price(nil, nil, line_item[:price_data], nil)[:id]
+                else
+                  new_price(nil, nil, {
+                    unit_amount: line_item[:amount],
+                    currency: line_item[:currency],
+                    product_data: {
+                      name: line_item[:name]
+                    }
+                  }, nil)[:id]
+                end,
+                quantity: line_item[:quantity]
+              }
+            end
+          end
+
+          amount = nil
+          currency = nil
+          if line_items
+            amount = 0
+
+            line_items.each do |line_item| 
+              price = prices[line_item[:price]]
+
+              if price.nil?
+                raise StripeMock::StripeMockError.new("Price not found for ID: #{line_item[:price]}")
+              end
+
+              amount += (price[:unit_amount] * line_item[:quantity])
+            end
+
+            currency = prices[line_items.first[:price]][:currency]
+          end
+
+          payment_status = "unpaid"
+          payment_intent = nil
+          setup_intent = nil
+          case params[:mode]
+          when nil, "payment"
+            params[:customer] ||= new_customer(nil, nil, {email: params[:customer_email]}, nil)[:id]
+            require_param(:line_items) if params[:line_items].nil? || params[:line_items].empty?
+            payment_intent = new_payment_intent(nil, nil, {
+              amount: amount,
+              currency: currency,
+              customer: params[:customer],
+              payment_method_options: params[:payment_method_options],
+              payment_method_types: params[:payment_method_types]
+            }.merge(params[:payment_intent_data] || {}), nil)[:id]
+            checkout_session_line_items[id] = line_items
+          when "setup"
+            if !params[:line_items].nil? && !params[:line_items].empty?
+              throw Stripe::InvalidRequestError.new("You cannot pass `line_items` in `setup` mode", :line_items, http_status: 400)
+            end
+            setup_intent = new_setup_intent(nil, nil, {
+              customer: params[:customer],
+              payment_method_options: params[:payment_method_options],
+              payment_method_types: params[:payment_method_types]
+            }.merge(params[:setup_intent_data] || {}), nil)[:id]
+            payment_status = "no_payment_required"
+          when "subscription"
+            params[:customer] ||= new_customer(nil, nil, {email: params[:customer_email]}, nil)[:id]
+            require_param(:line_items) if params[:line_items].nil? || params[:line_items].empty?
+            checkout_session_line_items[id] = line_items
+          else
+            throw Stripe::InvalidRequestError.new("Invalid mode: must be one of payment, setup, or subscription", :mode, http_status: 400)
+          end
+
+          checkout_sessions[id] = {
+            id: id,
+            object: "checkout.session",
+            allow_promotion_codes: nil,
+            amount_subtotal: amount,
+            amount_total: amount,
+            automatic_tax: {
+              enabled: false,
+              status: nil
+            },
+            billing_address_collection: nil,
+            cancel_url: params[:cancel_url],
+            client_reference_id: nil,
+            currency: currency,
+            customer: params[:customer],
+            customer_details: nil,
+            customer_email: params[:customer_email],
+            livemode: false,
+            locale: nil,
+            metadata: params[:metadata],
+            mode: params[:mode],
+            payment_intent: payment_intent,
+            payment_method_options: params[:payment_method_options],
+            payment_method_types: params[:payment_method_types],
+            payment_status: payment_status,
+            setup_intent: setup_intent,
+            shipping: nil,
+            shipping_address_collection: nil,
+            submit_type: nil,
+            subscription: nil,
+            success_url: params[:success_url],
+            total_details: nil,
+            url: URI.join(StripeMock.checkout_base, id).to_s
+          }
+        end
+
+        def list_checkout_sessions(route, method_url, params, headers)
+          Data.mock_list_object(checkout_sessions.values)
         end
 
         def get_checkout_session(route, method_url, params, headers)
@@ -16,6 +144,35 @@ module StripeMock
           end
           checkout_session
         end
+
+        def list_line_items(route, method_url, params, headers)
+          route =~ method_url
+          checkout_session = assert_existence :checkout_session, $1, checkout_sessions[$1]
+
+          case checkout_session[:mode]
+          when "payment", "subscription"
+            line_items = assert_existence :checkout_session_line_items, $1, checkout_session_line_items[$1]
+            line_items.map do |line_item|
+              price = prices[line_item[:price]].clone
+
+              if price.nil?
+                raise StripeMock::StripeMockError.new("Price not found for ID: #{line_item[:price]}")
+              end
+
+              {
+                id: line_item[:id],
+                object: "item",
+                amount_subtotal: price[:unit_amount] * line_item[:quantity],
+                amount_total: price[:unit_amount] * line_item[:quantity],
+                currency: price[:currency],
+                price: price.clone,
+                quantity: line_item[:quantity]
+              }
+            end
+          else
+            throw Stripe::InvalidRequestError("Only payment and subscription sessions have line items")
+          end
+        end
       end
     end
   end

data/lib/stripe_mock/request_handlers/customers.rb

@@ -5,9 +5,10 @@ module StripeMock
       def Customers.included(klass)
         klass.add_handler 'post /v1/customers',                     :new_customer
         klass.add_handler 'post /v1/customers/([^/]*)',             :update_customer
-        klass.add_handler 'get /v1/customers/([^/]*)',              :get_customer
+        klass.add_handler 'get /v1/customers/((?!search)[^/]*)',    :get_customer
         klass.add_handler 'delete /v1/customers/([^/]*)',           :delete_customer
         klass.add_handler 'get /v1/customers',                      :list_customers
+        klass.add_handler 'get /v1/customers/search',               :search_customers
         klass.add_handler 'delete /v1/customers/([^/]*)/discount',  :delete_customer_discount
       end
 
@@ -140,6 +141,16 @@ module StripeMock
         Data.mock_list_object(customers[stripe_account]&.values, params)
       end
 
+      SEARCH_FIELDS = ["email", "name", "phone"].freeze
+      def search_customers(route, method_url, params, headers)
+        require_param(:query) unless params[:query]
+
+        stripe_account = headers && headers[:stripe_account] || Stripe.api_key
+        all_customers = customers[stripe_account]&.values
+        results = search_results(all_customers, params[:query], fields: SEARCH_FIELDS, resource_name: "customers")
+        Data.mock_list_object(results, params)
+      end
+
       def delete_customer_discount(route, method_url, params, headers)
         stripe_account = headers && headers[:stripe_account] || Stripe.api_key
         route =~ method_url

data/lib/stripe_mock/request_handlers/events.rb

@@ -4,7 +4,7 @@ module StripeMock
 
       def Events.included(klass)
         klass.add_handler 'get /v1/events/(.*)', :retrieve_event
-        klass.add_handler 'get /v1/events',      :list_events 
+        klass.add_handler 'get /v1/events',      :list_events
       end
 
       def retrieve_event(route, method_url, params, headers)
@@ -13,9 +13,36 @@ module StripeMock
       end
 
       def list_events(route, method_url, params, headers)
-        Data.mock_list_object(events.values, params)
+        values = filter_by_created(events.values, params: params)
+        Data.mock_list_object(values, params)
       end
-      
+
+      private
+
+      def filter_by_created(event_list, params:)
+        if params[:created].nil?
+          return event_list
+        end
+
+        if params[:created].is_a?(Hash)
+          if params[:created][:gt]
+            event_list = event_list.select { |event| event[:created] > params[:created][:gt].to_i }
+          end
+          if params[:created][:gte]
+            event_list = event_list.select { |event| event[:created] >= params[:created][:gte].to_i }
+          end
+          if params[:created][:lt]
+            event_list = event_list.select { |event| event[:created] < params[:created][:lt].to_i }
+          end
+          if params[:created][:lte]
+            event_list = event_list.select { |event| event[:created] <= params[:created][:lte].to_i }
+          end
+        else
+          event_list = event_list.select { |event| event[:created] == params[:created].to_i }
+        end
+        event_list
+      end
+
     end
   end
 end

data/lib/stripe_mock/request_handlers/helpers/coupon_helpers.rb

@@ -7,6 +7,7 @@ module StripeMock
           attrs[:coupon]                 = coupon
           attrs[:start]                  = Time.now.to_i
           attrs[:end]                    = (DateTime.now >> coupon[:duration_in_months].to_i).to_time.to_i if coupon[:duration] == 'repeating'
+          attrs[:id]                     = new_id("di")
         end
 
         object[:discount] = Stripe::Discount.construct_from(discount_attrs)

data/lib/stripe_mock/request_handlers/helpers/search_helpers.rb

@@ -0,0 +1,67 @@
+module StripeMock
+  module RequestHandlers
+    module Helpers
+      # Only supports exact matches on a single field, e.g.
+      # - 'amount:100'
+      # - 'email:"name@domain.com"'
+      # - 'name:"Foo Bar"'
+      # - 'metadata["foo"]:"bar"'
+      QUERYSTRING_PATTERN = /\A(?<field>[\w\.]+)(\[['"](?<metadata_key>[^'"]*)['"]\])?:['"]?(?<value>[^'"]*)['"]?\z/
+      def search_results(all_values, querystring, fields: [], resource_name:)
+        values = all_values.dup
+        query_match = QUERYSTRING_PATTERN.match(querystring)
+        raise Stripe::InvalidRequestError.new(
+          'We were unable to parse your search query.' \
+            ' Try using the format `metadata["key"]:"value"` to query for metadata or key:"value" to query for other fields.',
+          nil,
+          http_status: 400,
+        ) unless query_match
+
+        case query_match[:field]
+        when *fields
+          values = values.select { |resource|
+            exact_match?(actual: field_value(resource, field: query_match[:field]), expected: query_match[:value])
+          }
+        when "metadata"
+          values = values.select { |resource|
+            resource[:metadata] &&
+              exact_match?(actual: resource[:metadata][query_match[:metadata_key].to_sym], expected: query_match[:value])
+          }
+        else
+          raise Stripe::InvalidRequestError.new(
+            "Field `#{query_match[:field]}` is an unsupported search field for resource `#{resource_name}`." \
+              " See http://stripe.com/docs/search#query-fields-for-#{resource_name.gsub('_', '-')} for a list of supported fields.",
+            nil,
+            http_status: 400,
+          )
+        end
+
+        values
+      end
+
+      def exact_match?(actual:, expected:)
+        # allow comparisons of integers
+        if actual.respond_to?(:to_i) && actual.to_i == actual
+          expected = expected.to_i
+        end
+        # allow comparisons of boolean
+        case expected
+        when "true"
+          expected = true
+        when "false"
+          expected = false
+        end
+
+        actual == expected
+      end
+
+      def field_value(resource, field:)
+        value = resource
+        field.split('.').each do |segment|
+          value = value[segment.to_sym]
+        end
+        value
+      end
+    end
+  end
+end

data/lib/stripe_mock/request_handlers/helpers/subscription_helpers.rb

@@ -13,11 +13,15 @@ module StripeMock
         subscription[:items][:data] = plans.map do |plan|
           matching_item = items && items.detect { |item| [item[:price], item[:plan]].include? plan[:id] }
           if matching_item
-            quantity = matching_item[:quantity] || 1
-            id = matching_item[:id] || new_id('si')
-            Data.mock_subscription_item({ plan: plan, quantity: quantity, id: id })
+            matching_item[:quantity] ||= 1
+            matching_item[:id] ||= new_id('si')
+            params = matching_item.merge(plan: plan)
+            params[:price] = plan if plan[:object] == "price"
+            Data.mock_subscription_item(params)
           else
-            Data.mock_subscription_item({ plan: plan, id: new_id('si') })
+            params = { plan: plan, id: new_id('si') }
+            params[:price] = plan if plan[:object] == "price"
+            Data.mock_subscription_item(params)
           end
         end
         subscription
@@ -46,10 +50,10 @@ module StripeMock
 
         if (((plan && plan[:trial_period_days]) || 0) == 0 && options[:trial_end].nil?) || options[:trial_end] == "now"
           end_time = options[:billing_cycle_anchor] || get_ending_time(start_time, plan)
-          params.merge!({status: 'active', current_period_end: end_time, trial_start: nil, trial_end: nil, billing_cycle_anchor: options[:billing_cycle_anchor]})
+          params.merge!({status: 'active', current_period_end: end_time, trial_start: nil, trial_end: nil, billing_cycle_anchor: options[:billing_cycle_anchor] || created_time})
         else
           end_time = options[:trial_end] || (Time.now.utc.to_i + plan[:trial_period_days]*86400)
-          params.merge!({status: 'trialing', current_period_end: end_time, trial_start: start_time, trial_end: end_time, billing_cycle_anchor: nil})
+          params.merge!({status: 'trialing', current_period_end: end_time, trial_start: start_time, trial_end: end_time, billing_cycle_anchor: options[:billing_cycle_anchor] || created_time})
         end
 
         params
@@ -86,11 +90,13 @@ module StripeMock
       def get_ending_time(start_time, plan, intervals = 1)
         return start_time unless plan
 
-        case plan[:interval]
+        interval = plan[:interval] || plan.dig(:recurring, :interval)
+        interval_count = plan[:interval_count] || plan.dig(:recurring, :interval_count) || 1
+        case interval
         when "week"
-          start_time + (604800 * (plan[:interval_count] || 1) * intervals)
+          start_time + (604800 * (interval_count) * intervals)
         when "month"
-          (Time.at(start_time).to_datetime >> ((plan[:interval_count] || 1) * intervals)).to_time.to_i
+          (Time.at(start_time).to_datetime >> ((interval_count) * intervals)).to_time.to_i
         when "year"
           (Time.at(start_time).to_datetime >> (12 * intervals)).to_time.to_i # max period is 1 year
         else
@@ -119,6 +125,19 @@ module StripeMock
         end
         total
       end
+
+      def filter_by_timestamp(subscriptions, field:, value:)
+        if value.is_a?(Hash)
+          operator_mapping = { gt: :>, gte: :>=, lt: :<, lte: :<= }
+          subscriptions.filter do |sub|
+            sub[field].public_send(operator_mapping[value.keys[0]], value.values[0])
+          end
+        else
+          subscriptions.filter do |sub|
+            sub[field] == value
+          end
+        end
+      end
     end
   end
 end

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,7 +62,12 @@ 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 = {})

data/lib/stripe_mock/request_handlers/payment_intents.rb

@@ -6,7 +6,8 @@ module StripeMock
       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/(.*)',           :get_payment_intent
+        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
@@ -70,6 +71,14 @@ module StripeMock
         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]
@@ -81,6 +90,10 @@ module StripeMock
         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
 
@@ -169,12 +182,19 @@ module StripeMock
         payment_intent[:status] = 'succeeded'
         btxn = new_balance_transaction('txn', { source: payment_intent[:id] })
 
-        payment_intent[:charges][:data] << Data.mock_charge(
+        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]
+          currency: payment_intent[:currency],
+          payment_method: payment_intent[:payment_method]
         )
 
+        payment_intent[:charges][:data] << charges[charge_id].clone
+
         payment_intent
       end
     end

data/lib/stripe_mock/request_handlers/payment_methods.rb

@@ -78,7 +78,11 @@ module StripeMock
 
       # post /v1/payment_methods/:id
       def update_payment_method(route, method_url, params, headers)
-        allowed_params = [:billing_details, :card, :ideal, :sepa_debit, :metadata]
+        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]
 

data/lib/stripe_mock/request_handlers/prices.rb

@@ -3,14 +3,21 @@ module StripeMock
     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/(.*)',    :get_price
-        klass.add_handler 'get /v1/prices',         :list_prices
+        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
@@ -37,8 +44,28 @@ module StripeMock
           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,11 +2,12 @@ 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)
@@ -32,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']