stripe-ruby-mock 2.3.1 → 2.5.8

data/spec/shared_stripe_examples/subscription_examples.rb

@@ -7,8 +7,39 @@ shared_examples 'Customer Subscriptions' do
   end
 
   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', 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)
+
+      sub = Stripe::Subscription.create({ items: [{ plan: 'silver' }],
+                                          customer: customer.id, metadata: { foo: "bar", example: "yes" } })
+
+      expect(sub.object).to eq('subscription')
+      expect(sub.plan.to_hash).to eq(plan.to_hash)
+      expect(sub.metadata.foo).to eq( "bar" )
+      expect(sub.metadata.example).to eq( "yes" )
+
+      customer = Stripe::Customer.retrieve(customer.id)
+      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.charges.data.length).to eq(1)
+      expect(customer.currency).to eq( "usd" )
+
+      expect(customer.subscriptions.data.first.id).to eq(sub.id)
+      expect(customer.subscriptions.data.first.plan.to_hash).to eq(plan.to_hash)
+      expect(customer.subscriptions.data.first.customer).to eq(customer.id)
+      expect(customer.subscriptions.data.first.metadata.foo).to eq( "bar" )
+      expect(customer.subscriptions.data.first.metadata.example).to eq( "yes" )
+    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
@@ -31,6 +62,38 @@ shared_examples 'Customer Subscriptions' do
       expect(customer.subscriptions.data.first.id).to eq(sub.id)
       expect(customer.subscriptions.data.first.plan.to_hash).to eq(plan.to_hash)
       expect(customer.subscriptions.data.first.customer).to eq(customer.id)
+      expect(customer.subscriptions.data.first.billing).to eq('charge_automatically')
+      expect(customer.subscriptions.data.first.metadata.foo).to eq( "bar" )
+      expect(customer.subscriptions.data.first.metadata.example).to eq( "yes" )
+    end
+
+    it 'when customer object provided' 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)
+
+      sub = Stripe::Subscription.create({ plan: 'silver', customer: customer, metadata: { foo: "bar", example: "yes" } })
+
+      expect(sub.object).to eq('subscription')
+      expect(sub.plan.to_hash).to eq(plan.to_hash)
+      expect(sub.billing).to eq('charge_automatically')
+      expect(sub.metadata.foo).to eq( "bar" )
+      expect(sub.metadata.example).to eq( "yes" )
+
+      customer = Stripe::Customer.retrieve(customer.id)
+      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.charges.data.length).to eq(1)
+      expect(customer.currency).to eq( "usd" )
+
+      expect(customer.subscriptions.data.first.id).to eq(sub.id)
+      expect(customer.subscriptions.data.first.plan.to_hash).to eq(plan.to_hash)
+
+      expect(customer.subscriptions.data.first.customer).to eq(customer.id)
+      expect(customer.subscriptions.data.first.billing).to eq('charge_automatically')
       expect(customer.subscriptions.data.first.metadata.foo).to eq( "bar" )
       expect(customer.subscriptions.data.first.metadata.example).to eq( "yes" )
     end
@@ -39,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)
@@ -53,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" } })
@@ -64,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)
@@ -73,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|
@@ -92,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"
@@ -106,6 +176,24 @@ shared_examples 'Customer Subscriptions' do
       expect(subscription.tax_percent).to eq(20)
     end
 
+    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', 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)
+    end
+
+    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', 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)
+    end
+
     it "adds additional subscription to customer with existing subscription" do
       silver =  stripe_helper.create_plan(id: 'silver')
       gold =    stripe_helper.create_plan(id: 'gold')
@@ -185,6 +273,18 @@ shared_examples 'Customer Subscriptions' do
       }
     end
 
+    it 'when attempting to create a new subscription with the params trial', live: true do
+      plan = stripe_helper.create_plan(id: 'trial', amount: 999)
+      customer = Stripe::Customer.create(source: gen_card_tk)
+
+      expect{ Stripe::Subscription.create(plan: plan.id, customer: customer.id, trial: 10) }.to raise_error {|e|
+        expect(e).to be_a Stripe::InvalidRequestError
+        expect(e.http_status).to eq(400)
+        expect(e.param).to eq('trial')
+        expect(e.message).to match /Received unknown parameter/
+      }
+    end
+
     it "subscribes a customer with no card to a plan with a free trial" do
       plan = stripe_helper.create_plan(id: 'trial', amount: 999, trial_period_days: 14)
       customer = Stripe::Customer.create(id: 'cardless')
@@ -194,6 +294,7 @@ shared_examples 'Customer Subscriptions' do
       expect(sub.object).to eq('subscription')
       expect(sub.plan.to_hash).to eq(plan.to_hash)
       expect(sub.trial_end - sub.trial_start).to eq(14 * 86400)
+      expect(sub.billing_cycle_anchor).to be_nil
 
       customer = Stripe::Customer.retrieve('cardless')
       expect(customer.subscriptions.data).to_not be_empty
@@ -203,6 +304,30 @@ shared_examples 'Customer Subscriptions' do
       expect(customer.subscriptions.data.first.id).to eq(sub.id)
       expect(customer.subscriptions.data.first.plan.to_hash).to eq(plan.to_hash)
       expect(customer.subscriptions.data.first.customer).to eq(customer.id)
+      expect(customer.charges.count).to eq(0)
+    end
+
+    it "subscribes a customer with no card to a plan with a free trial with plan as item" do
+      plan = stripe_helper.create_plan(id: 'trial', amount: 999, trial_period_days: 14)
+      customer = Stripe::Customer.create(id: 'cardless')
+
+      sub = Stripe::Subscription.create({ items: [ { plan: 'trial' } ], customer: customer.id })
+
+      expect(sub.object).to eq('subscription')
+      expect(sub.items.data[0].plan.to_hash).to eq(plan.to_hash)
+      # no idea how to fix this one
+      # expect(sub.trial_end - sub.trial_start).to eq(14 * 86400)
+
+      customer = Stripe::Customer.retrieve('cardless')
+      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.id).to eq(sub.id)
+      expect(customer.subscriptions.data.first.items.data.first.plan.to_hash).to eq(plan.to_hash)
+      expect(customer.subscriptions.data.first.customer).to eq(customer.id)
+      # No idea on this one
+      # expect(customer.charges.count).to eq(0)
     end
 
     it "subscribes a customer with no card to a free plan" do
@@ -237,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)
@@ -285,6 +434,137 @@ shared_examples 'Customer Subscriptions' do
       }
     end
 
+    it 'overrides current period end when billing cycle anchor is set' do
+      plan = stripe_helper.create_plan(id: 'plan', amount: 999)
+      customer = Stripe::Customer.create(source: gen_card_tk)
+      billing_cycle_anchor = Time.now.utc.to_i + 3600
+
+      sub = Stripe::Subscription.create({ plan: 'plan', customer: customer.id, billing_cycle_anchor: billing_cycle_anchor })
+
+      expect(sub.status).to eq('active')
+      expect(sub.current_period_end).to eq(billing_cycle_anchor)
+      expect(sub.billing_cycle_anchor).to eq(billing_cycle_anchor)
+    end
+
+    it 'when plan defined inside items', live: true do
+      plan = stripe_helper.create_plan(id: 'BASE_PRICE_PLAN1')
+
+      plan2 = stripe_helper.create_plan(id: 'PER_USER_PLAN1')
+      customer = Stripe::Customer.create(
+        source: {
+          object: 'card',
+          exp_month: 11,
+          exp_year: 2019,
+          number: '4242424242424242',
+          cvc: '123'
+        }
+      )
+      subscription = Stripe::Subscription.create(
+        customer: customer.id,
+        items: [
+          { plan: plan.id, quantity: 1 },
+          { plan: plan2.id, quantity: 2 }
+        ]
+      )
+
+      expect(subscription.id).to match /(test_su_|sub_).+/
+      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
+      plan = stripe_helper.create_plan(id: 'BASE_PRICE_PLAN1')
+
+      plan2 = stripe_helper.create_plan(id: 'PER_USER_PLAN1')
+      customer = Stripe::Customer.create
+      trial_end = Time.now.utc.to_i + 3600
+
+      subscription = Stripe::Subscription.create(
+        customer: customer.id,
+        items: [
+          { plan: plan.id, quantity: 1 },
+          { plan: plan2.id, quantity: 2 }
+        ],
+        trial_end: trial_end
+      )
+
+      expect(subscription.id).to match /(test_su_|sub_).+/
+      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
+    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
@@ -302,7 +582,19 @@ shared_examples 'Customer Subscriptions' do
       }
     end
 
-    it "updates a stripe customer's existing subscription" do
+    it "updates a stripe customer's existing subscription with one plan inside 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: [ { 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
+
+    it "updates a stripe customer's existing subscription when plan inside of items" do
       silver = stripe_helper.create_plan(id: 'silver')
       gold = stripe_helper.create_plan(id: 'gold')
       customer = Stripe::Customer.create(id: 'test_customer_sub', source: gen_card_tk, plan: 'silver')
@@ -331,8 +623,60 @@ shared_examples 'Customer Subscriptions' do
       expect(customer.subscriptions.data.first.customer).to eq(customer.id)
     end
 
+    it "updates a stripe customer's existing subscription with single plan when multiple plans inside of items" do
+      silver_plan = stripe_helper.create_plan(id: 'silver')
+      gold_plan = stripe_helper.create_plan(id: 'gold')
+      addon_plan = stripe_helper.create_plan(id: 'addon_plan')
+      customer = Stripe::Customer.create(id: 'test_customer_sub', source: gen_card_tk, plan: silver_plan.id)
+
+      sub = Stripe::Subscription.retrieve(customer.subscriptions.data.first.id)
+      sub.items = [{ plan: gold_plan.id, quantity: 2 }, { plan: addon_plan.id, quantity: 2 }]
+      expect(sub.save).to be_truthy
+
+      expect(sub.object).to eq('subscription')
+      expect(sub.plan).to be_nil
+
+      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.id).to eq(sub.id)
+      expect(customer.subscriptions.data.first.plan).to be_nil
+      expect(customer.subscriptions.data.first.customer).to eq(customer.id)
+      expect(customer.subscriptions.data.first.items.data[0].plan.to_hash).to eq(gold_plan.to_hash)
+      expect(customer.subscriptions.data.first.items.data[1].plan.to_hash).to eq(addon_plan.to_hash)
+    end
+
+    it "updates a stripe customer's existing subscription with multple plans when multiple plans inside of items" do
+      silver_plan = stripe_helper.create_plan(id: 'silver')
+      gold_plan = stripe_helper.create_plan(id: 'gold')
+      addon1_plan = stripe_helper.create_plan(id: 'addon1')
+      addon2_plan = stripe_helper.create_plan(id: 'addon2')
+      customer = Stripe::Customer.create(id: 'test_customer_sub', source: gen_card_tk)
+      sub = Stripe::Subscription.create(customer: customer.id, items: [{ plan: silver_plan.id }, { plan: addon1_plan.id }])
+
+      sub.items = [{ plan: gold_plan.id, quantity: 2 }, { plan: addon2_plan.id, quantity: 2 }]
+      expect(sub.save).to be_truthy
+
+      expect(sub.object).to eq('subscription')
+      expect(sub.plan).to be_nil
+
+      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.id).to eq(sub.id)
+      expect(customer.subscriptions.data.first.plan).to be_nil
+      expect(customer.subscriptions.data.first.customer).to eq(customer.id)
+      expect(customer.subscriptions.data.first.items.data[0].plan.to_hash).to eq(gold_plan.to_hash)
+      expect(customer.subscriptions.data.first.items.data[1].plan.to_hash).to eq(addon2_plan.to_hash)
+    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)
@@ -341,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)
 
@@ -360,6 +705,21 @@ shared_examples 'Customer Subscriptions' do
 
     end
 
+    it 'when coupon is removed' do
+      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)
+
+      subscription.coupon = coupon.id
+      subscription.save
+      subscription.coupon = nil
+      subscription.save
+
+      expect(subscription.discount).to be_nil
+    end
+
     it "throws an error when plan does not exist" do
       free = stripe_helper.create_plan(id: 'free', amount: 0)
       customer = Stripe::Customer.create(id: 'cardless', plan: 'free')
@@ -395,24 +755,32 @@ shared_examples 'Customer Subscriptions' do
       expect(customer.subscriptions.data.first.plan.to_hash).to eq(free.to_hash)
     end
 
-    it "throws an error when updating a customer with no card" do
-      free = stripe_helper.create_plan(id: 'free', amount: 0)
-      paid = stripe_helper.create_plan(id: 'enterprise', amount: 499)
-      customer = Stripe::Customer.create(id: 'cardless', plan: 'free')
-
-      sub = Stripe::Subscription.retrieve(customer.subscriptions.data.first.id)
-      sub.plan = 'enterprise'
-
-      expect { sub.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
-      }
-
-      customer = Stripe::Customer.retrieve('cardless')
-      expect(customer.subscriptions.count).to eq(1)
-      expect(customer.subscriptions.data.length).to eq(1)
-      expect(customer.subscriptions.data.first.plan.to_hash).to eq(free.to_hash)
+    [nil, 0].each do |trial_period_days|
+      it "throws an error when updating a customer with no card, and plan trail_period_days = #{trial_period_days}", live: true do
+        begin
+          free = stripe_helper.create_plan(id: 'free', amount: 0)
+          paid = stripe_helper.create_plan(id: 'enterprise', amount: 499, trial_period_days: trial_period_days)
+          customer = Stripe::Customer.create(description: 'cardless', plan: 'free')
+
+          sub = Stripe::Subscription.retrieve(customer.subscriptions.data.first.id)
+          sub.plan = 'enterprise'
+
+          expect { sub.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
+          }
+
+          customer = Stripe::Customer.retrieve(customer.id)
+          expect(customer.subscriptions.count).to eq(1)
+          expect(customer.subscriptions.data.length).to eq(1)
+          expect(customer.subscriptions.data.first.plan.to_hash).to eq(free.to_hash)
+        ensure
+          customer.delete if customer
+          paid.delete if paid
+          free.delete if free
+        end
+      end
     end
 
     it 'updates a subscription if the customer has a free trial', live: true do
@@ -616,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")
@@ -644,6 +1058,34 @@ shared_examples 'Customer Subscriptions' do
     Stripe::Subscription.create options
   end
 
+  context 'retrieving a single subscription' do
+    let(:customer) { Stripe::Customer.create(id: 'test_customer_sub', source: gen_card_tk, plan: 'free') }
+    let(:subscription) { Stripe::Subscription.retrieve(customer.subscriptions.data.first.id) }
+
+    before do
+      stripe_helper.create_plan(id: 'free', amount: 0)
+      Stripe::Subscription.create({ plan: 'free', customer: customer.id })
+    end
+
+    it 'retrieves a single subscription' do
+      expect(subscription).to be_truthy
+    end
+
+    it "includes 'items' object on retrieved subscription" do
+      expect(subscription.items).to be_truthy
+      expect(subscription.items.object).to eq('list')
+      expect(subscription.items.data.class).to eq(Array)
+      expect(subscription.items.data.count).to eq(1)
+      expect(subscription.items.data.first.id).to eq('test_txn_default')
+      expect(subscription.items.data.first.created).to eq(1504716183)
+      expect(subscription.items.data.first.object).to eq('subscription_item')
+      expect(subscription.items.data.first.plan.amount).to eq(0)
+      expect(subscription.items.data.first.plan.created).to eq(1466698898)
+      expect(subscription.items.data.first.plan.currency).to eq('usd')
+      expect(subscription.items.data.first.quantity).to eq(2)
+    end
+  end
+
   context "retrieve multiple subscriptions" do
 
     it "retrieves a list of multiple subscriptions" do
@@ -675,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'
       )