stripe-ruby-mock 3.1.0.rc3 → 3.1.0

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/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

@@ -53,7 +53,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

@@ -81,6 +81,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 +173,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

@@ -11,6 +11,12 @@ module StripeMock
 
       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,6 +43,18 @@ 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
     end

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

@@ -15,20 +15,22 @@ module StripeMock
       ]
 
       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
+        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
+            id: id,
+            status: status
           )
         )
 
@@ -40,7 +42,7 @@ module StripeMock
         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)})
+        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)
@@ -50,7 +52,7 @@ module StripeMock
         clone = setup_intents.clone
 
         if params[:customer]
-          clone.delete_if { |k,v| v[:customer] != params[:customer] }
+          clone.delete_if { |k, v| v[:customer] != params[:customer] }
         end
 
         Data.mock_list_object(clone.values, params)
@@ -62,6 +64,11 @@ module StripeMock
         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
 

data/lib/stripe_mock/request_handlers/subscriptions.rb

@@ -69,6 +69,16 @@ module StripeMock
           end
         end
 
+        if params[:promotion_code]
+          promotion_code_id = params[:promotion_code]
+
+          promotion_code = promotion_codes[promotion_code_id]
+
+          unless promotion_code
+            raise Stripe::InvalidRequestError.new("No such promotion code: #{promotion_code_id}", 'promotion_code', http_status: 400)
+          end
+        end
+
         subscriptions[subscription[:id]] = subscription
         add_subscription_to_customer(customer, subscription)
 
@@ -97,7 +107,7 @@ module StripeMock
           customer[:default_source] = new_card[:id]
         end
 
-        allowed_params = %w(customer application_fee_percent coupon items metadata plan quantity source tax_percent trial_end trial_period_days current_period_start created prorate billing_cycle_anchor billing days_until_due idempotency_key enable_incomplete_payments cancel_at_period_end default_tax_rates payment_behavior pending_invoice_item_interval default_payment_method collection_method off_session trial_from_plan expand)
+        allowed_params = %w(id customer application_fee_percent coupon items metadata plan quantity source tax_percent trial_end trial_period_days current_period_start created prorate billing_cycle_anchor billing days_until_due idempotency_key enable_incomplete_payments cancel_at_period_end default_tax_rates payment_behavior pending_invoice_item_interval default_payment_method collection_method off_session trial_from_plan proration_behavior backdate_start_date transfer_data expand automatic_tax payment_settings trial_settings promotion_code)
         unknown_params = params.keys - allowed_params.map(&:to_sym)
         if unknown_params.length > 0
           raise Stripe::InvalidRequestError.new("Received unknown parameter: #{unknown_params.join}", unknown_params.first.to_s, http_status: 400)
@@ -113,6 +123,10 @@ module StripeMock
         # Note: needs updating for subscriptions with multiple plans
         verify_card_present(customer, subscription_plans.first, subscription, params)
 
+        if params[:coupon] && params[:promotion_code]
+          raise Stripe::InvalidRequestError.new("You may only specify one of these parameters: coupon, promotion_code", "coupon", http_status: 400)
+        end
+
         if params[:coupon]
           coupon_id = params[:coupon]
 
@@ -128,15 +142,50 @@ module StripeMock
           end
         end
 
+        if params[:promotion_code]
+          promotion_code_id = params[:promotion_code]
+
+          promotion_code = promotion_codes[promotion_code_id]
+
+          unless promotion_code
+            raise Stripe::InvalidRequestError.new("No such promotion code: #{promotion_code_id}", 'promotion_code', http_status: 400)
+          end
+        end
+
         if params[:trial_period_days]
           subscription[:status] = 'trialing'
         end
 
+        if params[:payment_behavior] == 'default_incomplete'
+          subscription[:status] = 'incomplete'
+        end
+
         if params[:cancel_at_period_end]
           subscription[:cancel_at_period_end] = true
           subscription[:canceled_at] = Time.now.utc.to_i
         end
 
+        if params[:transfer_data] && !params[:transfer_data].empty?
+          throw Stripe::InvalidRequestError.new(missing_param_message("transfer_data[destination]")) unless params[:transfer_data][:destination]
+          subscription[:transfer_data] = params[:transfer_data].dup
+          subscription[:transfer_data][:amount_percent] ||= 100
+        end
+
+        if (s = params[:expand]&.find { |s| s.start_with? 'latest_invoice' })
+          payment_intent = nil
+          unless subscription[:status] == 'trialing'
+            intent_status = subscription[:status] == 'incomplete' ? 'requires_payment_method' : 'succeeded'
+            intent = Data.mock_payment_intent({
+              status: intent_status,
+              amount: subscription[:plan][:amount],
+              currency: subscription[:plan][:currency]
+            })
+            payment_intent = s.include?('latest_invoice.payment_intent') ? intent : intent.id
+          end
+          invoice = Data.mock_invoice([], { payment_intent: payment_intent })
+          subscription[:latest_invoice] = invoice
+        end
+
         subscriptions[subscription[:id]] = subscription
         add_subscription_to_customer(customer, subscription)
 
@@ -153,15 +202,34 @@ module StripeMock
         # stripe_account = headers && headers[:stripe_account] || Stripe.api_key
         route =~ method_url
 
-        Data.mock_list_object(subscriptions.values, params)
-        #customer = assert_existence :customer, $1, customers[stripe_account][$1]
-        #customer[:subscriptions]
+        subs = subscriptions.values
+
+        case params[:status]
+        when nil
+          subs = subs.filter {|subscription| subscription[:status] != "canceled"}
+        when "all"
+          # Include all subscriptions
+        else
+          subs = subs.filter {|subscription| subscription[:status] == params[:status]}
+        end
+        if params[:current_period_end]
+          subs = filter_by_timestamp(subs, field: :current_period_end, value: params[:current_period_end])
+        end
+        if params[:current_period_start]
+          subs = filter_by_timestamp(subs, field: :current_period_start, value: params[:current_period_start])
+        end
+
+        Data.mock_list_object(subs, params)
       end
 
       def update_subscription(route, method_url, params, headers)
         stripe_account = headers && headers[:stripe_account] || Stripe.api_key
         route =~ method_url
 
+        if params[:billing_cycle_anchor] == 'now'
+          params[:billing_cycle_anchor] = Time.now.utc.to_i
+        end
+
         subscription_id = $2 ? $2 : $1
         subscription = assert_existence :subscription, subscription_id, subscriptions[subscription_id]
         verify_active_status(subscription)
@@ -198,6 +266,26 @@ module StripeMock
           end
         end
 
+        if params[:promotion_code]
+          promotion_code_id = params[:promotion_code]
+
+          promotion_code = promotion_codes[promotion_code_id]
+
+          if promotion_code
+            # You can't apply a promotion code with amount restrictions on the Customer object or on a subscription
+            # update API call
+            if promotion_code[:restrictions][:minimum_amount]
+              raise Stripe::InvalidRequestError.new(
+                "This promotion code cannot be redeemed on a subcription update because it uses the `minimum_amount` restriction.",
+                "promotion_code",
+                http_status: 400
+              )
+            end
+          else
+            raise Stripe::InvalidRequestError.new("No such promotion code: #{promotion_code_id}", 'promotion_code', http_status: 400)
+          end
+        end
+
         if params[:trial_period_days]
           subscription[:status] = 'trialing'
         end
@@ -285,6 +373,7 @@ module StripeMock
         return if customer[:invoice_settings][:default_payment_method]
         return if customer[:trial_end]
         return if params[:trial_end]
+        return if params[:payment_behavior] == 'default_incomplete'
         return if subscription[:default_payment_method]
 
         plan_trial_period_days = plan[:trial_period_days] || 0

data/lib/stripe_mock/request_handlers/transfers.rb

@@ -45,7 +45,18 @@ module StripeMock
           raise Stripe::InvalidRequestError.new("Invalid integer: #{params[:amount]}", 'amount', http_status: 400)
         end
 
-        transfers[id] = Data.mock_transfer(params.merge :id => id)
+        bal_trans_params = { amount: params[:amount].to_i, source: id }
+
+        balance_transaction_id = new_balance_transaction('txn', bal_trans_params)
+
+        transfers[id] = Data.mock_transfer(params.merge(id: id, balance_transaction: balance_transaction_id))
+
+        transfer = transfers[id].clone
+        if params[:expand] == ['balance_transaction']
+          transfer[:balance_transaction] = balance_transactions[balance_transaction_id]
+        end
+
+        transfer
       end
 
       def get_transfer(route, method_url, params, headers)

data/lib/stripe_mock/request_handlers/validators/param_validators.rb

@@ -108,13 +108,14 @@ module StripeMock
 
       def validate_create_price_params(params)
         price_id = params[:id].to_s
-        product_id = params[:product]
 
-        @base_strategy.create_price_params.keys.each do |attr_name|
-          message = "Missing required param: #{attr_name}."
-          raise Stripe::InvalidRequestError.new(message, attr_name) if params[attr_name].nil?
+        require_param(:currency) unless params[:currency]
+        unless params[:product] || params[:product_data]
+          raise Stripe::InvalidRequestError("Requires product or product_data")
         end
 
+        product_id = params[:product] || create_product(nil, nil, params[:product_data], nil).id
+
         if prices[price_id]
           message = already_exists_message(Stripe::Price)
           raise Stripe::InvalidRequestError.new(message, :id)