stripe-ruby-mock 3.0.1 → 3.1.0.rc2

data/lib/stripe_mock/request_handlers/subscriptions.rb

@@ -17,26 +17,29 @@ module StripeMock
       end
 
       def retrieve_customer_subscription(route, method_url, params, headers)
+        stripe_account = headers && headers[:stripe_account] || Stripe.api_key
         route =~ method_url
 
-        customer = assert_existence :customer, $1, customers[$1]
+        customer = assert_existence :customer, $1, customers[stripe_account][$1]
         subscription = get_customer_subscription(customer, $2)
 
         assert_existence :subscription, $2, subscription
       end
 
       def retrieve_customer_subscriptions(route, method_url, params, headers)
+        stripe_account = headers && headers[:stripe_account] || Stripe.api_key
         route =~ method_url
 
-        customer = assert_existence :customer, $1, customers[$1]
+        customer = assert_existence :customer, $1, customers[stripe_account][$1]
         customer[:subscriptions]
       end
 
       def create_customer_subscription(route, method_url, params, headers)
+        stripe_account = headers && headers[:stripe_account] || Stripe.api_key
         route =~ method_url
 
         subscription_plans = get_subscription_plans_from_params(params)
-        customer = assert_existence :customer, $1, customers[$1]
+        customer = assert_existence :customer, $1, customers[stripe_account][$1]
 
         if params[:source]
           new_card = get_card_by_token(params.delete(:source))
@@ -73,10 +76,10 @@ module StripeMock
       end
 
       def create_subscription(route, method_url, params, headers)
+        stripe_account = headers && headers[:stripe_account] || Stripe.api_key
         if headers && headers[:idempotency_key]
           if subscriptions.any?
             original_subscription = subscriptions.values.find { |c| c[:idempotency_key] == headers[:idempotency_key]}
-            puts original_subscription
             return subscriptions[original_subscription[:id]] if original_subscription
           end
         end
@@ -86,15 +89,7 @@ module StripeMock
 
         customer = params[:customer]
         customer_id = customer.is_a?(Stripe::Customer) ? customer[:id] : customer.to_s
-        customer = assert_existence :customer, customer_id, customers[customer_id]
-
-        if subscription_plans && customer
-          subscription_plans.each do |plan|
-            unless customer[:currency].to_s == plan[:currency].to_s
-              raise Stripe::InvalidRequestError.new("Customer's currency of #{customer[:currency]} does not match plan's currency of #{plan[:currency]}", 'currency', http_status: 400)
-            end
-          end
-        end
+        customer = assert_existence :customer, customer_id, customers[stripe_account][customer_id]
 
         if params[:source]
           new_card = get_card_by_token(params.delete(:source))
@@ -102,7 +97,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)
+        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)
         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)
@@ -133,6 +128,10 @@ module StripeMock
           end
         end
 
+        if params[:trial_period_days]
+          subscription[:status] = 'trialing'
+        end
+
         if params[:cancel_at_period_end]
           subscription[:cancel_at_period_end] = true
           subscription[:canceled_at] = Time.now.utc.to_i
@@ -151,14 +150,16 @@ module StripeMock
       end
 
       def retrieve_subscriptions(route, method_url, params, headers)
+        # 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[$1]
+        #customer = assert_existence :customer, $1, customers[stripe_account][$1]
         #customer[:subscriptions]
       end
 
       def update_subscription(route, method_url, params, headers)
+        stripe_account = headers && headers[:stripe_account] || Stripe.api_key
         route =~ method_url
 
         subscription_id = $2 ? $2 : $1
@@ -166,7 +167,7 @@ module StripeMock
         verify_active_status(subscription)
 
         customer_id = subscription[:customer]
-        customer = assert_existence :customer, customer_id, customers[customer_id]
+        customer = assert_existence :customer, customer_id, customers[stripe_account][customer_id]
 
         if params[:source]
           new_card = get_card_by_token(params.delete(:source))
@@ -197,6 +198,10 @@ module StripeMock
           end
         end
 
+        if params[:trial_period_days]
+          subscription[:status] = 'trialing'
+        end
+
         if params[:cancel_at_period_end]
           subscription[:cancel_at_period_end] = true
           subscription[:canceled_at] = Time.now.utc.to_i
@@ -222,13 +227,14 @@ module StripeMock
       end
 
       def cancel_subscription(route, method_url, params, headers)
+        stripe_account = headers && headers[:stripe_account] || Stripe.api_key
         route =~ method_url
 
         subscription_id = $2 ? $2 : $1
         subscription = assert_existence :subscription, subscription_id, subscriptions[subscription_id]
 
         customer_id = subscription[:customer]
-        customer = assert_existence :customer, customer_id, customers[customer_id]
+        customer = assert_existence :customer, customer_id, customers[stripe_account][customer_id]
 
         cancel_params = { canceled_at: Time.now.utc.to_i }
         cancelled_at_period_end = (params[:at_period_end] == true)
@@ -257,14 +263,17 @@ module StripeMock
                    elsif params[:items]
                      items = params[:items]
                      items = items.values if items.respond_to?(:values)
-                     items.map { |item| item[:plan].to_s if item[:plan] }
+                     items.map { |item| item[:plan] ? item[:plan] : item[:price] }
                    else
                      []
                    end
+        plan_ids.compact!
         plan_ids.each do |plan_id|
           assert_existence :plan, plan_id, plans[plan_id]
+        rescue Stripe::InvalidRequestError
+          assert_existence :price, plan_id, prices[plan_id]
         end
-        plan_ids.map { |plan_id| plans[plan_id] }
+        plan_ids.map { |plan_id| plans[plan_id] || prices[plan_id]}
       end
 
       # Ensure customer has card to charge unless one of the following criterias is met:
@@ -276,6 +285,7 @@ module StripeMock
         return if customer[:invoice_settings][:default_payment_method]
         return if customer[:trial_end]
         return if params[:trial_end]
+        return if subscription[:default_payment_method]
 
         plan_trial_period_days = plan[:trial_period_days] || 0
         plan_has_trial = plan_trial_period_days != 0 || plan[:amount] == 0 || plan[:trial_end]

data/lib/stripe_mock/request_handlers/tokens.rb

@@ -8,6 +8,8 @@ module StripeMock
       end
 
       def create_token(route, method_url, params, headers)
+        stripe_account = headers && headers[:stripe_account] || Stripe.api_key
+
         if params[:customer].nil? && params[:card].nil? && params[:bank_account].nil?
           raise Stripe::InvalidRequestError.new('You must supply either a card, customer, or bank account to create a token.', nil, http_status: 400)
         end
@@ -15,13 +17,13 @@ module StripeMock
         cus_id = params[:customer]
 
         if cus_id && params[:source]
-          customer = assert_existence :customer, cus_id, customers[cus_id]
+          customer = assert_existence :customer, cus_id, customers[stripe_account][cus_id]
 
           # params[:card] is an id; grab it from the db
           customer_card = get_card(customer, params[:source])
           assert_existence :card, params[:source], customer_card
         elsif params[:card].is_a?(String)
-          customer = assert_existence :customer, cus_id, customers[cus_id]
+          customer = assert_existence :customer, cus_id, customers[stripe_account][cus_id]
 
           # params[:card] is an id; grab it from the db
           customer_card = get_card(customer, params[:card])
@@ -32,7 +34,7 @@ module StripeMock
           params[:card][:last4] = params[:card][:number][-4,4]
           customer_card = params[:card]
         elsif params[:bank_account].is_a?(String)
-          customer = assert_existence :customer, cus_id, customers[cus_id]
+          customer = assert_existence :customer, cus_id, customers[stripe_account][cus_id]
 
           # params[:bank_account] is an id; grab it from the db
           bank_account = verify_bank_account(customer, params[:bank_account])
@@ -41,7 +43,7 @@ module StripeMock
           # params[:card] is a hash of cc info; "Sanitize" the card number
           bank_account = params[:bank_account]
         else
-          customer = assert_existence :customer, cus_id, customers[cus_id]
+          customer = assert_existence :customer, cus_id, customers[stripe_account][cus_id] || customers[Stripe.api_key][cus_id]
           customer_card = get_card(customer, customer[:default_source])
         end
 

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

@@ -110,9 +110,41 @@ module StripeMock
 
       end
 
+      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?
+        end
+
+        if prices[price_id]
+          message = already_exists_message(Stripe::Price)
+          raise Stripe::InvalidRequestError.new(message, :id)
+        end
+
+        unless products[product_id]
+          message = not_found_message(Stripe::Product, product_id)
+          raise Stripe::InvalidRequestError.new(message, :product)
+        end
+
+        unless SUPPORTED_CURRENCIES.include?(params[:currency])
+          message = invalid_currency_message(params[:currency])
+          raise Stripe::InvalidRequestError.new(message, :currency)
+        end
+      end
+
+      def validate_list_prices_params(params)
+        if params[:lookup_keys] && !params[:lookup_keys].is_a?(Array)
+          raise Stripe::InvalidRequestError.new('Invalid array', :lookup_keys)
+        end
+      end
+
       def require_param(param_name)
         raise Stripe::InvalidRequestError.new("Missing required param: #{param_name}.", param_name.to_s, http_status: 400)
       end
+
     end
   end
 end

data/lib/stripe_mock/test_strategies/base.rb

@@ -41,6 +41,15 @@ module StripeMock
         }.merge(params)
       end
 
+      def create_price(params={})
+        Stripe::Price.create create_price_params(params)
+      end
+
+      def create_price_params(params={})
+        {
+          :currency => StripeMock.default_currency,
+        }.merge(params)
+      end
 
       def list_subscriptions(limit)
         Stripe::Subscription.list(limit: limit)
@@ -97,10 +106,27 @@ module StripeMock
         }.merge(params)
       end
 
+      def create_checkout_session_params(params = {})
+        {
+            payment_method_types: ['card'],
+            line_items: [{
+                             name: 'T-shirt',
+                             quantity: 1,
+                             amount: 500,
+                             currency: 'usd',
+                         }],
+        }.merge(params)
+      end
+
+
       def create_coupon(params = {})
         Stripe::Coupon.create create_coupon_params(params)
       end
 
+      def create_checkout_session(params = {})
+        Stripe::Checkout::Session.create create_checkout_session_params(params)
+      end
+
       def delete_all_coupons
         coupons = Stripe::Coupon.list
         coupons.data.map(&:delete) if coupons.data.count > 0

data/lib/stripe_mock/version.rb

@@ -1,4 +1,4 @@
 module StripeMock
   # stripe-ruby-mock version
-  VERSION = "3.0.1"
+  VERSION = "3.1.0.rc2"
 end

data/lib/stripe_mock/webhook_fixtures/balance.available.json

@@ -18,6 +18,12 @@
           "currency": "usd"
         }
       ],
+      "instant_available": [
+        {
+          "amount": 0,
+          "currency": "usd"
+        }
+      ],
       "livemode": false,
       "object": "balance"
     }

data/lib/stripe_mock/webhook_fixtures/payment_intent.payment_failed.json

@@ -0,0 +1,186 @@
+{
+  "id": "evt_00000000000000",
+  "object": "event",
+  "api_version": "2018-02-28",
+  "created": 1578401135,
+  "data": {
+    "object": {
+      "id": "pi_00000000000000",
+      "object": "payment_intent",
+      "allowed_source_types": ["card", "sepa_debit"],
+      "amount": 200,
+      "amount_capturable": 0,
+      "amount_received": 0,
+      "application": null,
+      "application_fee_amount": null,
+      "canceled_at": null,
+      "cancellation_reason": null,
+      "capture_method": "automatic",
+      "charges": {
+        "object": "list",
+        "data": [
+          {
+            "id": "py_00000000000000",
+            "object": "charge",
+            "amount": 200,
+            "amount_refunded": 0,
+            "application": null,
+            "application_fee": null,
+            "application_fee_amount": null,
+            "balance_transaction": null,
+            "billing_details": {
+              "address": {
+                "city": null,
+                "country": null,
+                "line1": null,
+                "line2": null,
+                "postal_code": null,
+                "state": null
+              },
+              "email": "john.doe@example.com",
+              "name": "John Doe",
+              "phone": null
+            },
+            "captured": true,
+            "created": 1578401129,
+            "currency": "eur",
+            "customer": "cus_00000000000000",
+            "description": null,
+            "destination": "acct_00000000000000",
+            "dispute": null,
+            "disputed": false,
+            "failure_code": null,
+            "failure_message": null,
+            "fraud_details": {},
+            "invoice": null,
+            "livemode": false,
+            "metadata": {},
+            "on_behalf_of": null,
+            "order": null,
+            "outcome": {
+              "network_status": "approved_by_network",
+              "reason": null,
+              "risk_level": "not_assessed",
+              "seller_message": "Payment complete.",
+              "type": "authorized"
+            },
+            "paid": false,
+            "payment_intent": "pi_00000000000000",
+            "payment_method": "pm_00000000000000",
+            "payment_method_details": {
+              "sepa_debit": {
+                "bank_code": "37040044",
+                "branch_code": null,
+                "country": "DE",
+                "fingerprint": "00000000000000",
+                "last4": "3001",
+                "mandate": "mandate_00000000000000"
+              },
+              "type": "sepa_debit"
+            },
+            "receipt_email": null,
+            "receipt_number": null,
+            "receipt_url": "https://pay.stripe.com/receipts/acct_00000000000000/py_00000000000000/rcpt_00000000000000",
+            "refunded": false,
+            "refunds": {
+              "object": "list",
+              "data": [],
+              "has_more": false,
+              "total_count": 0,
+              "url": "/v1/charges/py_00000000000000/refunds"
+            },
+            "review": null,
+            "shipping": null,
+            "source": null,
+            "source_transfer": null,
+            "statement_descriptor": "ACME Corp",
+            "statement_descriptor_suffix": null,
+            "status": "failed",
+            "transfer_data": {
+              "amount": null,
+              "destination": "acct_00000000000000"
+            },
+            "transfer_group": "group_pi_00000000000000"
+          }
+        ],
+        "has_more": false,
+        "total_count": 1,
+        "url": "/v1/charges?payment_intent=pi_00000000000000"
+      },
+      "client_secret": "pi_00000000000000",
+      "confirmation_method": "automatic",
+      "created": 1578401129,
+      "currency": "eur",
+      "customer": "cus_00000000000000",
+      "description": null,
+      "invoice": null,
+      "last_payment_error": {
+        "code": "payment_intent_payment_attempt_failed",
+        "doc_url": "https://stripe.com/docs/error-codes/payment-intent-payment-attempt-failed",
+        "message": "The payment failed.",
+        "payment_method": {
+          "id": "pm_00000000000000",
+          "object": "payment_method",
+          "billing_details": {
+            "address": {
+              "city": null,
+              "country": null,
+              "line1": null,
+              "line2": null,
+              "postal_code": null,
+              "state": null
+            },
+            "email": "john.doe@example.com",
+            "name": "John Doe",
+            "phone": null
+          },
+          "created": 1578400666,
+          "customer": "cus_00000000000000",
+          "livemode": false,
+          "metadata": {},
+          "sepa_debit": {
+            "bank_code": "37040044",
+            "branch_code": "",
+            "country": "DE",
+            "fingerprint": "00000000000000",
+            "last4": "3001"
+          },
+          "type": "sepa_debit"
+        },
+        "type": "invalid_request_error"
+      },
+      "livemode": false,
+      "metadata": {},
+      "next_action": null,
+      "next_source_action": null,
+      "on_behalf_of": null,
+      "payment_method": null,
+      "payment_method_options": {
+        "card": {
+          "installments": null,
+          "request_three_d_secure": "automatic"
+        }
+      },
+      "payment_method_types": ["card", "sepa_debit"],
+      "receipt_email": null,
+      "review": null,
+      "setup_future_usage": null,
+      "shipping": null,
+      "source": null,
+      "statement_descriptor": "ACME Corp",
+      "statement_descriptor_suffix": null,
+      "status": "requires_source",
+      "transfer_data": {
+        "destination": "acct_00000000000000"
+      },
+      "transfer_group": null
+    }
+  },
+  "livemode": false,
+  "pending_webhooks": 3,
+  "request": {
+    "id": null,
+    "idempotency_key": null
+  },
+  "type": "payment_intent.payment_failed"
+}