stripe-ruby-mock 2.5.6 → 3.1.0.rc2

data/lib/stripe_mock/request_handlers/tax_rates.rb

@@ -0,0 +1,36 @@
+module StripeMock
+  module RequestHandlers
+    module TaxRates
+      def TaxRates.included(klass)
+        klass.add_handler 'post /v1/tax_rates', :new_tax_rate
+        klass.add_handler 'post /v1/tax_rates/([^/]*)', :update_tax_rate
+        klass.add_handler 'get /v1/tax_rates/([^/]*)', :get_tax_rate
+        klass.add_handler 'get /v1/tax_rates', :list_tax_rates
+      end
+
+      def update_tax_rate(route, method_url, params, headers)
+        route =~ method_url
+        rate = assert_existence :tax_rate, $1, tax_rates[$1]
+        rate.merge!(params)
+        rate
+      end
+
+      def new_tax_rate(route, method_url, params, headers)
+        params[:id] ||= new_id('txr')
+        tax_rates[ params[:id] ] = Data.mock_tax_rate(params)
+        tax_rates[ params[:id] ]
+      end
+
+      def list_tax_rates(route, method_url, params, headers)
+        Data.mock_list_object(tax_rates.values, params)
+      end
+
+      def get_tax_rate(route, method_url, params, headers)
+        route =~ method_url
+        tax_rate = assert_existence :tax_rate, $1, tax_rates[$1]
+        tax_rate.clone
+      end
+    end
+  end
+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,17 +43,17 @@ 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
 
         if bank_account
-          token_id = generate_bank_token(bank_account)
+          token_id = generate_bank_token(bank_account.dup)
           bank_account = @bank_tokens[token_id]
 
           Data.mock_bank_account_token(params.merge :id => token_id, :bank_account => bank_account)
         else
-          token_id = generate_card_token(customer_card)
+          token_id = generate_card_token(customer_card.dup)
           card = @card_tokens[token_id]
 
           Data.mock_card_token(params.merge :id => token_id, :card => card)

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

@@ -2,26 +2,147 @@ module StripeMock
   module RequestHandlers
     module ParamValidators
 
-      def validate_create_plan_params(params)
+      def already_exists_message(obj_class)
+        "#{obj_class.to_s.split("::").last} already exists."
+      end
+
+      def not_found_message(obj_class, obj_id)
+        "No such #{obj_class.to_s.split("::").last.downcase}: #{obj_id}"
+      end
+
+      def missing_param_message(attr_name)
+        "Missing required param: #{attr_name}."
+      end
+
+      def invalid_integer_message(my_val)
+        "Invalid integer: #{my_val}"
+      end
+
+      #
+      # ProductValidator
+      #
+
+
+      def validate_create_product_params(params)
         params[:id] = params[:id].to_s
+        @base_strategy.create_product_params.keys.reject{ |k,_| k == :id }.each do |k|
+          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
+      end
+
+      #
+      # PlanValidator
+      #
+
+      def missing_plan_amount_message
+        "Plans require an `amount` parameter to be set."
+      end
+
+      SUPPORTED_PLAN_INTERVALS = ["month", "year", "week", "day"]
+
+      def invalid_plan_interval_message
+        "Invalid interval: must be one of day, month, week, or year"
+      end
+
+      SUPPORTED_CURRENCIES = [
+        "usd", "aed", "afn", "all", "amd", "ang", "aoa", "ars", "aud", "awg", "azn", "bam", "bbd", "bdt", "bgn",
+        "bif", "bmd", "bnd", "bob", "brl", "bsd", "bwp", "bzd", "cad", "cdf", "chf", "clp", "cny", "cop", "crc",
+        "cve", "czk", "djf", "dkk", "dop", "dzd", "egp", "etb", "eur", "fjd", "fkp", "gbp", "gel", "gip", "gmd",
+        "gnf", "gtq", "gyd", "hkd", "hnl", "hrk", "htg", "huf", "idr", "ils", "inr", "isk", "jmd", "jpy", "kes",
+        "kgs", "khr", "kmf", "krw", "kyd", "kzt", "lak", "lbp", "lkr", "lrd", "lsl", "mad", "mdl", "mga", "mkd",
+        "mmk", "mnt", "mop", "mro", "mur", "mvr", "mwk", "mxn", "myr", "mzn", "nad", "ngn", "nio", "nok", "npr",
+        "nzd", "pab", "pen", "pgk", "php", "pkr", "pln", "pyg", "qar", "ron", "rsd", "rub", "rwf", "sar", "sbd",
+        "scr", "sek", "sgd", "shp", "sll", "sos", "srd", "std", "szl", "thb", "tjs", "top", "try", "ttd", "twd",
+        "tzs", "uah", "ugx", "uyu", "uzs", "vnd", "vuv", "wst", "xaf", "xcd", "xof", "xpf", "yer", "zar", "zmw",
+        "eek", "lvl", "svc", "vef", "ltl"
+      ]
+
+      def invalid_currency_message(my_val)
+        "Invalid currency: #{my_val.downcase}. Stripe currently supports these currencies: #{SUPPORTED_CURRENCIES.join(", ")}"
+      end
+
+      def validate_create_plan_params(params)
+        plan_id = params[:id].to_s
+        product_id = params[:product]
 
-        @base_strategy.create_plan_params.keys.each do |name|
+        @base_strategy.create_plan_params.keys.each do |attr_name|
           message =
-            if name == :amount
-              "Plans require an `#{name}` parameter to be set."
+            if attr_name == :amount
+              "Plans require an `#{attr_name}` parameter to be set."
             else
-              "Missing required param: #{name}."
+              "Missing required param: #{attr_name}."
             end
-          raise Stripe::InvalidRequestError.new(message, name) if params[name].nil?
+          raise Stripe::InvalidRequestError.new(message, attr_name) if params[attr_name].nil?
+        end
+
+        if plans[plan_id]
+          message = already_exists_message(Stripe::Plan)
+          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
 
-        if plans[ params[:id] ]
-          raise Stripe::InvalidRequestError.new("Plan already exists.", :id)
+        unless SUPPORTED_PLAN_INTERVALS.include?(params[:interval])
+          message = invalid_plan_interval_message
+          raise Stripe::InvalidRequestError.new(message, :interval)
+        end
+
+        unless SUPPORTED_CURRENCIES.include?(params[:currency])
+          message = invalid_currency_message(params[:currency])
+          raise Stripe::InvalidRequestError.new(message, :currency)
         end
 
         unless params[:amount].integer?
-          raise Stripe::InvalidRequestError.new("Invalid integer: #{params[:amount]}", :amount)
+          message = invalid_integer_message(params[:amount])
+          raise Stripe::InvalidRequestError.new(message, :amount)
         end
+
+      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

data/lib/stripe_mock/test_strategies/base.rb

@@ -2,19 +2,60 @@ module StripeMock
   module TestStrategies
     class Base
 
+      def list_products(limit)
+        Stripe::Product.list(limit: limit)
+      end
+
+      def create_product(params = {})
+        Stripe::Product.create create_product_params(params)
+      end
+
+      def create_product_params(params={})
+        {
+          :id => 'stripe_mock_default_product_id',
+          :name => 'Default Product',
+          :type => 'service'
+        }.merge(params)
+      end
+
+      def retrieve_product(product_id)
+        Stripe::Product.retrieve(product_id)
+      end
+
+
+      def list_plans(limit)
+        Stripe::Plan.list(limit: limit)
+      end
+
+      def create_plan(params={})
+        Stripe::Plan.create create_plan_params(params)
+      end
+
       def create_plan_params(params={})
-        currency = params[:currency] || StripeMock.default_currency
         {
           :id => 'stripe_mock_default_plan_id',
-          :product => {
-            :name => 'StripeMock Default Plan ID'
-          },
-          :amount => 1337,
-          :currency => currency,
-          :interval => 'month'
+          :interval => 'month',
+          :currency => StripeMock.default_currency,
+          :product => nil, # need to override yourself to pass validations
+          :amount => 1337
         }.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)
+      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 }
         card = StripeMock::Util.card_merge(card_data, card_params)
@@ -40,6 +81,7 @@ module StripeMock
         stripe_token.id
       end
 
+
       def create_coupon_params(params = {})
         currency = params[:currency] || StripeMock.default_currency
         {
@@ -64,18 +106,36 @@ 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.all
+        coupons = Stripe::Coupon.list
         coupons.data.map(&:delete) if coupons.data.count > 0
       end
 
       def prepare_card_error
         StripeMock.prepare_card_error(:card_error, :new_customer) if StripeMock.state == 'local'
       end
+
     end
   end
 end

data/lib/stripe_mock/test_strategies/live.rb

@@ -2,6 +2,21 @@ module StripeMock
   module TestStrategies
     class Live < Base
 
+      def create_product(params={})
+        params = create_product_params(params)
+        raise "create_product requires an :id" if params[:id].nil?
+        delete_product(params[:id])
+        Stripe::Product.create params
+      end
+
+      def delete_product(product_id)
+        product = Stripe::Product.retrieve(product_id)
+        Stripe::Plan.list(product: product_id).each(&:delete) if product.type == 'service'
+        product.delete
+      rescue Stripe::StripeError => e
+        # do nothing
+      end
+
       def create_plan(params={})
         raise "create_plan requires an :id" if params[:id].nil?
         delete_plan(params[:id])
@@ -9,12 +24,10 @@ module StripeMock
       end
 
       def delete_plan(plan_id)
-        begin
-          plan = Stripe::Plan.retrieve(plan_id)
-          plan.delete
-        rescue Stripe::StripeError => e
-          # Do nothing; we just want to make sure this plan ceases to exists
-        end
+        plan = Stripe::Plan.retrieve(plan_id)
+        plan.delete
+      rescue Stripe::StripeError => e
+        # do nothing
       end
 
       def create_coupon(params={})
@@ -23,12 +36,10 @@ module StripeMock
       end
 
       def delete_coupon(id)
-        begin
-          coupon = Stripe::Coupon.retrieve(id)
-          coupon.delete
-        rescue Stripe::StripeError
-          # do nothing
-        end
+        coupon = Stripe::Coupon.retrieve(id)
+        coupon.delete
+      rescue Stripe::StripeError
+        # do nothing
       end
 
       def upsert_stripe_object(object, attributes)

data/lib/stripe_mock/test_strategies/mock.rb

@@ -2,8 +2,12 @@ module StripeMock
   module TestStrategies
     class Mock < Base
 
-      def create_plan(params={})
-        Stripe::Plan.create create_plan_params(params)
+      def delete_product(product_id)
+        if StripeMock.state == 'remote'
+          StripeMock.client.destroy_resource('products', product_id)
+        elsif StripeMock.state == 'local'
+          StripeMock.instance.products.delete(product_id)
+        end
       end
 
       def delete_plan(plan_id)

data/lib/stripe_mock/version.rb

@@ -1,4 +1,4 @@
 module StripeMock
   # stripe-ruby-mock version
-  VERSION = "2.5.6"
+  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"
     }