stripe-ruby-mock 2.3.1 → 2.5.8

data/spec/shared_stripe_examples/balance_transaction_examples.rb

@@ -2,6 +2,8 @@ require 'spec_helper'
 
 shared_examples 'Balance Transaction API' do
 
+  let(:stripe_helper) { StripeMock.create_test_helper }
+
   it "returns an error if balance transaction does not exist" do
     txn_id = 'txn_xxxxxxxxxxxxxxxxxxxxxxxx'
 
@@ -32,4 +34,30 @@ shared_examples 'Balance Transaction API' do
 
   end
 
+  it 'retrieves balance transactions for an automated transfer' do
+    transfer_id = Stripe::Transfer.create({ amount: 2730, currency: "usd" })
+
+    # verify transfer currently has no balance transactions
+    transfer_transactions = Stripe::BalanceTransaction.all({transfer: transfer_id})
+    expect(transfer_transactions.count).to eq(0)
+
+    # verify we can create a new balance transaction associated with the transfer
+    new_txn_id = stripe_helper.upsert_stripe_object(:balance_transaction, {amount: 12300, transfer: transfer_id})
+    new_txn = Stripe::BalanceTransaction.retrieve(new_txn_id)
+    expect(new_txn).to be_a(Stripe::BalanceTransaction)
+    expect(new_txn.amount).to eq(12300)
+    # although transfer was specified as an attribute on the balance_transaction, it should not be returned in the object
+    expect{new_txn.transfer}.to raise_error(NoMethodError)
+
+    # verify we can update an existing balance transaction to associate with the transfer
+    existing_txn_id = 'txn_05RsQX2eZvKYlo2C0FRTGSSA'
+    existing_txn = Stripe::BalanceTransaction.retrieve(existing_txn_id)
+    stripe_helper.upsert_stripe_object(:balance_transaction, {id: existing_txn_id, transfer: transfer_id})
+
+    # now verify that only these balance transactions are retrieved with the transfer
+    transfer_transactions = Stripe::BalanceTransaction.all({transfer: transfer_id})
+    expect(transfer_transactions.count).to eq(2)
+    expect(transfer_transactions.map &:id).to include(new_txn_id, existing_txn_id)
+  end
+
 end

data/spec/shared_stripe_examples/bank_examples.rb

@@ -40,7 +40,7 @@ shared_examples 'Bank API' do
     expect(bank.last4).to eq("6789")
   end
 
-  it "creates a single bank with a generated bank token", :live => true do
+  it "creates a single bank with a generated bank token" do
     customer = Stripe::Customer.create
     expect(customer.sources.count).to eq 0
 
@@ -199,4 +199,31 @@ shared_examples 'Bank API' do
     end
   end
 
+  describe 'Stripe::Token creation from bank account' do
+    it 'generates token from bank account informations' do
+      token = Stripe::Token.create({
+        bank_account: {
+          account_number: "4222222222222222",
+          routing_number: "123456",
+          bank_name: "Fake bank"
+        }
+      })
+
+      cus = Stripe::Customer.create(source: token.id)
+      bank_account = cus.sources.data.first
+      expect(bank_account.bank_name).to eq('Fake bank')
+    end
+
+    it 'generates token from existing bank account token' do
+      bank_token = StripeMock.generate_bank_token(bank_name: 'Fake bank')
+      cus = Stripe::Customer.create(source: bank_token)
+      token = Stripe::Token.create({ customer: cus.id, bank_account: cus.sources.first.id })
+      cus.sources.create(source: token.id)
+      cus = Stripe::Customer.retrieve(cus.id)
+      expect(cus.sources.data.count).to eq 2
+      cus.sources.data.each do |source|
+        expect(source.bank_name).to eq('Fake bank')
+      end
+    end
+  end
 end

data/spec/shared_stripe_examples/card_examples.rb

@@ -21,8 +21,14 @@ 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
-    recipient = Stripe::Recipient.create(id: 'test_recipient_sub')
+  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',
+      type: 'individual'
+    }
+
+    recipient = Stripe::Recipient.create(params)
     card_token = stripe_helper.generate_card_token(last4: "1123", exp_month: 11, exp_year: 2099)
     card = recipient.cards.create(card: card_token)
 
@@ -63,8 +69,13 @@ 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
-    recipient = Stripe::Recipient.create(id: 'test_recipient_sub')
+  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',
+      type: 'individual'
+    }
+    recipient = Stripe::Recipient.create(params)
     card = recipient.cards.create(card: {
       number: '4000056655665556',
       exp_month: '11',
@@ -155,6 +166,13 @@ shared_examples 'Card API' do
       expect(retrieved_cus.default_source).to be_nil
     end
 
+    it 'updates total_count if deleted' do
+      card.delete
+      sources = Stripe::Customer.retrieve(customer.id).sources
+
+      expect(sources.total_count).to eq 0
+    end
+
     context "deletion when the user has two cards" do
       let!(:card_token_2) { stripe_helper.generate_card_token(last4: "1123", exp_month: 11, exp_year: 2099) }
       let!(:card_2) { customer.sources.create(source: card_token_2) }
@@ -174,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/card_token_examples.rb

@@ -12,6 +12,7 @@ shared_examples 'Card Token Mocking' do
       expect(card.last4).to eq("4242")
       expect(card.exp_month).to eq(4)
       expect(card.exp_year).to eq(2016)
+      expect(card.tokenization_method).to eq(nil)
     end
 
     it "generates and reads a card token for create charge" do

data/spec/shared_stripe_examples/charge_examples.rb

@@ -12,11 +12,20 @@ shared_examples 'Charge API' do
     }.to raise_error(Stripe::InvalidRequestError, /token/i)
   end
 
+  it "requires a valid customer or source", :live => true do
+    expect {
+      charge = Stripe::Charge.create(
+        amount: 99,
+        currency: 'usd',
+      )
+    }.to raise_error(Stripe::InvalidRequestError, /Must provide source or customer/i)
+  end
+
   it "requires presence of amount", :live => true do
     expect {
       charge = Stripe::Charge.create(
         currency: 'usd',
-        card: stripe_helper.generate_card_token
+        source: stripe_helper.generate_card_token
       )
     }.to raise_error(Stripe::InvalidRequestError, /missing required param: amount/i)
   end
@@ -25,7 +34,7 @@ shared_examples 'Charge API' do
     expect {
       charge = Stripe::Charge.create(
         amount: 99,
-        card: stripe_helper.generate_card_token
+        source: stripe_helper.generate_card_token
       )
     }.to raise_error(Stripe::InvalidRequestError, /missing required param: currency/i)
   end
@@ -35,7 +44,7 @@ shared_examples 'Charge API' do
       charge = Stripe::Charge.create(
         amount: -99,
         currency: 'usd',
-        card: stripe_helper.generate_card_token
+        source: stripe_helper.generate_card_token
       )
     }.to raise_error(Stripe::InvalidRequestError, /invalid positive integer/i)
   end
@@ -45,7 +54,7 @@ shared_examples 'Charge API' do
       charge = Stripe::Charge.create(
         amount: 99.0,
         currency: 'usd',
-        card: stripe_helper.generate_card_token
+        source: stripe_helper.generate_card_token
       )
     }.to raise_error(Stripe::InvalidRequestError, /invalid integer/i)
   end
@@ -65,6 +74,21 @@ shared_examples 'Charge API' do
     expect(charge.status).to eq('succeeded')
   end
 
+  it "creates a stripe charge item with a bank token" do
+    charge = Stripe::Charge.create(
+      amount: 999,
+      currency: 'USD',
+      source: stripe_helper.generate_bank_token,
+      description: 'bank charge'
+    )
+
+    expect(charge.id).to match(/^test_ch/)
+    expect(charge.amount).to eq(999)
+    expect(charge.description).to eq('bank charge')
+    expect(charge.captured).to eq(true)
+    expect(charge.status).to eq('succeeded')
+  end
+
   it 'creates a stripe charge item with a customer', :live => true do
     customer = Stripe::Customer.create({
       email: 'johnny@appleseed.com',
@@ -138,6 +162,48 @@ shared_examples 'Charge API' do
     expect(data[charge2.id][:amount]).to eq(777)
   end
 
+  it "creates a balance transaction" do
+    amount = 300
+    fee = 10
+    charge = Stripe::Charge.create({
+      amount: amount,
+      currency: 'USD',
+      source: stripe_helper.generate_card_token,
+      application_fee: fee,
+    })
+    bal_trans = Stripe::BalanceTransaction.retrieve(charge.balance_transaction)
+    expect(bal_trans.amount).to eq(amount)
+    expect(bal_trans.fee).to eq(39 + fee)
+    expect(bal_trans.source).to eq(charge.id)
+    expect(bal_trans.net).to eq(amount - bal_trans.fee)
+  end
+
+  context 'when conversion rate is set' do
+    it "balance transaction stores amount converted from charge currency to USD" do
+      StripeMock.set_conversion_rate(1.2)
+
+      charge = Stripe::Charge.create({
+        amount: 300,
+        currency: 'CAD',
+        source: stripe_helper.generate_card_token
+      })
+      bal_trans = Stripe::BalanceTransaction.retrieve(charge.balance_transaction)
+      expect(bal_trans.amount).to eq(charge.amount * 1.2)
+      expect(bal_trans.fee).to eq(39)
+      expect(bal_trans.currency).to eq('usd')
+    end
+  end
+
+  it "can expand balance transaction when creating a charge" do
+    charge = Stripe::Charge.create({
+      amount: 300,
+      currency: 'USD',
+      source: stripe_helper.generate_card_token,
+      expand: ['balance_transaction']
+    })
+    expect(charge.balance_transaction).to be_a(Stripe::BalanceTransaction)
+  end
+
   it "retrieves a stripe charge" do
     original = Stripe::Charge.create({
       amount: 777,
@@ -150,6 +216,20 @@ shared_examples 'Charge API' do
     expect(charge.amount).to eq(original.amount)
   end
 
+  it "can expand balance transaction when retrieving a charge" do
+    original = Stripe::Charge.create({
+      amount: 300,
+      currency: 'USD',
+      source: stripe_helper.generate_card_token
+    })
+    charge = Stripe::Charge.retrieve(
+      id: original.id,
+      expand: ['balance_transaction']
+    )
+
+    expect(charge.balance_transaction).to be_a(Stripe::BalanceTransaction)
+  end
+
   it "cannot retrieve a charge that doesn't exist" do
     expect { Stripe::Charge.retrieve('nope') }.to raise_error {|e|
       expect(e).to be_a Stripe::InvalidRequestError
@@ -181,6 +261,23 @@ shared_examples 'Charge API' do
     expect(updated.fraud_details.to_hash).to eq(charge.fraud_details.to_hash)
   end
 
+  it "updates a stripe charge with no changes" do
+    original = Stripe::Charge.create({
+      amount: 777,
+      currency: 'USD',
+      source: stripe_helper.generate_card_token,
+      description: 'Original description',
+      destination: {
+        account: "acct_SOMEBOGUSID",
+        amount: 150
+      }
+    })
+
+    expect {
+      updated = original.save
+    }.not_to raise_error
+  end
+
   it "marks a charge as safe" do
     original = Stripe::Charge.create({
       amount: 777,
@@ -237,14 +334,14 @@ shared_examples 'Charge API' do
     charge1 = Stripe::Charge.create(
       amount: 999,
       currency: 'USD',
-      card: stripe_helper.generate_card_token,
+      source: stripe_helper.generate_card_token,
       description: 'card charge'
     )
 
     charge2 = Stripe::Charge.create(
       amount: 999,
       currency: 'USD',
-      card: stripe_helper.generate_card_token,
+      source: stripe_helper.generate_card_token,
       description: 'card charge'
     )
 
@@ -254,8 +351,9 @@ shared_examples 'Charge API' do
   context "retrieving a list of charges" do
     before do
       @customer = Stripe::Customer.create(email: 'johnny@appleseed.com')
+      @customer2 = Stripe::Customer.create(email: 'johnny2@appleseed.com')
       @charge = Stripe::Charge.create(amount: 1, currency: 'usd', customer: @customer.id)
-      @charge2 = Stripe::Charge.create(amount: 1, currency: 'usd')
+      @charge2 = Stripe::Charge.create(amount: 1, currency: 'usd', customer: @customer2.id)
     end
 
     it "stores charges for a customer in memory" do
@@ -263,16 +361,17 @@ shared_examples 'Charge API' do
     end
 
     it "stores all charges in memory" do
-      expect(Stripe::Charge.all.data.map(&:id)).to eq([@charge.id, @charge2.id])
+      expect(Stripe::Charge.all.data.map(&:id).reverse).to eq([@charge.id, @charge2.id])
     end
 
     it "defaults count to 10 charges" do
-      11.times { Stripe::Charge.create(amount: 1, currency: 'usd') }
+      11.times { Stripe::Charge.create(amount: 1, currency: 'usd', source: stripe_helper.generate_card_token) }
+
       expect(Stripe::Charge.all.data.count).to eq(10)
     end
 
     it "is marked as having more when more objects exist" do
-      11.times { Stripe::Charge.create(amount: 1, currency: 'usd') }
+      11.times { Stripe::Charge.create(amount: 1, currency: 'usd', source: stripe_helper.generate_card_token) }
 
       expect(Stripe::Charge.all.has_more).to eq(true)
     end
@@ -314,7 +413,7 @@ shared_examples 'Charge API' do
       charge = Stripe::Charge.create({
         amount: 777,
         currency: 'USD',
-        card: stripe_helper.generate_card_token
+        source: stripe_helper.generate_card_token
       })
 
       expect(charge.captured).to eq(true)
@@ -324,7 +423,7 @@ shared_examples 'Charge API' do
       charge = Stripe::Charge.create({
         amount: 777,
         currency: 'USD',
-        card: stripe_helper.generate_card_token,
+        source: stripe_helper.generate_card_token,
         capture: true
       })
 
@@ -335,7 +434,7 @@ shared_examples 'Charge API' do
       charge = Stripe::Charge.create({
         amount: 777,
         currency: 'USD',
-        card: stripe_helper.generate_card_token,
+        source: stripe_helper.generate_card_token,
         capture: false
       })
 
@@ -348,7 +447,7 @@ shared_examples 'Charge API' do
       charge = Stripe::Charge.create({
         amount: 777,
         currency: 'USD',
-        card: stripe_helper.generate_card_token,
+        source: stripe_helper.generate_card_token,
         capture: false
       })
 
@@ -362,7 +461,7 @@ shared_examples 'Charge API' do
       charge = Stripe::Charge.create({
         amount: 777,
         currency: 'USD',
-        card: stripe_helper.generate_card_token,
+        source: stripe_helper.generate_card_token,
         capture: false
       })
 
@@ -376,29 +475,35 @@ shared_examples 'Charge API' do
   end
 
   describe "idempotency" do
-    let(:idempotent_charge_params) {{
+    let(:customer) { Stripe::Customer.create(email: 'johnny@appleseed.com') }
+    let(:charge_params) {{
       amount: 777,
       currency: 'USD',
-      card: stripe_helper.generate_card_token,
-      capture: true,
+      customer: customer.id,
+      capture: true
+    }}
+    let(:charge_headers) {{
       idempotency_key: 'onceisenough'
     }}
 
     it "returns the original charge if the same idempotency_key is passed in" do
-      charge1 = Stripe::Charge.create(idempotent_charge_params)
-      charge2 = Stripe::Charge.create(idempotent_charge_params)
+      charge1 = Stripe::Charge.create(charge_params, charge_headers)
+      charge2 = Stripe::Charge.create(charge_params, charge_headers)
 
       expect(charge1).to eq(charge2)
     end
 
-    it "returns different charges if different idempotency_keys are used for each charge" do
-      idempotent_charge_params2 = idempotent_charge_params.clone
-      idempotent_charge_params2[:idempotency_key] = 'thisoneisdifferent'
+    context 'different key' do
+      let(:different_charge_headers) {{
+        idempotency_key: 'thisoneisdifferent'
+      }}
 
-      charge1 = Stripe::Charge.create(idempotent_charge_params)
-      charge2 = Stripe::Charge.create(idempotent_charge_params2)
+      it "returns different charges if different idempotency_keys are used for each charge" do
+        charge1 = Stripe::Charge.create(charge_params, charge_headers)
+        charge2 = Stripe::Charge.create(charge_params, different_charge_headers)
 
-      expect(charge1).not_to eq(charge2)
+        expect(charge1).not_to eq(charge2)
+      end
     end
   end
 

data/spec/shared_stripe_examples/country_specs_examples.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+shared_examples 'Country Spec API' do
+  context 'retrieve country', live: true do
+    it 'retrieves a stripe country spec' do
+      country = Stripe::CountrySpec.retrieve('US')
+
+      expect(country).to be_a Stripe::CountrySpec
+      expect(country.id).to match /US/
+    end
+
+    it "cannot retrieve a stripe country that doesn't exist" do
+      expect { Stripe::CountrySpec.retrieve('nope') }
+          .to raise_error(Stripe::InvalidRequestError, /(nope is not currently supported by Stripe)|(Country 'nope' is unknown)/)
+
+    end
+  end
+end

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
@@ -56,7 +62,7 @@ shared_examples 'Coupon API' do
     it "cannot retrieve a stripe coupon that doesn't exist" do
       expect { Stripe::Coupon.retrieve('nope') }.to raise_error {|e|
         expect(e).to be_a Stripe::InvalidRequestError
-        expect(e.param).to eq('id')
+        expect(e.param).to eq('coupon')
         expect(e.http_status).to eq(404)
       }
     end
@@ -71,7 +77,7 @@ shared_examples 'Coupon API' do
 
       expect { Stripe::Coupon.retrieve(coupon.id) }.to raise_error {|e|
         expect(e).to be_a Stripe::InvalidRequestError
-        expect(e.param).to eq('id')
+        expect(e.param).to eq('coupon')
         expect(e.http_status).to eq(404)
       }
     end

data/spec/shared_stripe_examples/customer_examples.rb

@@ -24,6 +24,27 @@ shared_examples 'Customer API' do
     expect { customer.source }.to raise_error
   end
 
+  it "creates a stripe customer with multiple cards and updates the default card" do
+    card_a   = gen_card_tk
+    card_b   = gen_card_tk
+    customer = Stripe::Customer.create({
+      email: 'johnny.multiple@appleseed.com',
+      source: card_a,
+      description: "a description"
+    })
+
+    original_card = customer.sources.data.first.id
+
+    customer.sources.create(source: card_b)
+    retrieved_customer = Stripe::Customer.retrieve(customer.id)
+
+    expect(retrieved_customer.sources.data.length).to eq(2)
+    retrieved_customer.default_source = retrieved_customer.sources.data.last.id
+    retrieved_customer.save
+    expect(Stripe::Customer.retrieve(customer.id).default_source).to eq(retrieved_customer.sources.data.last.id)
+    expect(Stripe::Customer.retrieve(customer.id).default_source).to_not eq(original_card)
+  end
+
   it "creates a stripe customer without a card" do
     customer = Stripe::Customer.create({
       email: 'cardless@appleseed.com',
@@ -57,6 +78,15 @@ shared_examples 'Customer API' do
     expect(customer.sources.data.first.exp_year).to eq 2024
   end
 
+  it 'creates a customer with name' do
+    customer = Stripe::Customer.create(
+      source: gen_card_tk,
+      name: 'John Appleseed'
+    )
+    expect(customer.id).to match(/^test_cus/)
+    expect(customer.name).to eq('John Appleseed')
+  end
+
   it 'creates a customer with a plan' do
     plan = stripe_helper.create_plan(id: 'silver')
     customer = Stripe::Customer.create(id: 'test_cus_plan', source: gen_card_tk, :plan => 'silver')
@@ -194,6 +224,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_helper.create_coupon(id: '10OFF', amount_off: 1000, currency: 'usd', duration: 'repeating', duration_in_months: 12) }
+    let!(:customer) { Stripe::Customer.create(coupon: coupon.id) }
+    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.to_datetime >> 12).to_time.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
@@ -231,11 +276,25 @@ shared_examples 'Customer API' do
 
     expect(customer.id).to eq(original.id)
     expect(customer.email).to eq(original.email)
+    expect(customer.name).to eq(nil)
     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
@@ -344,9 +403,40 @@ shared_examples 'Customer API' do
     expect(original.subscriptions.total_count).to eq(1)
   end
 
+  it "should add a customer to a subscription" do
+    plan     = stripe_helper.create_plan(id: 'silver')
+    customer = Stripe::Customer.create(source: gen_card_tk)
+    customer.subscriptions.create(plan: plan.id)
+
+    expect(Stripe::Customer.retrieve(customer.id).subscriptions.total_count).to eq(1)
+  end
+
   it "deletes a customer" do
     customer = Stripe::Customer.create(id: 'test_customer_sub')
     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)
+    expect {
+      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')
+
+    coupon = Stripe::Coupon.create(id: "10PERCENT", duration: 'once')
+    original.coupon = coupon.id
+    original.save
+
+    expect(original.discount.coupon).to be_a Stripe::Coupon
+
+    original.delete_discount
+
+    customer = Stripe::Customer.retrieve("test_customer_update")
+    expect(customer.discount).to be nil
+  end
 end