stripe-ruby-mock 2.5.4 → 2.5.8

data/spec/shared_stripe_examples/ephemeral_key_examples.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+shared_examples 'EphemeralKey API' do
+  describe 'Create a new key' do
+    let(:customer)  { Stripe::Customer.create email: 'test@example.com' }
+    let(:version) { '2016-07-06' }
+
+    it 'creates a new key' do
+      key = Stripe::EphemeralKey.create(
+        { customer: customer.id },
+        { stripe_version: version }
+      )
+
+      expect(key[:associated_objects][0][:id]).to eq customer.id
+    end
+  end
+end

data/spec/shared_stripe_examples/invoice_examples.rb

@@ -52,7 +52,7 @@ shared_examples 'Invoice API' do
     end
 
     it "stores all invoices in memory" do
-      expect(Stripe::Invoice.all.map(&:id)).to eq([@invoice.id, @invoice2.id])
+      expect(Stripe::Invoice.all.map(&:id).sort).to eq([@invoice.id, @invoice2.id].sort)
     end
 
     it "defaults count to 10 invoices" do
@@ -79,7 +79,7 @@ shared_examples 'Invoice API' do
     end
 
     it 'updates attempted and paid flags' do
-      @invoice.pay
+      @invoice = @invoice.pay
       expect(@invoice.attempted).to eq(true)
       expect(@invoice.paid).to eq(true)
     end
@@ -89,7 +89,7 @@ shared_examples 'Invoice API' do
     end
 
     it 'sets the charge attribute' do
-      @invoice.pay
+      @invoice = @invoice.pay
       expect(@invoice.charge).to be_a String
       expect(@invoice.charge.length).to be > 0
     end
@@ -351,7 +351,7 @@ shared_examples 'Invoice API' do
         it 'generates a preview without performing an actual proration', live: true do
           expect(preview.subtotal).to eq 150_00
           # this is a future invoice (generted at the end of the current subscription cycle), rather than a proration invoice
-          expect(preview.date).to be_within(1).of subscription.current_period_end
+          expect(preview.created).to be_within(1).of subscription.current_period_end
           expect(preview.period_start).to eq subscription.current_period_start
           expect(preview.period_end).to eq subscription.current_period_end
           expect(preview.lines.count).to eq 1
@@ -360,7 +360,7 @@ shared_examples 'Invoice API' do
           expect(line.amount).to eq 150_00
           # line period is for the NEXT subscription cycle
           expect(line.period.start).to be_within(1).of subscription.current_period_end
-          expect(line.period.end).to be_within(1).of (Time.at(subscription.current_period_end).to_datetime >> 1).to_time.to_i # +1 month
+          expect(Time.at(line.period.end).month).to be_within(1).of (Time.at(subscription.current_period_end).to_datetime >> 1).month # +1 month
         end
       end
 

data/spec/shared_stripe_examples/plan_examples.rb

@@ -9,6 +9,9 @@ shared_examples 'Plan API' do
       :amount => 9900,
       :currency => 'USD',
       :interval => 1,
+      :product => {
+        :name => 'A product'
+      },
       :metadata => {
         :description => "desc text",
         :info => "info text"
@@ -36,6 +39,9 @@ shared_examples 'Plan API' do
       :amount => 9900,
       :currency => 'USD',
       :interval => 1,
+      :product => {
+        :name => 'A product'
+      }
     )
 
     expect(plan.id).to match(/^test_plan/)
@@ -47,14 +53,20 @@ shared_examples 'Plan API' do
       :name => 'The Memory Plan',
       :amount => 1100,
       :currency => 'USD',
-      :interval => 1
+      :interval => 1,
+      :product => {
+        :name => 'A product'
+      }
     )
     plan2 = Stripe::Plan.create(
       :id => 'pid_3',
       :name => 'The Bonk Plan',
       :amount => 7777,
       :currency => 'USD',
-      :interval => 1
+      :interval => 1,
+      :product => {
+        :name => 'A product'
+      }
     )
     data = test_data_source(:plans)
     expect(data[plan.id]).to_not be_nil
@@ -136,7 +148,10 @@ shared_examples 'Plan API' do
         :name => 'The Mock Plan',
         :amount => 99.99,
         :currency => 'USD',
-        :interval => 'month'
+        :interval => 'month',
+        :product => {
+          :name => 'A product'
+        }
       )
     }.to raise_error(Stripe::InvalidRequestError, "Invalid integer: 99.99")
   end
@@ -157,7 +172,7 @@ shared_examples 'Plan API' do
         expect { subject }.to raise_error(Stripe::InvalidRequestError, message)
       end
 
-      it("requires a name") { @name = :name }
+      it("requires a product") { @name = :product }
       it("requires an amount") { @name = :amount }
       it("requires a currency") { @name = :currency }
       it("requires an interval") { @name = :interval }

data/spec/shared_stripe_examples/product_example.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+shared_examples 'Product API' do
+  it 'creates a product' do
+    product = Stripe::Product.create(
+      name: 'my awesome product',
+      type: 'service'
+    )
+
+    expect(product.name).to eq 'my awesome product'
+    expect(product.type).to eq 'service'
+  end
+
+  it 'retrieves a product' do
+    Stripe::Product.create(
+      id:   'test_prod_1',
+      name: 'my awesome product',
+      type: 'service'
+    )
+
+    product = Stripe::Product.retrieve('test_prod_1')
+
+    expect(product.name).to eq 'my awesome product'
+    expect(product.type).to eq 'service'
+  end
+
+  it 'updates a product' do
+    Stripe::Product.create(
+      id:   'test_prod_1',
+      name: 'my awesome product',
+      type: 'service'
+    )
+
+    Stripe::Product.update('test_prod_1', name: 'my lame product')
+
+    product = Stripe::Product.retrieve('test_prod_1')
+
+    expect(product.name).to eq 'my lame product'
+  end
+
+  it 'lists all products' do
+    2.times do |n|
+      Stripe::Product.create(
+        name: "product #{n}",
+        type: 'service'
+      )
+    end
+
+    products = Stripe::Product.list
+
+    expect(products.map(&:name)).to match_array ['product 0', 'product 1']
+  end
+
+  it 'destroys a product', live: true do
+    Stripe::Product.create(
+      id:   'test_prod_1',
+      name: 'my awesome product',
+      type: 'service'
+    )
+
+    Stripe::Product.delete('test_prod_1')
+
+    expect { Stripe::Product.retrieve('test_prod_1') }. to raise_error(Stripe::InvalidRequestError)
+  end
+end

data/spec/shared_stripe_examples/refund_examples.rb

@@ -337,26 +337,32 @@ shared_examples 'Refund API' do
           capture: true
         )
       end
-      let(:idempotent_refund_params) {{
-        charge: charge.id,
+      let(:refund_params) {{
+        charge: charge.id
+      }}
+
+      let(:refund_headers) {{
         idempotency_key: 'onceisenough'
       }}
 
       it "returns the original refund if the same idempotency_key is passed in" do
-        refund1 = Stripe::Refund.create(idempotent_refund_params)
-        refund2 = Stripe::Refund.create(idempotent_refund_params)
+        refund1 = Stripe::Refund.create(refund_params, refund_headers)
+        refund2 = Stripe::Refund.create(refund_params, refund_headers)
 
         expect(refund1).to eq(refund2)
       end
 
-      it "returns different charges if different idempotency_keys are used for each charge" do
-        idempotent_refund_params2 = idempotent_refund_params.clone
-        idempotent_refund_params2[:idempotency_key] = 'thisoneisdifferent'
+      context 'different key' do
+        let(:different_refund_headers) {{
+          idempotency_key: 'thisoneisdifferent'
+        }}
 
-        refund1 = Stripe::Refund.create(idempotent_refund_params)
-        refund2 = Stripe::Refund.create(idempotent_refund_params2)
+        it "returns different charges if different idempotency_keys are used for each charge" do
+          refund1 = Stripe::Refund.create(refund_params, refund_headers)
+          refund2 = Stripe::Refund.create(refund_params, different_refund_headers)
 
-        expect(refund1).not_to eq(refund2)
+          expect(refund1).not_to eq(refund2)
+        end
       end
     end
   end

data/spec/shared_stripe_examples/subscription_examples.rb

@@ -8,7 +8,8 @@ shared_examples 'Customer Subscriptions' do
 
   context "creating a new subscription" do
     it "adds a new subscription to customer with none using items", :live => true do
-      plan = stripe_helper.create_plan(id: 'silver', name: 'Silver Plan', amount: 4999, currency: 'usd')
+      plan = stripe_helper.create_plan(id: 'silver', product: { name: 'Silver Plan' },
+                                       amount: 4999, currency: 'usd')
       customer = Stripe::Customer.create(source: gen_card_tk)
 
       expect(customer.subscriptions.data).to be_empty
@@ -37,7 +38,8 @@ shared_examples 'Customer Subscriptions' do
     end
 
     it "adds a new subscription to customer with none", :live => true do
-      plan = stripe_helper.create_plan(id: 'silver', name: 'Silver Plan', amount: 4999, currency: 'usd')
+      plan = stripe_helper.create_plan(id: 'silver', product: { name: 'Silver Plan' },
+                                       amount: 4999, currency: 'usd')
       customer = Stripe::Customer.create(source: gen_card_tk)
 
       expect(customer.subscriptions.data).to be_empty
@@ -66,7 +68,7 @@ shared_examples 'Customer Subscriptions' do
     end
 
     it 'when customer object provided' do
-      plan = stripe_helper.create_plan(id: 'silver', name: 'Silver Plan', amount: 4999, currency: 'usd')
+      plan = stripe_helper.create_plan(id: 'silver', product: { name: 'Silver Plan' }, amount: 4999, currency: 'usd')
       customer = Stripe::Customer.create(source: gen_card_tk)
 
       expect(customer.subscriptions.data).to be_empty
@@ -100,13 +102,15 @@ shared_examples 'Customer Subscriptions' do
       customer = Stripe::Customer.create(source: gen_card_tk)
       expect(customer.subscriptions.count).to eq(0)
 
-      plan = stripe_helper.create_plan(id: :silver, name: 'Silver Plan', amount: 4999, currency: 'usd')
+      plan = stripe_helper.create_plan(id: :silver, product: { name: 'Silver Plan' },
+                                       amount: 4999, currency: 'usd')
       sub = Stripe::Subscription.create({ plan: 'silver', customer: customer.id })
       customer = Stripe::Customer.retrieve(customer.id)
       expect(sub.plan.to_hash).to eq(plan.to_hash)
       expect(customer.subscriptions.count).to eq(1)
 
-      plan = stripe_helper.create_plan(id: 'gold', name: 'Gold Plan', amount: 14999, currency: 'usd')
+      plan = stripe_helper.create_plan(id: 'gold', product: { name: 'Gold Plan' },
+                                       amount: 14999, currency: 'usd')
       sub = Stripe::Subscription.create({ plan: 'gold', customer: customer.id })
       customer = Stripe::Customer.retrieve(customer.id)
       expect(sub.plan.to_hash).to eq(plan.to_hash)
@@ -114,7 +118,8 @@ shared_examples 'Customer Subscriptions' do
     end
 
     it 'creates a charge for the customer', live: true do
-      stripe_helper.create_plan(id: 'silver', name: 'Silver Plan', amount: 4999)
+      stripe_helper.create_plan(id: 'silver', product: { name: 'Silver Plan' },
+                                amount: 4999)
 
       customer = Stripe::Customer.create(source: gen_card_tk)
       Stripe::Subscription.create({ plan: 'silver', customer: customer.id, metadata: { foo: "bar", example: "yes" } })
@@ -125,7 +130,8 @@ shared_examples 'Customer Subscriptions' do
     end
 
     it 'contains coupon object', live: true do
-      plan = stripe_helper.create_plan(id: 'plan_with_coupon', name: 'One More Test Plan', amount: 777)
+      plan = stripe_helper.create_plan(id: 'plan_with_coupon', product: { name: 'One More Test Plan' },
+                                       amount: 777)
       coupon = stripe_helper.create_coupon(id: 'free_coupon', duration: 'repeating', duration_in_months: 3)
       customer = Stripe::Customer.create(source: gen_card_tk)
       Stripe::Subscription.create(plan: plan.id, customer: customer.id, coupon: coupon.id)
@@ -134,12 +140,13 @@ shared_examples 'Customer Subscriptions' do
       expect(customer.subscriptions.data).to be_a(Array)
       expect(customer.subscriptions.data.count).to eq(1)
       expect(customer.subscriptions.data.first.discount).not_to be_nil
-      expect(customer.subscriptions.data.first.discount).to be_a(Stripe::StripeObject)
+      expect(customer.subscriptions.data.first.discount).to be_a(Stripe::Discount)
       expect(customer.subscriptions.data.first.discount.coupon.id).to eq(coupon.id)
     end
 
     it 'when coupon is not exist', live: true do
-      plan = stripe_helper.create_plan(id: 'plan_with_coupon', name: 'One More Test Plan', amount: 777)
+      plan = stripe_helper.create_plan(id: 'plan_with_coupon', product: { name: 'One More Test Plan' },
+                                       amount: 777)
       customer = Stripe::Customer.create(source: gen_card_tk)
 
       expect { Stripe::Subscription.create(plan: plan.id, customer: customer.id, coupon: 'none') }.to raise_error {|e|
@@ -153,7 +160,9 @@ shared_examples 'Customer Subscriptions' do
       Stripe::Plan.create(
         :amount => 2500,
         :interval => 'month',
-        :name => 'Test plan',
+        :product => {
+          :name => 'Test plan'
+        },
         :currency => 'usd',
         :id => 'silver',
         :statement_description => "testPlan"
@@ -169,7 +178,8 @@ shared_examples 'Customer Subscriptions' do
 
     it "correctly sets created when it's not provided as a parameter", live: true do
       customer = Stripe::Customer.create(source: gen_card_tk)
-      plan = stripe_helper.create_plan(id: 'silver', name: 'Silver Plan', amount: 4999, currency: 'usd')
+      plan = stripe_helper.create_plan(id: 'silver', product: { name: 'Silver Plan' },
+                                       amount: 4999, currency: 'usd')
       subscription = Stripe::Subscription.create({ plan: 'silver', customer: customer.id })
 
       expect(subscription.created).to eq(subscription.current_period_start)
@@ -177,7 +187,8 @@ shared_examples 'Customer Subscriptions' do
 
     it "correctly sets created when it's provided as a parameter" do
       customer = Stripe::Customer.create(source: gen_card_tk)
-      plan = stripe_helper.create_plan(id: 'silver', name: 'Silver Plan', amount: 4999, currency: 'usd')
+      plan = stripe_helper.create_plan(id: 'silver', product: { name: 'Silver Plan' },
+                                       amount: 4999, currency: 'usd')
       subscription = Stripe::Subscription.create({ plan: 'silver', customer: customer.id, created: 1473576318 })
 
       expect(subscription.created).to eq(1473576318)
@@ -351,6 +362,30 @@ shared_examples 'Customer Subscriptions' do
       expect(sub.trial_end).to eq(trial_end)
     end
 
+    it "does not override trial end when trial end is not set" do
+      plan = stripe_helper.create_plan(id: 'trial', amount: 999, trial_period_days: 14)
+      customer = Stripe::Customer.create(id: 'short_trial')
+      trial_end = Time.now.utc.to_i + 3600
+      metadata = {description: 'original description'}
+
+      sub = Stripe::Subscription.create({ plan: 'trial', customer: customer.id, trial_end: trial_end, metadata: metadata })
+
+      expect(sub.object).to eq('subscription')
+      expect(sub.plan.to_hash).to eq(plan.to_hash)
+      expect(sub.current_period_end).to eq(trial_end)
+      expect(sub.trial_end).to eq(trial_end)
+      expect(sub.metadata.description).to eq(metadata[:description])
+
+      metadata = {description: 'updated description'}
+      sub = Stripe::Subscription.update(sub.id, { metadata: metadata })
+
+      expect(sub.object).to eq('subscription')
+      expect(sub.plan.to_hash).to eq(plan.to_hash)
+      expect(sub.current_period_end).to eq(trial_end)
+      expect(sub.trial_end).to eq(trial_end) # check that the trial_end has NOT changed
+      expect(sub.metadata.description).to eq(metadata[:description]) # check that the description has changed
+    end
+
     it "returns without a trial when trial_end is set to 'now'" do
       plan = stripe_helper.create_plan(id: 'trial', amount: 999, trial_period_days: 14)
       customer = Stripe::Customer.create(id: 'no_trial', source: gen_card_tk)
@@ -436,6 +471,8 @@ shared_examples 'Customer Subscriptions' do
       expect(subscription.plan).to eq nil
       expect(subscription.items.data[0].plan.id).to eq plan.id
       expect(subscription.items.data[1].plan.id).to eq plan2.id
+      expect(subscription.items.data[0].quantity).to eq 1
+      expect(subscription.items.data[1].quantity).to eq 2
     end
 
     it 'when plan defined inside items for trials with no card', live: true do
@@ -459,6 +496,75 @@ shared_examples 'Customer Subscriptions' do
       expect(subscription.items.data[0].plan.id).to eq plan.id
       expect(subscription.items.data[1].plan.id).to eq plan2.id
     end
+
+    it 'add a new subscription to bill via an invoice' do
+      plan = stripe_helper.create_plan(id: 'silver', product: { name: 'Silver Plan' },
+                                       amount: 4999, currency: 'usd')
+      customer = Stripe::Customer.create(id: 'cardless')
+
+      expect(customer.subscriptions.data).to be_empty
+      expect(customer.subscriptions.count).to eq(0)
+
+      sub = Stripe::Subscription.create({
+        plan: 'silver',
+        customer: customer.id,
+        metadata: { foo: 'bar', example: 'yes' },
+        billing: 'send_invoice',
+        days_until_due: 30,
+      })
+
+      expect(sub.object).to eq('subscription')
+      expect(sub.plan.to_hash).to eq(plan.to_hash)
+      expect(sub.billing).to eq 'send_invoice'
+      expect(sub.days_until_due).to eq 30
+    end
+
+    let(:subscription_header) {{
+      :idempotency_key => 'a_idempotency_key'
+    }}
+
+    it "adds a new subscription to customer with identical idempotency key" do
+      plan = stripe_helper.create_plan(id: 'silver', product: { name: 'Silver Plan' },
+                                       amount: 4999, currency: 'usd')
+      customer = Stripe::Customer.create(source: gen_card_tk)
+
+      expect(customer.subscriptions.data).to be_empty
+      expect(customer.subscriptions.count).to eq(0)
+
+      sub1 = Stripe::Subscription.create({ items: [{ plan: 'silver' }], customer: customer.id }, subscription_header)
+      sub2 = Stripe::Subscription.create({ items: [{ plan: 'silver' }], customer: customer.id }, subscription_header)
+      expect(sub1).to eq(sub2)
+    end
+
+    it "adds a new subscription to customer with different idempotency key", :live => true do
+      plan = stripe_helper.create_plan(id: 'silver', product: { name: 'Silver Plan' },
+                                       amount: 4999, currency: 'usd')
+      customer = Stripe::Customer.create(source: gen_card_tk)
+
+      expect(customer.subscriptions.data).to be_empty
+      expect(customer.subscriptions.count).to eq(0)
+
+      another_subscription_header = {
+        :idempotency_key => 'another_idempotency_key'
+      }
+
+      sub1 = Stripe::Subscription.create({ items: [{ plan: 'silver' }], customer: customer.id }, subscription_header)
+      sub2 = Stripe::Subscription.create({ items: [{ plan: 'silver' }], customer: customer.id }, another_subscription_header)
+      expect(sub1).not_to eq(sub2)
+    end
+
+    it "accepts a hash of items" do
+      silver = stripe_helper.create_plan(id: 'silver')
+      customer = Stripe::Customer.create(id: 'test_customer_sub', source: gen_card_tk)
+
+      sub = Stripe::Subscription.create({ items: { '0' => { plan: 'silver' } }, customer: customer.id })
+      sub.delete(at_period_end: true)
+
+      expect(sub.cancel_at_period_end).to be_truthy
+      expect(sub.save).to be_truthy
+      expect(sub.cancel_at_period_end).to be_falsey
+    end
+
   end
 
   context "updating a subscription" do
@@ -569,7 +675,8 @@ shared_examples 'Customer Subscriptions' do
     end
 
     it 'when adds coupon', live: true do
-      plan = stripe_helper.create_plan(id: 'plan_with_coupon2', name: 'One More Test Plan', amount: 777)
+      plan = stripe_helper.create_plan(id: 'plan_with_coupon2', product: { name: 'One More Test Plan' },
+                                       amount: 777)
       coupon = stripe_helper.create_coupon
       customer = Stripe::Customer.create(source: gen_card_tk, plan: plan.id)
       subscription = Stripe::Subscription.retrieve(customer.subscriptions.data.first.id)
@@ -578,12 +685,13 @@ shared_examples 'Customer Subscriptions' do
       subscription.save
 
       expect(subscription.discount).not_to be_nil
-      expect(subscription.discount).to be_an_instance_of(Stripe::StripeObject)
+      expect(subscription.discount).to be_a(Stripe::Discount)
       expect(subscription.discount.coupon.id).to eq(coupon.id)
     end
 
     it 'when add not exist coupon' do
-      plan = stripe_helper.create_plan(id: 'plan_with_coupon3', name: 'One More Test Plan', amount: 777)
+      plan = stripe_helper.create_plan(id: 'plan_with_coupon3', product: { name: 'One More Test Plan' },
+                                       amount: 777)
       customer = Stripe::Customer.create(source: gen_card_tk, plan: plan.id)
       subscription = Stripe::Subscription.retrieve(customer.subscriptions.data.first.id)
 
@@ -598,7 +706,8 @@ shared_examples 'Customer Subscriptions' do
     end
 
     it 'when coupon is removed' do
-      plan = stripe_helper.create_plan(id: 'plan_with_coupon3', name: 'One More Test Plan', amount: 777)
+      plan = stripe_helper.create_plan(id: 'plan_with_coupon3', product: { name: 'One More Test Plan' },
+                                       amount: 777)
       customer = Stripe::Customer.create(source: gen_card_tk, plan: plan.id)
       coupon = stripe_helper.create_coupon
       subscription = Stripe::Subscription.retrieve(customer.subscriptions.data.first.id)
@@ -875,6 +984,52 @@ shared_examples 'Customer Subscriptions' do
     end
   end
 
+  it "supports 'cancelling' by updating cancel_at_period_end" do
+    truth = stripe_helper.create_plan(id: 'the_truth')
+    customer = Stripe::Customer.create(id: 'test_customer_sub', source: gen_card_tk, plan: "the_truth")
+
+    sub = Stripe::Subscription.retrieve(customer.subscriptions.data.first.id)
+    result = Stripe::Subscription.update(sub.id, cancel_at_period_end: true)
+
+    expect(result.status).to eq('active')
+    expect(result.cancel_at_period_end).to eq(true)
+    expect(result.id).to eq(sub.id)
+
+    customer = Stripe::Customer.retrieve('test_customer_sub')
+    expect(customer.subscriptions.data).to_not be_empty
+    expect(customer.subscriptions.count).to eq(1)
+    expect(customer.subscriptions.data.length).to eq(1)
+
+    expect(customer.subscriptions.data.first.status).to eq('active')
+    expect(customer.subscriptions.data.first.cancel_at_period_end).to eq(true)
+    expect(customer.subscriptions.data.first.ended_at).to be_nil
+    expect(customer.subscriptions.data.first.canceled_at).to_not be_nil
+  end
+
+  it "resumes a subscription cancelled by updating cancel_at_period_end" do
+    truth = stripe_helper.create_plan(id: 'the_truth')
+    customer = Stripe::Customer.create(id: 'test_customer_sub', source: gen_card_tk, plan: "the_truth")
+
+    sub = Stripe::Subscription.retrieve(customer.subscriptions.data.first.id)
+    Stripe::Subscription.update(sub.id, cancel_at_period_end: true)
+
+    result = Stripe::Subscription.update(sub.id, cancel_at_period_end: false)
+
+    expect(result.status).to eq('active')
+    expect(result.cancel_at_period_end).to eq(false)
+    expect(result.id).to eq(sub.id)
+
+    customer = Stripe::Customer.retrieve('test_customer_sub')
+    expect(customer.subscriptions.data).to_not be_empty
+    expect(customer.subscriptions.count).to eq(1)
+    expect(customer.subscriptions.data.length).to eq(1)
+
+    expect(customer.subscriptions.data.first.status).to eq('active')
+    expect(customer.subscriptions.data.first.cancel_at_period_end).to eq(false)
+    expect(customer.subscriptions.data.first.ended_at).to be_nil
+    expect(customer.subscriptions.data.first.canceled_at).to be_nil
+  end
+
   it "doesn't change status of subscription when cancelling at period end" do
     trial = stripe_helper.create_plan(id: 'trial', trial_period_days: 14)
     customer = Stripe::Customer.create(id: 'test_customer_sub', source: gen_card_tk, plan: "trial")
@@ -962,10 +1117,13 @@ shared_examples 'Customer Subscriptions' do
 
     it "creates a stripe customer and subscribes them to a plan with meta data", :live => true do
 
-      stripe_helper.create_plan(
+      stripe_helper.
+        create_plan(
         :amount => 500,
         :interval => 'month',
-        :name => 'Sample Plan',
+        :product => {
+          :name => 'Sample Plan'
+        },
         :currency => 'usd',
         :id => 'Sample5'
       )