stripe-ruby-mock 2.4.1 → 2.5.0

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

@@ -8,10 +8,10 @@ module StripeMock
         if card.nil?
           if class_name == 'Recipient'
             msg = "#{class_name} #{object[:id]} does not have a card with ID #{card_id}"
-            raise Stripe::InvalidRequestError.new(msg, 'card', 404)
+            raise Stripe::InvalidRequestError.new(msg, 'card', http_status: 404)
           else
             msg = "There is no source with ID #{card_id}"
-            raise Stripe::InvalidRequestError.new(msg, 'id', 404)
+            raise Stripe::InvalidRequestError.new(msg, 'id', http_status: 404)
           end
         end
         card

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

@@ -3,7 +3,12 @@ module StripeMock
     module Helpers
 
       def add_coupon_to_customer(customer, coupon)
-        customer[:discount] = { coupon: coupon }
+        customer[:discount] = {
+            coupon: coupon,
+            customer: customer[:id],
+            start: Time.now.to_i,
+        }
+        customer[:discount][:end] = (DateTime.now >> coupon[:duration_in_months]).to_time.to_i  if coupon[:duration].to_sym == :repeating && coupon[:duration_in_months]
 
         customer
       end

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

@@ -14,7 +14,7 @@ module StripeMock
         params.merge! options.select {|k,v| k =~ /application_fee_percent|quantity|metadata|tax_percent/}
         # TODO: Implement coupon logic
 
-        if (plan[:trial_period_days].nil? && options[:trial_end].nil?) || options[:trial_end] == "now"
+        if ((plan[:trial_period_days]||0) == 0 && options[:trial_end].nil?) || options[:trial_end] == "now"
           end_time = get_ending_time(start_time, plan)
           params.merge!({status: 'active', current_period_end: end_time, trial_start: nil, trial_end: nil})
         else
@@ -34,7 +34,7 @@ module StripeMock
         if cus[:currency].nil?
           cus[:currency] = sub[:plan][:currency]
         elsif cus[:currency] != sub[:plan][:currency]
-          raise Stripe::InvalidRequestError.new( "Can't combine currencies on a single customer. This customer has had a subscription, coupon, or invoice item with currency #{cus[:currency]}", 'currency', 400)
+          raise Stripe::InvalidRequestError.new( "Can't combine currencies on a single customer. This customer has had a subscription, coupon, or invoice item with currency #{cus[:currency]}", 'currency', http_status: 400)
         end
         cus[:subscriptions][:total_count] = (cus[:subscriptions][:total_count] || 0) + 1
         cus[:subscriptions][:data].unshift sub
@@ -65,11 +65,11 @@ module StripeMock
       def verify_trial_end(trial_end)
         if trial_end != "now"
           if !trial_end.is_a? Integer
-            raise Stripe::InvalidRequestError.new('Invalid timestamp: must be an integer', nil, 400)
+            raise Stripe::InvalidRequestError.new('Invalid timestamp: must be an integer', nil, http_status: 400)
           elsif trial_end < Time.now.utc.to_i
-            raise Stripe::InvalidRequestError.new('Invalid timestamp: must be an integer Unix timestamp in the future', nil, 400)
+            raise Stripe::InvalidRequestError.new('Invalid timestamp: must be an integer Unix timestamp in the future', nil, http_status: 400)
           elsif trial_end > Time.now.utc.to_i + 31557600*5 # five years
-            raise Stripe::InvalidRequestError.new('Invalid timestamp: can be no more than five years in the future', nil, 400)
+            raise Stripe::InvalidRequestError.new('Invalid timestamp: can be no more than five years in the future', nil, http_status: 400)
           end
         end
       end

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

@@ -28,7 +28,7 @@ module StripeMock
         if token.nil? || @card_tokens[token].nil?
           # TODO: Make this strict
           msg = "Invalid token id: #{token}"
-          raise Stripe::InvalidRequestError.new(msg, 'tok', 404)
+          raise Stripe::InvalidRequestError.new(msg, 'tok', http_status: 404)
         else
           @card_tokens.delete(token)
         end
@@ -36,7 +36,7 @@ module StripeMock
 
       def get_card_or_bank_by_token(token)
         token_id = token['id'] || token
-         @card_tokens[token_id] || @bank_tokens[token_id] || raise(Stripe::InvalidRequestError.new("Invalid token id: #{token_id}", 'tok', 404))
+         @card_tokens[token_id] || @bank_tokens[token_id] || raise(Stripe::InvalidRequestError.new("Invalid token id: #{token_id}", 'tok', http_status: 404))
       end
 
     end

data/lib/stripe_mock/request_handlers/invoices.rb

@@ -58,24 +58,76 @@ module StripeMock
 
       def upcoming_invoice(route, method_url, params, headers)
         route =~ method_url
-        raise Stripe::InvalidRequestError.new('Missing required param: customer', nil, 400) if params[:customer].nil?
+        raise Stripe::InvalidRequestError.new('Missing required param: customer', nil, http_status: 400) if params[:customer].nil?
+        raise Stripe::InvalidRequestError.new('When previewing changes to a subscription, you must specify either `subscription` or `subscription_items`', nil, http_status: 400) if !params[:subscription_proration_date].nil? && params[:subscription].nil? && params[:subscription_plan].nil?
+        raise Stripe::InvalidRequestError.new('Cannot specify proration date without specifying a subscription', nil, http_status: 400) if !params[:subscription_proration_date].nil? && params[:subscription].nil?
 
         customer = customers[params[:customer]]
         assert_existence :customer, params[:customer], customer
 
-        raise Stripe::InvalidRequestError.new("No upcoming invoices for customer: #{customer[:id]}", nil, 404) if customer[:subscriptions][:data].length == 0
+        raise Stripe::InvalidRequestError.new("No upcoming invoices for customer: #{customer[:id]}", nil, http_status: 404) if customer[:subscriptions][:data].length == 0
+
+        subscription =
+          if params[:subscription]
+            customer[:subscriptions][:data].select{|s|s[:id] == params[:subscription]}.first
+          else
+            customer[:subscriptions][:data].min_by { |sub| sub[:current_period_end] }
+          end
+        
+        if params[:subscription_proration_date] && !((subscription[:current_period_start]..subscription[:current_period_end]) === params[:subscription_proration_date])
+          raise Stripe::InvalidRequestError.new('Cannot specify proration date outside of current subscription period', nil, http_status: 400)
+        end
+
+        prorating = false
+        subscription_proration_date = nil
+        subscription_plan_id = params[:subscription_plan] || subscription[:plan][:id]
+        subscription_quantity = params[:subscription_quantity] || subscription[:quantity]
+        if subscription_plan_id != subscription[:plan][:id] || subscription_quantity != subscription[:quantity]
+          prorating = true
+          invoice_date = Time.now.to_i
+          subscription_plan = assert_existence :plan, subscription_plan_id, plans[subscription_plan_id.to_s]
+          preview_subscription = Data.mock_subscription
+          preview_subscription.merge!(custom_subscription_params(subscription_plan, customer, { trial_end: params[:subscription_trial_end] }))
+          preview_subscription[:id] = subscription[:id]
+          preview_subscription[:quantity] = subscription_quantity
+          subscription_proration_date = params[:subscription_proration_date] || Time.now
+        else
+          preview_subscription = subscription
+          invoice_date = subscription[:current_period_end]
+        end
+
+        invoice_lines = []
+
+        if prorating
+          unused_amount = subscription[:plan][:amount] * subscription[:quantity] * (subscription[:current_period_end] - subscription_proration_date.to_i) / (subscription[:current_period_end] - subscription[:current_period_start])
+          invoice_lines << Data.mock_line_item(
+                                   id: new_id('ii'),
+                                   amount: -unused_amount,
+                                   description: 'Unused time',
+                                   plan: subscription[:plan],
+                                   period: {
+                                       start: subscription_proration_date.to_i,
+                                       end: subscription[:current_period_end]
+                                   },
+                                   quantity: subscription[:quantity],
+                                   proration: true
+          )
+        end
 
-        most_recent = customer[:subscriptions][:data].min_by { |sub| sub[:current_period_end] }
-        invoice_item = get_mock_subscription_line_item(most_recent)
+        subscription_line = get_mock_subscription_line_item(preview_subscription)
+        invoice_lines << subscription_line
 
         id = new_id('in')
-        invoices[id] = Data.mock_invoice([invoice_item],
+        invoices[id] = Data.mock_invoice(invoice_lines,
           id: id,
           customer: customer[:id],
-          subscription: most_recent[:id],
-          period_start: most_recent[:current_period_start],
-          period_end: most_recent[:current_period_end],
-          next_payment_attempt: most_recent[:current_period_end] + 3600 )
+          discount: customer[:discount],
+          date: invoice_date,
+          starting_balance: customer[:account_balance],
+          subscription: preview_subscription[:id],
+          period_start: prorating ? invoice_date : preview_subscription[:current_period_start],
+          period_end: prorating ? invoice_date : preview_subscription[:current_period_end],
+          next_payment_attempt: preview_subscription[:current_period_end] + 3600 )
       end
 
       private
@@ -85,9 +137,9 @@ module StripeMock
           id: subscription[:id],
           type: "subscription",
           plan: subscription[:plan],
-          amount: subscription[:plan][:amount],
+          amount: subscription[:status] == 'trialing' ? 0 : subscription[:plan][:amount] * subscription[:quantity],
           discountable: true,
-          quantity: 1,
+          quantity: subscription[:quantity],
           period: {
             start: subscription[:current_period_end],
             end: get_ending_time(subscription[:current_period_start], subscription[:plan], 2)

data/lib/stripe_mock/request_handlers/orders.rb

@@ -15,16 +15,16 @@ module StripeMock
         order_items = []
 
         unless params[:currency].to_s.size == 3
-          raise Stripe::InvalidRequestError.new('You must supply a currency', nil, 400)
+          raise Stripe::InvalidRequestError.new('You must supply a currency', nil, http_status: 400)
         end
 
         if params[:items]
           unless params[:items].is_a? Array
-            raise Stripe::InvalidRequestError.new('You must supply a list of items', nil, 400)
+            raise Stripe::InvalidRequestError.new('You must supply a list of items', nil, http_status: 400)
           end
 
           unless params[:items].first.is_a? Hash
-            raise Stripe::InvalidRequestError.new('You must supply an item', nil, 400)
+            raise Stripe::InvalidRequestError.new('You must supply an item', nil, http_status: 400)
           end
         end
 
@@ -61,7 +61,7 @@ module StripeMock
         order = assert_existence :order, $1, orders[$1]
 
         if params[:source].blank? && params[:customer].blank?
-          raise Stripe::InvalidRequestError.new('You must supply a source or customer', nil, 400)
+          raise Stripe::InvalidRequestError.new('You must supply a source or customer', nil, http_status: 400)
         end
 
         charge_id = new_id('ch')

data/lib/stripe_mock/request_handlers/refunds.rb

@@ -47,7 +47,7 @@ module StripeMock
         allowed = allowed_refund_params(params)
         disallowed = params.keys - allowed
         if disallowed.count > 0
-          raise Stripe::InvalidRequestError.new("Received unknown parameters: #{disallowed.join(', ')}" , '', 400)
+          raise Stripe::InvalidRequestError.new("Received unknown parameters: #{disallowed.join(', ')}" , '', http_status: 400)
         end
 
         refunds[id] = Util.rmerge(refund, params)
@@ -72,9 +72,9 @@ module StripeMock
 
       def ensure_refund_required_params(params)
         if non_integer_charge_amount?(params)
-          raise Stripe::InvalidRequestError.new("Invalid integer: #{params[:amount]}", 'amount', 400)
+          raise Stripe::InvalidRequestError.new("Invalid integer: #{params[:amount]}", 'amount', http_status: 400)
         elsif non_positive_charge_amount?(params)
-          raise Stripe::InvalidRequestError.new('Invalid positive integer', 'amount', 400)
+          raise Stripe::InvalidRequestError.new('Invalid positive integer', 'amount', http_status: 400)
         elsif params[:charge].nil?
           raise Stripe::InvalidRequestError.new('Must provide the identifier of the charge to refund.', nil)
         end

data/lib/stripe_mock/request_handlers/subscriptions.rb

@@ -63,7 +63,7 @@ module StripeMock
           if coupon
             subscription[:discount] = Stripe::Util.convert_to_stripe_object({ coupon: coupon }, {})
           else
-            raise Stripe::InvalidRequestError.new("No such coupon: #{coupon_id}", 'coupon', 400)
+            raise Stripe::InvalidRequestError.new("No such coupon: #{coupon_id}", 'coupon', http_status: 400)
           end
         end
 
@@ -89,10 +89,10 @@ 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)
+        allowed_params = %w(customer application_fee_percent coupon items metadata plan quantity source tax_percent trial_end trial_period_days current_period_start)
         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, 400)
+          raise Stripe::InvalidRequestError.new("Received unknown parameter: #{unknown_params.join}", unknown_params.first.to_s, http_status: 400)
         end
 
         subscription = Data.mock_subscription({ id: (params[:id] || new_id('su')) })
@@ -112,7 +112,7 @@ module StripeMock
           if coupon
             subscription[:discount] = Stripe::Util.convert_to_stripe_object({ coupon: coupon }, {})
           else
-            raise Stripe::InvalidRequestError.new("No such coupon: #{coupon_id}", 'coupon', 400)
+            raise Stripe::InvalidRequestError.new("No such coupon: #{coupon_id}", 'coupon', http_status: 400)
           end
         end
 
@@ -170,7 +170,7 @@ module StripeMock
           elsif coupon_id == ""
             subscription[:discount] = Stripe::Util.convert_to_stripe_object(nil, {})
           else
-            raise Stripe::InvalidRequestError.new("No such coupon: #{coupon_id}", 'coupon', 400)
+            raise Stripe::InvalidRequestError.new("No such coupon: #{coupon_id}", 'coupon', http_status: 400)
           end
         end
 
@@ -224,8 +224,8 @@ module StripeMock
       private
 
       def verify_card_present(customer, plan, subscription, params={})
-        if customer[:default_source].nil? && customer[:trial_end].nil? && plan[:trial_period_days].nil? && plan[:amount] != 0 && plan[:trial_end].nil? && params[:trial_end].nil? && (subscription.nil? || subscription[:trial_end].nil? || subscription[:trial_end] == 'now')
-          raise Stripe::InvalidRequestError.new('You must supply a valid card xoxo', nil, 400)
+        if customer[:default_source].nil? && customer[:trial_end].nil? && (plan[:trial_period_days]||0)==0 && plan[:amount] != 0 && plan[:trial_end].nil? && params[:trial_end].nil? && (subscription.nil? || subscription[:trial_end].nil? || subscription[:trial_end] == 'now')
+          raise Stripe::InvalidRequestError.new('You must supply a valid card xoxo', nil, http_status: 400)
         end
       end
 
@@ -234,7 +234,7 @@ module StripeMock
 
         if status == 'canceled'
           message = "No such subscription: #{id}"
-          raise Stripe::InvalidRequestError.new(message, 'subscription', 404)
+          raise Stripe::InvalidRequestError.new(message, 'subscription', http_status: 404)
         end
       end
     end

data/lib/stripe_mock/request_handlers/tokens.rb

@@ -9,7 +9,7 @@ module StripeMock
 
       def create_token(route, method_url, params, headers)
         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, 400)
+          raise Stripe::InvalidRequestError.new('You must supply either a card, customer, or bank account to create a token.', nil, http_status: 400)
         end
 
         cus_id = params[:customer]

data/lib/stripe_mock/request_handlers/transfers.rb

@@ -36,7 +36,7 @@ module StripeMock
         end
 
         unless params[:amount].is_a?(Integer) || (params[:amount].is_a?(String) && /^\d+$/.match(params[:amount]))
-          raise Stripe::InvalidRequestError.new("Invalid integer: #{params[:amount]}", 'amount', 400)
+          raise Stripe::InvalidRequestError.new("Invalid integer: #{params[:amount]}", 'amount', http_status: 400)
         end
 
         transfers[id] = Data.mock_transfer(params.merge :id => id)

data/lib/stripe_mock/server.rb

@@ -23,7 +23,7 @@ module StripeMock
         {
           :error_raised => 'invalid_request',
           :error_params => [
-            e.message, e.param, e.http_status, e.http_body, e.json_body
+            e.message, e.param, { http_status: e.http_status, http_body: e.http_body, json_body: e.json_body}
           ]
         }
       end

data/lib/stripe_mock/version.rb

@@ -1,4 +1,4 @@
 module StripeMock
   # stripe-ruby-mock version
-  VERSION = "2.4.1"
+  VERSION = "2.5.0"
 end

data/spec/instance_spec.rb

@@ -17,9 +17,9 @@ describe StripeMock::Instance do
       "id" => "str_abcde",
       :name => "String Plan"
     )
-    res, api_key = StripeMock.instance.mock_request('post', '/v1/plans', 'api_key', string_params)
-    expect(res[:id]).to eq('str_abcde')
-    expect(res[:name]).to eq('String Plan')
+    res, api_key = StripeMock.instance.mock_request('post', '/v1/plans', api_key: 'api_key', params: string_params)
+    expect(res.data[:id]).to eq('str_abcde')
+    expect(res.data[:name]).to eq('String Plan')
   end
 
   it "exits gracefully on an unrecognized handler url" do
@@ -28,7 +28,7 @@ describe StripeMock::Instance do
       "name" => "PLAN"
     }
 
-    expect { res, api_key = StripeMock.instance.mock_request('post', '/v1/unrecongnized_method', 'api_key', dummy_params) }.to_not raise_error
+    expect { res, api_key = StripeMock.instance.mock_request('post', '/v1/unrecongnized_method', api_key: 'api_key', params: dummy_params) }.to_not raise_error
   end
 
   it "can toggle debug" do

data/spec/integration_examples/prepare_error_examples.rb

@@ -26,13 +26,13 @@ shared_examples 'Card Error Prep' do
       )
     rescue Stripe::CardError => e
       body = e.json_body
-      err  = body[:error]
-
       expect(body).to be_a(Hash)
-      expect(err[:type]).to eq 'card_error'
-      expect(err[:param]).to eq 'number'
-      expect(err[:code]).to eq 'invalid_number'
-      expect(err[:message]).to eq 'The card number is not a valid credit card number.'
+      error = body[:error]
+
+      expect(error[:type]).to eq 'card_error'
+      expect(error[:param]).to eq 'number'
+      expect(error[:code]).to eq 'invalid_number'
+      expect(error[:message]).to eq 'The card number is not a valid credit card number.'
     end
   end
 end

data/spec/readme_spec.rb

@@ -1,3 +1,4 @@
+require 'stripe_mock'
 
 describe 'README examples' do
   let(:stripe_helper) { StripeMock.create_test_helper }
@@ -24,6 +25,7 @@ describe 'README examples' do
       expect(e).to be_a Stripe::CardError
       expect(e.http_status).to eq(402)
       expect(e.code).to eq('card_declined')
+      expect(e.json_body[:error][:decline_code]).to eq('do_not_honor')
     }
   end
 

data/spec/server_spec.rb

@@ -52,8 +52,8 @@ describe 'StripeMock Server', :mock_server => true do
 
   it "returns a response with symbolized hash keys" do
     stripe_helper.create_plan(id: 'x')
-    response, api_key = StripeMock.redirect_to_mock_server('get', '/v1/plans/x', 'xxx')
-    response.keys.each {|k| expect(k).to be_a(Symbol) }
+    response, api_key = StripeMock.redirect_to_mock_server('get', '/v1/plans/x', api_key: 'xxx')
+    response.data.keys.each {|k| expect(k).to be_a(Symbol) }
   end
 
 

data/spec/shared_stripe_examples/card_examples.rb

@@ -21,7 +21,7 @@ shared_examples 'Card API' do
     expect(card.exp_year).to eq(2099)
   end
 
-  it 'creates/returns a card when using recipient.cards.create given a card token' do
+  it 'creates/returns a card when using recipient.cards.create given a card token', skip: 'Stripe has deprecated Recipients' do
     params = {
       id: 'test_recipient_sub',
       name: 'MyRec',
@@ -69,7 +69,7 @@ shared_examples 'Card API' do
     expect(card.exp_year).to eq(3031)
   end
 
-  it 'creates/returns a card when using recipient.cards.create given card params' do
+  it 'creates/returns a card when using recipient.cards.create given card params', skip: 'Stripe has deprecated Recipients' do
     params = {
       id: 'test_recipient_sub',
       name: 'MyRec',
@@ -192,7 +192,7 @@ shared_examples 'Card API' do
     end
   end
 
-  describe "retrieval and deletion with recipients", :live => true do
+  describe "retrieval and deletion with recipients", :live => true, skip: 'Stripe has deprecated Recipients' do
     let!(:recipient) { Stripe::Recipient.create(name: 'Test Recipient', type: 'individual') }
     let!(:card_token) { stripe_helper.generate_card_token(number: "4000056655665556") }
     let!(:card) { recipient.cards.create(card: card_token) }

data/spec/shared_stripe_examples/coupon_examples.rb

@@ -27,6 +27,12 @@ shared_examples 'Coupon API' do
                  expect(e.message).to match /duration/
              }
     end
+    it 'fails when a coupon is created without a currency when amount_off is specified' do
+      expect { Stripe::Coupon.create(id: '10OFF', duration: 'once', amount_off: 1000) }.to raise_error {|e|
+        expect(e).to be_a(Stripe::InvalidRequestError)
+        expect(e.message).to match /You must pass currency when passing amount_off/
+      }
+    end
   end
 
   context 'retrieve coupon', live: true do

data/spec/shared_stripe_examples/customer_examples.rb

@@ -215,6 +215,21 @@ shared_examples 'Customer API' do
     customer = Stripe::Customer.retrieve('test_cus_coupon')
     expect(customer.discount).to_not be_nil
     expect(customer.discount.coupon).to_not be_nil
+    expect(customer.discount.customer).to eq customer.id
+    expect(customer.discount.start).to be_within(1).of Time.now.to_i
+  end
+
+  describe 'repeating coupon with duration limit', live: true do
+    let!(:coupon) { Stripe::Coupon.create(id: '10OFF', amount_off: 1000, currency: 'usd', duration: 'repeating', duration_in_months: 12) }
+    let!(:customer) { Stripe::Customer.create(coupon: '10OFF') }
+    it 'creates the discount with the end date', live: true do
+      discount = Stripe::Customer.retrieve(customer.id).discount
+      expect(discount).to_not be_nil
+      expect(discount.coupon).to_not be_nil
+      expect(discount.end).to be_within(1).of (Time.now + 365 * 24 * 3600).to_i
+    end
+    after { Stripe::Coupon.retrieve(coupon.id).delete }
+    after { Stripe::Customer.retrieve(customer.id).delete }
   end
 
   it 'cannot create a customer with a coupon that does not exist' do
@@ -253,10 +268,23 @@ shared_examples 'Customer API' do
     expect(customer.id).to eq(original.id)
     expect(customer.email).to eq(original.email)
     expect(customer.default_source).to eq(original.default_source)
+    expect(customer.default_source).not_to be_a(Stripe::Card)
     expect(customer.subscriptions.count).to eq(0)
     expect(customer.subscriptions.data).to be_empty
   end
 
+  it "can expand default_source" do
+    original = Stripe::Customer.create({
+      email: 'johnny@appleseed.com',
+      source: gen_card_tk
+    })
+    customer = Stripe::Customer.retrieve(
+      id: original.id,
+      expand: ['default_source']
+    )
+    expect(customer.default_source).to be_a(Stripe::Card)
+  end
+
   it "cannot retrieve a customer that doesn't exist" do
     expect { Stripe::Customer.retrieve('nope') }.to raise_error {|e|
       expect(e).to be_a Stripe::InvalidRequestError
@@ -378,7 +406,7 @@ shared_examples 'Customer API' do
     customer = customer.delete
     expect(customer.deleted).to eq(true)
   end
-  
+
   it 'works with the update_subscription method' do
     stripe_helper.create_plan(id: 'silver')
     cus   = Stripe::Customer.create(source: gen_card_tk)
@@ -386,7 +414,7 @@ shared_examples 'Customer API' do
       cus.update_subscription(plan: 'silver')
     }.not_to raise_error
   end
-  
+
   it "deletes a stripe customer discount" do
     original = Stripe::Customer.create(id: 'test_customer_update')
 
@@ -395,7 +423,7 @@ shared_examples 'Customer API' do
     original.save
 
     expect(original.discount.coupon).to be_a Stripe::Coupon
-    
+
     original.delete_discount
 
     customer = Stripe::Customer.retrieve("test_customer_update")