stripe-ruby-mock 3.1.0.rc2 → 3.1.0

data/spec/shared_stripe_examples/payment_method_examples.rb

@@ -25,6 +25,12 @@ shared_examples 'PaymentMethod API' do
       cvc: 999
     }
   end
+  let(:visa_card_details) do
+    card_details
+  end
+  let(:mastercard_card_details) do
+    card_details.merge(:number => 5555_5555_5555_4444)
+  end
   let(:sepa_debit_details) do
     {
       iban: 'DE89370400440532013000'
@@ -385,6 +391,7 @@ shared_examples 'PaymentMethod API' do
           .from(original_card_exp_month).to(new_card_exp_month)
       end
 
+
       context 'without a customer' do
         it 'raises invalid requestion exception' do
           expect do
@@ -394,29 +401,39 @@ shared_examples 'PaymentMethod API' do
       end
     end
 
+    context 'with visa card' do
+      let(:payment_method) do
+        Stripe::PaymentMethod.create(type: 'card', card: visa_card_details)
+      end
+
+      it 'uses correct brand' do
+        expect(payment_method.card.brand).to eq('visa')
+      end
+    end
+
+    context 'with mastercard card' do
+      let(:payment_method) do
+        Stripe::PaymentMethod.create(type: 'card', card: mastercard_card_details)
+      end
+
+      it 'uses correct brand' do
+        expect(payment_method.card.brand).to eq('mastercard')
+      end
+    end
+
     context 'with ideal' do
       let(:payment_method) do
         Stripe::PaymentMethod.create(type: 'ideal', ideal: ideal_details)
       end
 
-      it 'updates the ideal for the payment method' do
+      it 'cannot update' do
         Stripe::PaymentMethod.attach(payment_method.id, customer: customer.id)
 
-        original_ideal_bank = payment_method.ideal.bank
         new_ideal_bank = 12
 
         expect do
           Stripe::PaymentMethod.update(payment_method.id, ideal: { bank: new_ideal_bank })
-        end.to change { Stripe::PaymentMethod.retrieve(payment_method.id).ideal.bank }
-          .from(original_ideal_bank).to(new_ideal_bank)
-      end
-
-      context 'without a customer' do
-        it 'raises invalid requestion exception' do
-          expect do
-            Stripe::PaymentMethod.update(payment_method.id, ideal: { bank: 12 })
-          end.to raise_error(Stripe::InvalidRequestError)
-        end
+        end.to raise_error(Stripe::InvalidRequestError)
       end
     end
 
@@ -425,24 +442,12 @@ shared_examples 'PaymentMethod API' do
         Stripe::PaymentMethod.create(type: 'sepa_debit', sepa_debit: sepa_debit_details)
       end
 
-      it 'updates the sepa_debit for the payment method' do
+      it 'cannot update' do
         Stripe::PaymentMethod.attach(payment_method.id, customer: customer.id)
 
-        original_iban = payment_method.sepa_debit.iban
-        new_iban = 'DE62370400440532013001'
-
         expect do
-          Stripe::PaymentMethod.update(payment_method.id, sepa_debit: { iban: new_iban })
-        end.to change { Stripe::PaymentMethod.retrieve(payment_method.id).sepa_debit.iban }
-          .from(original_iban).to(new_iban)
-      end
-
-      context 'without a customer' do
-        it 'raises invalid requestion exception' do
-          expect do
-            Stripe::PaymentMethod.update(payment_method.id, sepa_debit: { iban: 'DE62370400440532013001' })
-          end.to raise_error(Stripe::InvalidRequestError)
-        end
+          Stripe::PaymentMethod.update(payment_method.id, sepa_debit: { iban: 'DE62370400440532013001'})
+        end.to raise_error(Stripe::InvalidRequestError)
       end
     end
   end

data/spec/shared_stripe_examples/price_examples.rb

@@ -1,8 +1,11 @@
 require 'spec_helper'
 
 shared_examples 'Price API' do
-  let(:product) { stripe_helper.create_product }
-  let(:product_id) { product.id }
+  let(:product_id) { "product_id_1" }
+  let(:product) { stripe_helper.create_product(id: product_id) }
+
+  let(:other_product_id) { "product_id_2" }
+  let(:other_product) { stripe_helper.create_product(id: other_product_id) }
 
   let(:price_attributes) { {
     :id => "price_abc123",
@@ -26,6 +29,7 @@ shared_examples 'Price API' do
 
   before(:each) do
     product
+    other_product
   end
 
   it "creates a stripe price" do
@@ -125,6 +129,42 @@ shared_examples 'Price API' do
     expect(two.map &:amount).to include(98765)
   end
 
+  it "retrieves prices filtering by currency" do
+    5.times do | i|
+      stripe_helper.create_price(id: "usd price #{i}", product: product_id, amount: 11, currency: 'usd')
+      stripe_helper.create_price(id: "brl price #{i}", product: product_id, amount: 11, currency: 'brl')
+    end
+
+    all = Stripe::Price.list()
+    expect(all.count).to eq(10)
+
+    usd = Stripe::Price.list({currency: 'usd'})
+    expect(usd.count).to eq(5)
+    expect(usd.all? {|p| p.currency == 'usd' }).to be_truthy
+
+    brl = Stripe::Price.list({currency: 'brl'})
+    expect(brl.count).to eq(5)
+    expect(brl.all? {|p| p.currency == 'brl' }).to be_truthy
+  end
+
+  it "retrieves prices filtering by product" do
+    5.times do | i|
+      stripe_helper.create_price(id: "product 1 price #{i}", product: product_id)
+      stripe_helper.create_price(id: "product 2 price #{i}", product: other_product_id)
+    end
+
+    all = Stripe::Price.list()
+    expect(all.count).to eq(10)
+
+    product_prices = Stripe::Price.list({product: product.id})
+    expect(product_prices.count).to eq(5)
+    expect(product_prices.all? {|p| p.product == product.id }).to be_truthy
+
+    other_product_prices = Stripe::Price.list({product: other_product.id})
+    expect(other_product_prices.count).to eq(5)
+    expect(other_product_prices.all? {|p| p.product == other_product.id }).to be_truthy
+  end
+
   describe "Validations", :live => true do
     include_context "stripe validator"
     let(:params) { stripe_helper.create_price_params(product: product_id) }

data/spec/shared_stripe_examples/product_examples.rb

@@ -1,7 +1,7 @@
 require "spec_helper"
 
 shared_examples "Product API" do
-  let(:product_attributes) { {id: "prod_123", name: "My Mock Product", type: "service"} }
+  let(:product_attributes) { {id: "prod_123", name: "My Mock Product"} }
   let(:product) { Stripe::Product.create(product_attributes) }
 
   it "creates a stripe product" do
@@ -101,14 +101,6 @@ shared_examples "Product API" do
       it("requires a name") { @attribute_name = :name }
     end
 
-    describe "Inclusion" do
-      it "validates inclusion of type in 'good' or 'service'" do
-        expect {
-          Stripe::Product.create(params.merge({type: "OOPS"}))
-        }.to raise_error(Stripe::InvalidRequestError, "Invalid type: must be one of good or service")
-      end
-    end
-
     describe "Uniqueness" do
       let(:already_exists_message){ stripe_validator.already_exists_message(Stripe::Product) }
 

data/spec/shared_stripe_examples/promotion_code_examples.rb

@@ -0,0 +1,68 @@
+require "spec_helper"
+
+shared_examples "PromotionCode API" do
+  let(:coupon) { stripe_helper.create_coupon }
+
+  it "creates a promotion code" do
+    promotion_code = Stripe::PromotionCode.create({id: "promo_123", coupon: coupon.id, code: "FREESTUFF"})
+
+    expect(promotion_code.id).to eq("promo_123")
+    expect(promotion_code.code).to eq("FREESTUFF")
+    expect(promotion_code.coupon).to eq(coupon.id)
+  end
+
+  it "creates a promotion code without specifying code" do
+    promotion_code = Stripe::PromotionCode.create({id: "promo_123", coupon: coupon.id})
+
+    expect(promotion_code.id).to eq("promo_123")
+    expect(promotion_code.code).to eq("TESTCODE")
+    expect(promotion_code.coupon).to eq(coupon.id)
+  end
+
+  it "cannot create a promotion code without a coupon" do
+    expect {
+      Stripe::PromotionCode.create
+    }.to raise_error { |e|
+      expect(e).to be_a(Stripe::InvalidRequestError)
+      expect(e.message).to eq("Missing required param: coupon")
+    }
+  end
+
+  it "requires minimum amount currency when minimum amount is provided" do
+    expect {
+      Stripe::PromotionCode.create(coupon: coupon, restrictions: {minimum_amount: 100})
+    }.to raise_error { |e|
+      expect(e).to be_a(Stripe::InvalidRequestError)
+      expect(e.message).to eq("You must pass minimum_amount_currency when passing minimum_amount")
+    }
+  end
+
+  it "updates a promotion code" do
+    promotion_code = Stripe::PromotionCode.create({coupon: coupon.id})
+    expect(promotion_code.active).to eq(true)
+
+    updated = Stripe::PromotionCode.update(promotion_code.id, active: false)
+
+    expect(updated.active).to eq(false)
+  end
+
+  it "retrieves a promotion code" do
+    original = Stripe::PromotionCode.create({coupon: coupon.id})
+
+    promotion_code = Stripe::PromotionCode.retrieve(original.id)
+
+    expect(promotion_code.id).to eq(original.id)
+    expect(promotion_code.code).to eq(original.code)
+    expect(promotion_code.coupon).to eq(original.coupon)
+  end
+
+  it "lists all promotion codes" do
+    Stripe::PromotionCode.create({coupon: coupon.id, code: "10PERCENT"})
+    Stripe::PromotionCode.create({coupon: coupon.id, code: "20PERCENT"})
+
+    all = Stripe::PromotionCode.list
+
+    expect(all.count).to eq(2)
+    expect(all.map(&:code)).to include("10PERCENT", "20PERCENT")
+  end
+end

data/spec/shared_stripe_examples/refund_examples.rb

@@ -22,6 +22,19 @@ shared_examples 'Refund API' do
       expect(charge.amount_refunded).to eq(999)
     end
 
+    it "refunds a stripe payment intent" do
+      payment_intent = Stripe::PaymentIntent.create(
+        amount: 999,
+        currency: 'USD'
+      )
+
+      refund = Stripe::Refund.create(
+        payment_intent: payment_intent.id
+      )
+      expect(refund.amount).to eq(999)
+    end
+
+
     it "creates a stripe refund with a status" do
       charge = Stripe::Charge.create(
         amount: 999,

data/spec/shared_stripe_examples/setup_intent_examples.rb

@@ -10,6 +10,14 @@ shared_examples 'SetupIntent API' do
     expect(setup_intent.status).to eq('requires_payment_method')
   end
 
+  it 'creates a stripe setup intent with payment method' do
+    setup_intent = Stripe::SetupIntent.create(payment_method: 'random')
+
+    expect(setup_intent.id).to match(/^test_si/)
+    expect(setup_intent.metadata.to_hash).to eq({})
+    expect(setup_intent.status).to eq('requires_action')
+  end
+
   describe "listing setup_intent" do
     before do
       3.times do
@@ -42,6 +50,15 @@ shared_examples 'SetupIntent API' do
     }
   end
 
+  it "expands payment_method" do
+    payment_method = Stripe::PaymentMethod.create(type: "card")
+    original = Stripe::SetupIntent.create(payment_method: payment_method.id)
+
+    setup_intent = Stripe::SetupIntent.retrieve({id: original.id, expand: ["payment_method"]})
+
+    expect(setup_intent.payment_method).to eq(payment_method)
+  end
+
   it "confirms a stripe setup_intent" do
     setup_intent = Stripe::SetupIntent.create()
     confirmed_setup_intent = setup_intent.confirm()

data/spec/shared_stripe_examples/subscription_examples.rb

@@ -179,6 +179,7 @@ shared_examples 'Customer Subscriptions with plans' do
       expect(subscriptions.data).to be_a(Array)
       expect(subscriptions.data.count).to eq(1)
       expect(subscriptions.data.first.discount).not_to be_nil
+      expect(subscriptions.data.first.discount.id).not_to be_nil
       expect(subscriptions.data.first.discount).to be_a(Stripe::Discount)
       expect(subscriptions.data.first.discount.coupon.id).to eq(coupon.id)
     end
@@ -195,6 +196,28 @@ shared_examples 'Customer Subscriptions with plans' do
       }
     end
 
+    it "allows promotion code" do
+      customer = Stripe::Customer.create(source: gen_card_tk)
+      coupon = stripe_helper.create_coupon
+      promotion_code = Stripe::PromotionCode.create(coupon: coupon)
+
+      expect {
+        Stripe::Subscription.create(plan: plan.id, customer: customer.id, promotion_code: promotion_code.id)
+      }.not_to raise_error(Stripe::InvalidRequestError)
+    end
+
+    it "does not permit both coupon and promotion code" do
+      customer = Stripe::Customer.create(source: gen_card_tk)
+
+      expect {
+        Stripe::Subscription.create(plan: plan.id, customer: customer.id, coupon: "test", promotion_code: "test")
+      }.to raise_error { |e|
+        expect(e).to be_a Stripe::InvalidRequestError
+        expect(e.http_status).to eq(400)
+        expect(e.message).to eq("You may only specify one of these parameters: coupon, promotion_code")
+      }
+    end
+
     it "correctly sets quantity, application_fee_percent and tax_percent" do
       customer = Stripe::Customer.create(id: 'test_customer_sub', source: gen_card_tk)
 
@@ -290,6 +313,27 @@ shared_examples 'Customer Subscriptions with plans' do
       expect(customer.subscriptions.count).to eq(0)
     end
 
+    it "creates a subscription when subscription's payment_behavior is default_incomplete" do
+      plan = stripe_helper.create_plan(id: 'enterprise', product: product.id, amount: 499)
+      customer = Stripe::Customer.create(id: 'cardless')
+
+      sub = Stripe::Subscription.create({ plan: plan.id, customer: customer.id, payment_behavior: 'default_incomplete' })
+      customer = Stripe::Customer.retrieve('cardless')
+
+      expect(customer.subscriptions.count).to eq(1)
+      expect(customer.subscriptions.data.first.id).to eq(sub.id)
+      expect(customer.subscriptions.data.first.status).to eq('incomplete')
+    end
+
+    it "allows setting transfer_data" do
+      customer = Stripe::Customer.create(id: 'test_customer_sub', source: gen_card_tk)
+
+      sub = Stripe::Subscription.create({ customer: customer.id, plan: plan.id, transfer_data: {destination: "acct_0000000000000000", amount_percent: 50} })
+
+      expect(sub.transfer_data.destination).to eq("acct_0000000000000000")
+      expect(sub.transfer_data.amount_percent).to eq(50)
+    end
+
     it "throws an error when subscribing a customer with no card" do
       plan = stripe_helper.create_plan(id: 'enterprise', product: product.id, amount: 499)
       customer = Stripe::Customer.create(id: 'cardless')
@@ -338,7 +382,7 @@ shared_examples 'Customer Subscriptions with plans' do
       expect(sub.object).to eq('subscription')
       expect(sub.plan.to_hash).to eq(plan_with_trial.to_hash)
       expect(sub.trial_end - sub.trial_start).to eq(14 * 86400)
-      expect(sub.billing_cycle_anchor).to be_nil
+      expect(sub.billing_cycle_anchor).to eq sub.trial_start
 
       customer = Stripe::Customer.retrieve(customer.id)
       subscriptions = Stripe::Subscription.list(customer: customer.id)
@@ -532,6 +576,45 @@ shared_examples 'Customer Subscriptions with plans' do
       expect(subscription.items.data[1].plan.id).to eq plan2.id
     end
 
+    it 'sets current_period_end based on price week interval', live: true do
+      price = stripe_helper.create_price(recurring: {interval: 'week'})
+
+      subscription = Stripe::Subscription.create(
+        customer: Stripe::Customer.create(source: gen_card_tk).id,
+        items: [
+          {price: price.id, quantity: 1}
+        ]
+      )
+
+      expect(subscription.current_period_end).to eq (Time.now + (7 * 60 * 60 * 24)).to_i
+    end
+
+    it 'sets current_period_end based on price month interval', live: true do
+      price = stripe_helper.create_price(recurring: {interval: 'month'})
+
+      subscription = Stripe::Subscription.create(
+        customer: Stripe::Customer.create(source: gen_card_tk).id,
+        items: [
+          {price: price.id, quantity: 1}
+        ]
+      )
+
+      expect(subscription.current_period_end).to eq (DateTime.now >> 1).to_time.to_i
+    end
+
+    it 'sets current_period_end based on price year interval', live: true do
+      price = stripe_helper.create_price(recurring: {interval: 'year'})
+
+      subscription = Stripe::Subscription.create(
+        customer: Stripe::Customer.create(source: gen_card_tk).id,
+        items: [
+          {price: price.id, quantity: 1}
+        ]
+      )
+
+      expect(subscription.current_period_end).to eq (DateTime.now >> 12).to_time.to_i
+    end
+
     it 'add a new subscription to bill via an invoice' do
       product = stripe_helper.create_product(id: 'invoice_billing')
       plan = stripe_helper.create_plan(id: 'silver', product: product.id,
@@ -633,6 +716,35 @@ shared_examples 'Customer Subscriptions with plans' do
         expect(subscription.default_tax_rates.first.id).to eq(tax_rate.id)
       end
     end
+
+    it 'expands latest_invoice.payment_intent' do
+      customer = Stripe::Customer.create(source: gen_card_tk)
+      subscription = Stripe::Subscription.create({
+        customer: customer.id,
+        plan: plan.id,
+        expand: ['latest_invoice.payment_intent']
+      })
+
+      expect(subscription.latest_invoice.payment_intent.status).to eq('succeeded')
+
+      subscription = Stripe::Subscription.create({
+        customer: customer.id,
+        plan: plan.id,
+        expand: ['latest_invoice.payment_intent'],
+        payment_behavior: 'default_incomplete'
+      })
+
+      expect(subscription.latest_invoice.payment_intent.status).to eq('requires_payment_method')
+
+      subscription = Stripe::Subscription.create({
+        customer: customer.id,
+        plan: plan.id,
+        expand: ['latest_invoice.payment_intent'],
+        trial_period_days: 14
+      })
+
+      expect(subscription.latest_invoice.payment_intent).to be_nil
+    end
   end
 
   context "updating a subscription" do
@@ -858,6 +970,23 @@ shared_examples 'Customer Subscriptions with plans' do
       expect(subscription.discount).to be_nil
     end
 
+    it "throws an error when promotion code has an amount restriction" do
+      coupon = stripe_helper.create_coupon
+      promotion_code = Stripe::PromotionCode.create(
+        coupon: coupon, restrictions: {minimum_amount: 100, minimum_amount_currency: "USD"}
+      )
+      customer = Stripe::Customer.create(source: gen_card_tk, plan: plan.id)
+      subscription = Stripe::Subscription.retrieve(customer.subscriptions.data.first.id)
+
+      subscription.promotion_code = promotion_code.id
+
+      expect { subscription.save }.to raise_error { |e|
+        expect(e).to be_a Stripe::InvalidRequestError
+        expect(e.http_status).to eq(400)
+        expect(e.message).to_not be_nil
+      }
+    end
+
     it "throws an error when plan does not exist" do
       customer = Stripe::Customer.create(id: 'cardless', plan: free_plan.id)
 
@@ -1030,6 +1159,18 @@ shared_examples 'Customer Subscriptions with plans' do
         expect(e.message).to eq("Invalid timestamp: must be an integer")
       }
     end
+
+    it "converts billing_cycle_anchor=now to a timestamp" do
+      customer = Stripe::Customer.create(id: 'test_billing_anchor', plan: plan.id, source: gen_card_tk)
+
+      sub = Stripe::Subscription.retrieve(customer.subscriptions.data.first.id)
+      sub.billing_cycle_anchor = 'now'
+      sub.save
+
+      expect(sub.billing_cycle_anchor).to be_a(Integer)
+    end
+
+
   end
 
   context "cancelling a subscription" do
@@ -1155,6 +1296,10 @@ shared_examples 'Customer Subscriptions with plans' do
       expect(subscription.items.data.first.plan.currency).to eq('usd')
       expect(subscription.items.data.first.quantity).to eq(2)
     end
+
+    it "has a start_date attribute" do
+      expect(subscription).to respond_to(:start_date)
+    end
   end
 
   context "retrieve multiple subscriptions" do
@@ -1182,6 +1327,50 @@ shared_examples 'Customer Subscriptions with plans' do
       expect(list.count).to eq(0)
       expect(list.data.length).to eq(0)
     end
+
+    it "does not include canceled subscriptions by default" do
+      customer = Stripe::Customer.create(source: gen_card_tk)
+      subscription = Stripe::Subscription.create({ plan: plan.id, customer: customer.id })
+      subscription.delete
+
+      list = Stripe::Subscription.list({customer: customer.id})
+
+      expect(list.object).to eq("list")
+      expect(list.data).to be_empty
+      expect(list.data.length).to eq(0)
+    end
+
+    it "filters out subscriptions based on their current_period", live: true do
+      price = stripe_helper.create_price(recurring: { interval: 'month' })
+      price2 = stripe_helper.create_price(recurring: { interval: 'year' })
+
+      subscription1 = Stripe::Subscription.create(
+        customer: Stripe::Customer.create(source: gen_card_tk).id,
+        items: [{ price: price.id, quantity: 1 }]
+      )
+      subscription2 = Stripe::Subscription.create(
+        customer: Stripe::Customer.create(source: gen_card_tk).id,
+        items: [{ price: price2.id, quantity: 1 }]
+      )
+
+      list = Stripe::Subscription.list({ current_period_end: { gt: subscription1.current_period_end }})
+      expect(list.data).to contain_exactly(subscription2)
+
+      list = Stripe::Subscription.list({ current_period_end: { gte: subscription1.current_period_end }})
+      expect(list.data).to contain_exactly(subscription1, subscription2)
+
+      list = Stripe::Subscription.list({ current_period_end: { lt: subscription1.current_period_end }})
+      expect(list.data).to be_empty
+
+      list = Stripe::Subscription.list({ current_period_end: { lte: subscription1.current_period_end }})
+      expect(list.data).to contain_exactly(subscription1)
+
+      list = Stripe::Subscription.list({ current_period_start: subscription1.current_period_start })
+      expect(list.data).to contain_exactly(subscription1, subscription2)
+
+      list = Stripe::Subscription.list({ current_period_end: subscription2.current_period_end })
+      expect(list.data).to contain_exactly(subscription2)
+    end
   end
 
   describe "metadata" do
@@ -1212,8 +1401,28 @@ shared_examples 'Customer Subscriptions with plans' do
       expect(customer.subscriptions.first.plan.id).to eq('Sample5')
       expect(customer.subscriptions.first.metadata['foo']).to eq('bar')
     end
-  end
 
+    it "saves subscription item metadata" do
+      stripe_helper.
+        create_plan(
+        :amount => 500,
+        :interval => 'month',
+        :product => product.id,
+        :currency => 'usd',
+        :id => 'Sample5'
+      )
+      customer = Stripe::Customer.create({
+        email: 'johnny@appleseed.com',
+        source: gen_card_tk
+      })
+
+      subscription = Stripe::Subscription.create(
+        customer: customer.id,
+        items: [{plan: "Sample5", metadata: {foo: 'bar'}}],
+      )
+      expect(subscription.items.data[0].metadata.to_h).to eq(foo: 'bar')
+    end
+  end
 end
 
 shared_examples 'Customer Subscriptions with prices' do
@@ -1237,6 +1446,7 @@ shared_examples 'Customer Subscriptions with prices' do
 
       expect(subscription.object).to eq('subscription')
       expect(subscription.plan.to_hash).to eq(price.to_hash)
+      expect(subscription.items.first.price.to_hash).to eq(price.to_hash)
       expect(subscription.metadata.foo).to eq("bar")
       expect(subscription.metadata.example).to eq("yes")
 
@@ -1252,6 +1462,7 @@ shared_examples 'Customer Subscriptions with prices' do
 
       expect(subscriptions.data.first.id).to eq(subscription.id)
       expect(subscriptions.data.first.plan.to_hash).to eq(price.to_hash)
+      expect(subscriptions.data.first.items.first.price.to_hash).to eq(price.to_hash)
       expect(subscriptions.data.first.customer).to eq(customer.id)
       expect(subscriptions.data.first.metadata.foo).to eq( "bar" )
       expect(subscriptions.data.first.metadata.example).to eq( "yes" )

data/spec/shared_stripe_examples/transfer_examples.rb

@@ -9,7 +9,7 @@ shared_examples 'Transfer API' do
     expect(transfer.id).to match /^test_tr/
     expect(transfer.amount).to eq(100)
     expect(transfer.amount_reversed).to eq(0)
-    expect(transfer.balance_transaction).to eq('txn_2dyYXXP90MN26R')
+    expect(transfer.balance_transaction).to eq('test_txn_1')
     expect(transfer.created).to eq(1304114826)
     expect(transfer.currency).to eq('usd')
     expect(transfer.description).to eq('Transfer description')
@@ -30,6 +30,15 @@ shared_examples 'Transfer API' do
     expect(transfer.transfer_group).to eq("group_ch_164xRv2eZvKYlo2Clu1sIJWB")
   end
 
+  it "creates a balance transaction" do
+    destination = Stripe::Account.create(type: "custom", email: "#{SecureRandom.uuid}@example.com", id: "acct_12345", requested_capabilities: ['card_payments', 'platform_payments'])
+    transfer = Stripe::Transfer.create(amount: 100, currency: "usd", destination: destination.id)
+
+    bal_trans = Stripe::BalanceTransaction.retrieve(transfer.balance_transaction)
+    expect(bal_trans.amount).to eq(100)
+    expect(bal_trans.source).to eq(transfer.id)
+  end
+
   describe "listing transfers" do
     let(:destination) { Stripe::Account.create(type: "custom", email: "#{SecureRandom.uuid}@example.com", business_name: "MyCo") }