stripe-ruby-mock 3.1.0.rc2 → 3.1.0

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

@@ -29,10 +29,6 @@ module StripeMock
           raise Stripe::InvalidRequestError.new(missing_param_message(k), k) if params[k].nil?
         end
 
-        if !%w[good service].include?(params[:type])
-          raise Stripe::InvalidRequestError.new("Invalid type: must be one of good or service", :type)
-        end
-
         if products[ params[:id] ]
           raise Stripe::InvalidRequestError.new(already_exists_message(Stripe::Product), :id)
         end
@@ -112,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)

data/lib/stripe_mock/server.rb

@@ -16,9 +16,9 @@ module StripeMock
       self.clear_data
     end
 
-    def mock_request(*args)
+    def mock_request(*args, **kwargs)
       begin
-        @instance.mock_request(*args)
+        @instance.mock_request(*args, **kwargs)
       rescue Stripe::InvalidRequestError => e
         {
           :error_raised => 'invalid_request',

data/lib/stripe_mock/test_strategies/base.rb

@@ -10,11 +10,10 @@ module StripeMock
         Stripe::Product.create create_product_params(params)
       end
 
-      def create_product_params(params={})
+      def create_product_params(params = {})
         {
           :id => 'stripe_mock_default_product_id',
           :name => 'Default Product',
-          :type => 'service'
         }.merge(params)
       end
 
@@ -22,16 +21,15 @@ module StripeMock
         Stripe::Product.retrieve(product_id)
       end
 
-
       def list_plans(limit)
         Stripe::Plan.list(limit: limit)
       end
 
-      def create_plan(params={})
+      def create_plan(params = {})
         Stripe::Plan.create create_plan_params(params)
       end
 
-      def create_plan_params(params={})
+      def create_plan_params(params = {})
         {
           :id => 'stripe_mock_default_plan_id',
           :interval => 'month',
@@ -41,23 +39,28 @@ module StripeMock
         }.merge(params)
       end
 
-      def create_price(params={})
+      def create_price(params = {})
         Stripe::Price.create create_price_params(params)
       end
 
-      def create_price_params(params={})
-        {
-          :currency => StripeMock.default_currency,
+      def create_price_params(params = {})
+        price_params = {
+          currency: StripeMock.default_currency,
         }.merge(params)
+        unless price_params.key?(:product) || price_params.key?(:product_data)
+          price_params[:product_data] = {
+            name: 'Product created for price'
+          }
+        end
+        price_params
       end
 
       def list_subscriptions(limit)
         Stripe::Subscription.list(limit: limit)
       end
 
-
-      def generate_card_token(card_params={})
-        card_data = { :number => "4242424242424242", :exp_month => 9, :exp_year => (Time.now.year + 5), :cvc => "999", :tokenization_method => nil }
+      def generate_card_token(card_params = {})
+        card_data = {:number => "4242424242424242", :exp_month => 9, :exp_year => (Time.now.year + 5), :cvc => "999", :tokenization_method => nil}
         card = StripeMock::Util.card_merge(card_data, card_params)
         card[:fingerprint] = StripeMock::Util.fingerprint(card[:number]) if StripeMock.state == 'local'
 
@@ -65,7 +68,7 @@ module StripeMock
         stripe_token.id
       end
 
-      def generate_bank_token(bank_account_params={})
+      def generate_bank_token(bank_account_params = {})
         currency = bank_account_params[:currency] || StripeMock.default_currency
         bank_account = {
           :country => "US",
@@ -81,7 +84,6 @@ module StripeMock
         stripe_token.id
       end
 
-
       def create_coupon_params(params = {})
         currency = params[:currency] || StripeMock.default_currency
         {
@@ -106,27 +108,51 @@ module StripeMock
         }.merge(params)
       end
 
+      def create_checkout_session(params = {})
+        Stripe::Checkout::Session.create create_checkout_session_params(params)
+      end
+
       def create_checkout_session_params(params = {})
         {
-            payment_method_types: ['card'],
-            line_items: [{
-                             name: 'T-shirt',
-                             quantity: 1,
-                             amount: 500,
-                             currency: 'usd',
-                         }],
+          payment_method_types: ['card'],
+          line_items: params[:mode] == "setup" ? nil : [{
+            name: 'T-shirt',
+            quantity: 1,
+            amount: 500,
+            currency: 'usd',
+          }],
+          cancel_url: "https://example.com/cancel",
+          success_url: "https://example.com/success",
         }.merge(params)
       end
 
+      def complete_checkout_session(session, payment_method)
+        session = session.is_a?(Stripe::Checkout::Session) ? session : Stripe::Checkout::Session.retrieve(session)
+        payment_method = payment_method.is_a?(Stripe::PaymentMethod) ? payment_method : Stripe::PaymentMethod.retrieve(payment_method)
+        case session.mode
+        when "payment"
+          Stripe::PaymentIntent.retrieve(session.payment_intent).confirm(payment_method: payment_method.id)
+        when "setup"
+          Stripe::SetupIntent.update(session.setup_intent, {payment_method: payment_method.id})
+        when "subscription"
+          line_items = Stripe::Checkout::Session.list_line_items(session.id)
+          Stripe::Subscription.create({
+            customer: session.customer,
+            items: line_items.map do |line_item|
+              {
+                price: line_item.price.id,
+                quantity: line_item.quantity
+              }
+            end,
+            default_payment_method: payment_method.id
+          })
+        end
+      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.1.0.rc2"
+  VERSION = "3.1.0"
 end

data/lib/stripe_mock/webhook_fixtures/account.updated.json

@@ -10,7 +10,7 @@
       "email": "test@stripe.com",
       "statement_descriptor": "TEST",
       "details_submitted": true,
-      "charge_enabled": false,
+      "charges_enabled": false,
       "payouts_enabled": false,
       "currencies_supported": [
         "USD"

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

@@ -1,31 +1,37 @@
 {
-  "created": 1326853478,
-  "livemode": false,
-  "id": "evt_00000000000000",
-  "type": "balance.available",
+  "id": "evt_000000000000000000000000",
   "object": "event",
+  "api_version": "2020-08-27",
+  "created": 1648319937,
   "data": {
     "object": {
-      "pending": [
-        {
-          "amount": 2217,
-          "currency": "usd"
-        }
-      ],
+      "object": "balance",
       "available": [
         {
-          "amount": 0,
-          "currency": "usd"
+          "amount": 7648,
+          "currency": "usd",
+          "source_types": {
+            "card": 7648
+          }
         }
       ],
-      "instant_available": [
+      "livemode": false,
+      "pending": [
         {
-          "amount": 0,
-          "currency": "usd"
+          "amount": 37734,
+          "currency": "usd",
+          "source_types": {
+            "card": 37734
+          }
         }
-      ],
-      "livemode": false,
-      "object": "balance"
+      ]
     }
-  }
-}
+  },
+  "livemode": false,
+  "pending_webhooks": 2,
+  "request": {
+    "id": null,
+    "idempotency_key": null
+  },
+  "type": "balance.available"
+}

data/lib/stripe_mock/webhook_fixtures/charge.captured.json

@@ -0,0 +1,143 @@
+{
+  "id": "evt_000000000000000000000000",
+  "object": "event",
+  "api_version": "2020-08-27",
+  "created": 1648319938,
+  "data": {
+    "object": {
+      "id": "ch_000000000000000000000000",
+      "object": "charge",
+      "amount": 100,
+      "amount_captured": 100,
+      "amount_refunded": 0,
+      "application": null,
+      "application_fee": null,
+      "application_fee_amount": null,
+      "balance_transaction": "txn_000000000000000000000000",
+      "billing_details": {
+        "address": {
+          "city": null,
+          "country": null,
+          "line1": null,
+          "line2": null,
+          "postal_code": null,
+          "state": null
+        },
+        "email": null,
+        "name": null,
+        "phone": null
+      },
+      "calculated_statement_descriptor": "EXAMPLECOMPANY",
+      "captured": true,
+      "created": 1648319937,
+      "currency": "usd",
+      "customer": null,
+      "description": "(created by Stripe CLI)",
+      "destination": null,
+      "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": "normal",
+        "risk_score": 64,
+        "seller_message": "Payment complete.",
+        "type": "authorized"
+      },
+      "paid": true,
+      "payment_intent": null,
+      "payment_method": "card_000000000000000000000000",
+      "payment_method_details": {
+        "card": {
+          "brand": "visa",
+          "checks": {
+            "address_line1_check": null,
+            "address_postal_code_check": null,
+            "cvc_check": null
+          },
+          "country": "US",
+          "exp_month": 3,
+          "exp_year": 2023,
+          "fingerprint": "ZoVSX2dK5igWt2SB",
+          "funding": "credit",
+          "installments": null,
+          "last4": "4242",
+          "mandate": null,
+          "network": "visa",
+          "three_d_secure": null,
+          "wallet": null
+        },
+        "type": "card"
+      },
+      "receipt_email": null,
+      "receipt_number": null,
+      "receipt_url": "https://pay.stripe.com/receipts/acct_0000000000000000/ch_000000000000000000000000/rcpt_0000000000000000000000000000000",
+      "refunded": false,
+      "refunds": {
+        "object": "list",
+        "data": [
+
+        ],
+        "has_more": false,
+        "total_count": 0,
+        "url": "/v1/charges/ch_000000000000000000000000/refunds"
+      },
+      "review": null,
+      "shipping": null,
+      "source": {
+        "id": "card_000000000000000000000000",
+        "object": "card",
+        "address_city": null,
+        "address_country": null,
+        "address_line1": null,
+        "address_line1_check": null,
+        "address_line2": null,
+        "address_state": null,
+        "address_zip": null,
+        "address_zip_check": null,
+        "brand": "Visa",
+        "country": "US",
+        "customer": null,
+        "cvc_check": null,
+        "dynamic_last4": null,
+        "exp_month": 3,
+        "exp_year": 2023,
+        "fingerprint": "ZoVSX2dK5igWt2SB",
+        "funding": "credit",
+        "last4": "4242",
+        "metadata": {
+        },
+        "name": null,
+        "tokenization_method": null
+      },
+      "source_transfer": null,
+      "statement_descriptor": null,
+      "statement_descriptor_suffix": null,
+      "status": "succeeded",
+      "transfer_data": null,
+      "transfer_group": null
+    },
+    "previous_attributes": {
+      "amount_captured": 0,
+      "balance_transaction": null,
+      "captured": false
+    }
+  },
+  "livemode": false,
+  "pending_webhooks": 2,
+  "request": {
+    "id": "req_00000000000000",
+    "idempotency_key": "d67cfb41-4cc5-47d0-b2ca-c571e6420952"
+  },
+  "type": "charge.captured"
+}

data/lib/stripe_mock/webhook_fixtures/charge.dispute.created.json

@@ -1,22 +1,69 @@
 {
-  "created": 1326853478,
-  "livemode": false,
-  "id": "evt_00000000000000",
-  "type": "charge.dispute.created",
+  "id": "evt_000000000000000000000000",
   "object": "event",
+  "api_version": "2020-08-27",
+  "created": 1648319940,
   "data": {
     "object": {
-      "charge": "ch_00000000000000",
-      "amount": 1000,
-      "created": 1381080223,
-      "status": "needs_response",
-      "livemode": false,
-      "currency": "usd",
+      "id": "dp_000000000000000000000000",
       "object": "dispute",
-      "reason": "general",
-      "balance_transaction": "txn_00000000000000",
-      "evidence_due_by": 1382745599,
-      "evidence": null
+      "amount": 100,
+      "balance_transaction": null,
+      "balance_transactions": [
+
+      ],
+      "charge": "ch_000000000000000000000000",
+      "created": 1648319940,
+      "currency": "usd",
+      "evidence": {
+        "access_activity_log": null,
+        "billing_address": null,
+        "cancellation_policy": null,
+        "cancellation_policy_disclosure": null,
+        "cancellation_rebuttal": null,
+        "customer_communication": null,
+        "customer_email_address": null,
+        "customer_name": null,
+        "customer_purchase_ip": null,
+        "customer_signature": null,
+        "duplicate_charge_documentation": null,
+        "duplicate_charge_explanation": null,
+        "duplicate_charge_id": null,
+        "product_description": null,
+        "receipt": null,
+        "refund_policy": null,
+        "refund_policy_disclosure": null,
+        "refund_refusal_explanation": null,
+        "service_date": null,
+        "service_documentation": null,
+        "shipping_address": null,
+        "shipping_carrier": null,
+        "shipping_date": null,
+        "shipping_documentation": null,
+        "shipping_tracking_number": null,
+        "uncategorized_file": null,
+        "uncategorized_text": null
+      },
+      "evidence_details": {
+        "due_by": 1649116799,
+        "has_evidence": false,
+        "past_due": false,
+        "submission_count": 0
+      },
+      "is_charge_refundable": true,
+      "livemode": false,
+      "metadata": {
+      },
+      "payment_intent": null,
+      "reason": "fraudulent",
+      "status": "warning_needs_response"
     }
-  }
-}
+  },
+  "livemode": false,
+  "pending_webhooks": 2,
+  "request": {
+    "id": "req_00000000000000",
+    "idempotency_key": "fa04076c-aa1f-40b8-9191-95465afc576e"
+  },
+  "type": "charge.dispute.created"
+}