stripe-ruby-mock 2.5.6 → 3.1.0.rc2

data/spec/shared_stripe_examples/product_examples.rb

@@ -0,0 +1,155 @@
+require "spec_helper"
+
+shared_examples "Product API" do
+  let(:product_attributes) { {id: "prod_123", name: "My Mock Product", type: "service"} }
+  let(:product) { Stripe::Product.create(product_attributes) }
+
+  it "creates a stripe product" do
+    expect(product.id).to eq("prod_123")
+    expect(product.name).to eq("My Mock Product")
+    expect(product.type).to eq("service")
+  end
+
+  it "stores a created stripe product in memory" do
+    product = Stripe::Product.create(product_attributes)
+    product2 = Stripe::Product.create(product_attributes.merge({id: "prod_456", name: "My Other Product"}))
+
+    data = test_data_source(:products)
+    expect(data[product.id]).to_not be_nil
+    expect(data[product.id][:id]).to eq("prod_123")
+    expect(data[product.id][:name]).to eq("My Mock Product")
+    expect(data[product2.id]).to_not be_nil
+    expect(data[product2.id][:id]).to eq("prod_456")
+    expect(data[product2.id][:name]).to eq("My Other Product")
+  end
+
+  it "retrieves a stripe product" do
+    original = stripe_helper.create_product(product_attributes)
+    product = Stripe::Product.retrieve(original.id)
+
+    expect(product.id).to eq(original.id)
+    expect(product.name).to eq(original.name)
+  end
+
+  it "updates a stripe product" do
+    stripe_helper.create_product(id: "prod_XYZ", name: "Future Product")
+
+    product = Stripe::Product.retrieve("prod_XYZ")
+    expect(product.name).to eq("Future Product")
+
+    product.name = "Updated Product"
+    product.save
+    product = Stripe::Product.retrieve("prod_XYZ")
+    expect(product.name).to eq("Updated Product")
+  end
+
+  it "cannot retrieve a stripe product that doesn't exist" do
+    expect { Stripe::Product.retrieve('nope') }.to raise_error {|e|
+      expect(e).to be_a Stripe::InvalidRequestError
+      expect(e.param).to eq("product")
+      expect(e.http_status).to eq(404)
+    }
+  end
+
+  it "deletes a stripe product" do
+    stripe_helper.create_product(id: "prod_DEL", name: "Aging Product")
+
+    product = Stripe::Product.retrieve("prod_DEL")
+    expect(product).to_not be_nil
+
+    product.delete
+
+    expect { Stripe::Product.retrieve("prod_DEL") }.to raise_error {|e|
+      expect(e).to be_a Stripe::InvalidRequestError
+      expect(e.param).to eq("product")
+      expect(e.http_status).to eq(404)
+    }
+  end
+
+  it "retrieves all products" do
+    stripe_helper.create_product(id: "prod_123", name: "First Product")
+    stripe_helper.create_product(id: "prod_456", name: "Second Product")
+
+    all = Stripe::Product.list
+    expect(all.count).to eq(2)
+    expect(all.map &:id).to include("prod_123", "prod_456")
+    expect(all.map &:name).to include("First Product", "Second Product")
+  end
+
+  it 'retrieves products with limit' do
+    101.times do |i|
+      stripe_helper.create_product(id: "Product #{i}", name: "My Product ##{i}")
+    end
+    all = Stripe::Product.list(limit: 100)
+
+    expect(all.count).to eq(100)
+  end
+
+  describe "Validation", :live => true do
+    include_context "stripe validator"
+    let(:params) { stripe_helper.create_product_params }
+    let(:subject) { Stripe::Product.create(params) }
+    before { stripe_helper.delete_product(params[:id]) }
+
+    describe "Required Parameters" do
+      after do
+        params.delete(@attribute_name)
+        message = stripe_validator.missing_param_message(@attribute_name)
+        expect { subject }.to raise_error(Stripe::InvalidRequestError, message)
+      end
+
+      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) }
+
+      it "validates uniqueness of identifier" do
+        stripe_helper.delete_product(params[:id])
+
+        Stripe::Product.create(params)
+        expect {
+          Stripe::Product.create(params)
+        }.to raise_error(Stripe::InvalidRequestError, already_exists_message)
+      end
+    end
+  end
+
+ describe "Mock Data" do
+    let(:mock_object) { StripeMock::Data.mock_product }
+    let(:known_attributes) { [
+      :id,
+      :object,
+      :active,
+      :attributes,
+      :caption,
+      :created,
+      :deactivate_on,
+      :description,
+      :images,
+      :livemode,
+      :metadata,
+      :name,
+      :package_dimensions,
+      :shippable,
+      :statement_descriptor,
+      :type,
+      :unit_label,
+      :updated,
+      :url
+    ] }
+
+    it "includes all retreived attributes" do
+      expect(mock_object.keys).to eql(known_attributes)
+    end
+  end
+
+end

data/spec/shared_stripe_examples/refund_examples.rb

@@ -30,9 +30,7 @@ shared_examples 'Refund API' do
         description: 'card charge'
       )
 
-      Stripe::Refund.create(
-        charge: charge.id
-      )
+      Stripe::Refund.create(charge: charge.id)
 
       charge = Stripe::Charge.retrieve(charge.id)
 
@@ -262,7 +260,7 @@ shared_examples 'Refund API' do
       end
 
       it "stores all charges in memory" do
-        expect(Stripe::Refund.all.data.map(&:id)).to eq([@refund2.id, @refund.id])
+        expect(Stripe::Refund.list.data.map(&:id)).to eq([@refund2.id, @refund.id])
       end
 
       it "defaults count to 10 charges" do
@@ -275,7 +273,7 @@ shared_examples 'Refund API' do
           Stripe::Refund.create(charge: charge.id)
         end
 
-        expect(Stripe::Refund.all.data.count).to eq(10)
+        expect(Stripe::Refund.list.data.count).to eq(10)
       end
 
       it "is marked as having more when more objects exist" do
@@ -288,12 +286,12 @@ shared_examples 'Refund API' do
           Stripe::Refund.create(charge: charge.id)
         end
 
-        expect(Stripe::Refund.all.has_more).to eq(true)
+        expect(Stripe::Refund.list.has_more).to eq(true)
       end
 
       context "when passing limit" do
         it "gets that many charges" do
-          expect(Stripe::Refund.all(limit: 1).count).to eq(1)
+          expect(Stripe::Refund.list(limit: 1).count).to eq(1)
         end
       end
     end
@@ -318,13 +316,13 @@ shared_examples 'Refund API' do
         Stripe::Refund.create(charge: charge.id)
       end
 
-      all = Stripe::Refund.all
+      all_refunds = Stripe::Refund.list
       default_limit = 10
-      half = Stripe::Refund.all(starting_after: all.data.at(1).id)
+      half = Stripe::Refund.list(starting_after: all_refunds.data.at(1).id)
 
       expect(half).to be_a(Stripe::ListObject)
       expect(half.data.count).to eq(default_limit)
-      expect(half.data.first.id).to eq(all.data.at(2).id)
+      expect(half.data.first.id).to eq(all_refunds.data.at(2).id)
     end
 
     describe "idempotency" do
@@ -337,26 +335,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
@@ -372,7 +376,8 @@ shared_examples 'Refund API' do
         description: 'card charge'
       )
 
-      charge = charge.refund(amount: 999)
+      Stripe::Refund.create(charge: charge.id, amount: 999)
+      charge.refresh
 
       expect(charge.refunded).to eq(true)
       expect(charge.refunds.data.first.amount).to eq(999)
@@ -386,10 +391,10 @@ shared_examples 'Refund API' do
         source: stripe_helper.generate_card_token,
         description: 'card charge'
       )
-      refund = charge.refund
+      refund = Stripe::Refund.create(charge: charge.id)
 
       expect(charge.id).to match(/^(test_)?ch/)
-      expect(refund.id).to eq(charge.id)
+      expect(refund.charge).to eq(charge.id)
     end
 
     it "creates a stripe refund with a refund ID" do
@@ -399,10 +404,12 @@ shared_examples 'Refund API' do
         source: stripe_helper.generate_card_token,
         description: 'card charge'
       )
-      refund = charge.refund
 
-      expect(refund.refunds.data.count).to eq 1
-      expect(refund.refunds.data.first.id).to match(/^test_re/)
+      Stripe::Refund.create(charge: charge.id)
+      refunds = Stripe::Refund.list(charge: charge.id)
+
+      expect(refunds.data.count).to eq 1
+      expect(refunds.data.first.id).to match(/^test_re/)
     end
 
     it "creates a stripe refund with a status" do
@@ -412,10 +419,12 @@ shared_examples 'Refund API' do
         source: stripe_helper.generate_card_token,
         description: 'card charge'
       )
-      refund = charge.refund
 
-      expect(refund.refunds.data.count).to eq 1
-      expect(refund.refunds.data.first.status).to eq("succeeded")
+      Stripe::Refund.create(charge: charge.id)
+      refunds = Stripe::Refund.list(charge: charge.id)
+
+      expect(refunds.data.count).to eq 1
+      expect(refunds.data.first.status).to eq("succeeded")
     end
 
     it "creates a stripe refund with a different balance transaction than the charge" do
@@ -425,9 +434,10 @@ shared_examples 'Refund API' do
         source: stripe_helper.generate_card_token,
         description: 'card charge'
       )
-      refund = charge.refund
+      Stripe::Refund.create(charge: charge.id)
+      refunds = Stripe::Refund.list(charge: charge.id)
 
-      expect(charge.balance_transaction).not_to eq(refund.refunds.data.first.balance_transaction)
+      expect(charge.balance_transaction).not_to eq(refunds.data.first.balance_transaction)
     end
 
     it "creates a refund off a charge", :live => true do

data/spec/shared_stripe_examples/setup_intent_examples.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+shared_examples 'SetupIntent API' do
+
+  it "creates a stripe setup_intent" do
+    setup_intent = Stripe::SetupIntent.create()
+
+    expect(setup_intent.id).to match(/^test_si/)
+    expect(setup_intent.metadata.to_hash).to eq({})
+    expect(setup_intent.status).to eq('requires_payment_method')
+  end
+
+  describe "listing setup_intent" do
+    before do
+      3.times do
+        Stripe::SetupIntent.create()
+      end
+    end
+
+    it "without params retrieves all stripe setup_intent" do
+      expect(Stripe::SetupIntent.list.count).to eq(3)
+    end
+
+    it "accepts a limit param" do
+      expect(Stripe::SetupIntent.list(limit: 2).count).to eq(2)
+    end
+  end
+
+  it "retrieves a stripe setup_intent" do
+    original = Stripe::SetupIntent.create()
+    setup_intent = Stripe::SetupIntent.retrieve(original.id)
+
+    expect(setup_intent.id).to eq(original.id)
+    expect(setup_intent.metadata.to_hash).to eq(original.metadata.to_hash)
+  end
+
+  it "cannot retrieve a setup_intent that doesn't exist" do
+    expect { Stripe::SetupIntent.retrieve('nope') }.to raise_error {|e|
+      expect(e).to be_a Stripe::InvalidRequestError
+      expect(e.param).to eq('setup_intent')
+      expect(e.http_status).to eq(404)
+    }
+  end
+
+  it "confirms a stripe setup_intent" do
+    setup_intent = Stripe::SetupIntent.create()
+    confirmed_setup_intent = setup_intent.confirm()
+    expect(confirmed_setup_intent.status).to eq("succeeded")
+  end
+
+  it "cancels a stripe setup_intent" do
+    setup_intent = Stripe::SetupIntent.create()
+    confirmed_setup_intent = setup_intent.cancel()
+    expect(confirmed_setup_intent.status).to eq("canceled")
+  end
+
+  it "updates a stripe setup_intent" do
+    original = Stripe::SetupIntent.create()
+    setup_intent = Stripe::SetupIntent.retrieve(original.id)
+
+    setup_intent.metadata[:foo] = :bar
+    setup_intent.save
+
+    updated = Stripe::SetupIntent.retrieve(original.id)
+
+    expect(updated.metadata[:foo]).to eq(:bar)
+  end
+end

data/spec/shared_stripe_examples/subscription_examples.rb

@@ -1,49 +1,61 @@
 require 'spec_helper'
+require 'securerandom'
 
-shared_examples 'Customer Subscriptions' do
+shared_examples 'Customer Subscriptions with plans' do
+  let(:gen_card_tk) { stripe_helper.generate_card_token }
 
-  def gen_card_tk
-    stripe_helper.generate_card_token
-  end
+  let(:product) { stripe_helper.create_product }
+  let(:plan_attrs) { {id: 'silver', product: product.id, amount: 4999, currency: 'usd'} }
+  let(:plan) { stripe_helper.create_plan(plan_attrs) }
+
+  let(:plan_with_trial_attrs) { {id: 'trial', product: product.id, amount: 999, trial_period_days: 14 } }
+  let(:plan_with_trial) { stripe_helper.create_plan(plan_with_trial_attrs) }
+
+  let(:free_plan) { stripe_helper.create_plan(id: 'free', product: product.id, amount: 0) }
 
   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')
+    it "adds a new subscription to customer with none using items", live: true do
+      plan
       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" } })
+      subscription = Stripe::Subscription.create({
+        customer: customer.id,
+        items: [{ plan: 'silver' }],
+        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" )
+      expect(subscription.object).to eq('subscription')
+      expect(subscription.plan.to_hash).to eq(plan.to_hash)
+      expect(subscription.metadata.foo).to eq("bar")
+      expect(subscription.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" )
+      subscriptions = Stripe::Subscription.list(customer: customer.id)
+      charges = Stripe::Charge.list(customer: customer.id)
+
+      expect(subscriptions.data).to_not be_empty
+      expect(subscriptions.count).to eq(1)
+      expect(subscriptions.data.length).to eq(1)
+      expect(charges.data.length).to eq(1)
+      expect(customer.currency).to eq("usd")
+
+      expect(subscriptions.data.first.id).to eq(subscription.id)
+      expect(subscriptions.data.first.plan.to_hash).to eq(plan.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" )
     end
 
-    it "adds a new subscription to customer with none", :live => true do
-      plan = stripe_helper.create_plan(id: 'silver', product: { name: 'Silver Plan' },
-                                       amount: 4999, currency: 'usd')
+    it "adds a new subscription to customer with none", live: true do
+      plan
       customer = Stripe::Customer.create(source: gen_card_tk)
+      subscriptions = Stripe::Subscription.list(customer: customer.id)
 
-      expect(customer.subscriptions.data).to be_empty
-      expect(customer.subscriptions.count).to eq(0)
+      expect(subscriptions.data).to be_empty
+      expect(subscriptions.count).to eq(0)
 
       sub = Stripe::Subscription.create({ plan: 'silver', customer: customer.id, metadata: { foo: "bar", example: "yes" } })
 
@@ -53,26 +65,30 @@ shared_examples 'Customer Subscriptions' do
       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)
+      subscriptions = Stripe::Subscription.list(customer: customer.id)
+      charges = Stripe::Charge.list(customer: customer.id)
+
+      expect(subscriptions.data).to_not be_empty
+      expect(subscriptions.count).to eq(1)
+      expect(subscriptions.data.length).to eq(1)
+      expect(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" )
+      expect(subscriptions.data.first.id).to eq(sub.id)
+      expect(subscriptions.data.first.plan.to_hash).to eq(plan.to_hash)
+      expect(subscriptions.data.first.customer).to eq(customer.id)
+      expect(subscriptions.data.first.billing).to eq('charge_automatically')
+      expect(subscriptions.data.first.metadata.foo).to eq( "bar" )
+      expect(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')
+      plan
       customer = Stripe::Customer.create(source: gen_card_tk)
+      subscriptions = Stripe::Subscription.list(customer: customer.id)
 
-      expect(customer.subscriptions.data).to be_empty
-      expect(customer.subscriptions.count).to eq(0)
+      expect(subscriptions.data).to be_empty
+      expect(subscriptions.count).to eq(0)
 
       sub = Stripe::Subscription.create({ plan: 'silver', customer: customer, metadata: { foo: "bar", example: "yes" } })
 
@@ -83,121 +99,149 @@ shared_examples 'Customer Subscriptions' do
       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)
+      subscriptions = Stripe::Subscription.list(customer: customer.id)
+      charges = Stripe::Charge.list(customer: customer.id)
+
+      expect(subscriptions.data).to_not be_empty
+      expect(subscriptions.count).to eq(1)
+      expect(subscriptions.data.length).to eq(1)
+      expect(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(subscriptions.data.first.id).to eq(sub.id)
+      expect(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" )
+      expect(subscriptions.data.first.customer).to eq(customer.id)
+      expect(subscriptions.data.first.billing).to eq('charge_automatically')
+      expect(subscriptions.data.first.metadata.foo).to eq( "bar" )
+      expect(subscriptions.data.first.metadata.example).to eq( "yes" )
+    end
+
+    it "adds a new subscription with payment method provided as default" do
+      plan
+      customer = Stripe::Customer.create(source: gen_card_tk)
+      payment_method = Stripe::PaymentMethod.create(
+        type: 'card',
+        card: {
+          number: 4242_4242_4242_4242,
+          exp_month: 9,
+          exp_year: (Time.now.year + 5),
+          cvc: 999
+        }
+      )
+      sub = Stripe::Subscription.create(
+        plan: 'silver',
+        customer: customer,
+        metadata: { foo: "bar", example: "yes" },
+        collection_method: 'send_invoice',
+        default_payment_method: payment_method.id,
+      )
+
+      subscriptions = Stripe::Subscription.list(customer: customer.id)
+      expect(subscriptions.count).to eq(1)
+      expect(subscriptions.data.first.id).to eq(sub.id)
+      expect(subscriptions.data.first.collection_method).to eq('send_invoice')
+      expect(subscriptions.data.first.default_payment_method).to eq(payment_method.id)
     end
 
     it "adds a new subscription to customer (string/symbol agnostic)" do
       customer = Stripe::Customer.create(source: gen_card_tk)
-      expect(customer.subscriptions.count).to eq(0)
+      subscriptions = Stripe::Subscription.list(customer: customer.id)
+      expect(subscriptions.count).to eq(0)
 
-      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
+      sub = Stripe::Subscription.create({plan: plan.id, customer: customer.id })
 
-      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)
+      subscriptions = Stripe::Subscription.list(customer: customer.id)
       expect(sub.plan.to_hash).to eq(plan.to_hash)
-      expect(customer.subscriptions.count).to eq(2)
+      expect(subscriptions.count).to eq(1)
     end
 
     it 'creates a charge for the customer', live: true do
-      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" } })
+      Stripe::Subscription.create({ plan: plan.id, customer: customer.id, metadata: { foo: "bar", example: "yes" } })
       customer = Stripe::Customer.retrieve(customer.id)
+      charges = Stripe::Charge.list(customer: customer.id)
 
-      expect(customer.charges.data.length).to eq(1)
-      expect(customer.charges.data.first.amount).to eq(4999)
+      expect(charges.data.length).to eq(1)
+      expect(charges.data.first.amount).to eq(4999)
     end
 
     it 'contains coupon object', live: true do
-      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)
       customer = Stripe::Customer.retrieve(customer.id)
 
-      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.coupon.id).to eq(coupon.id)
+      subscriptions = Stripe::Subscription.list(customer: customer.id)
+
+      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).to be_a(Stripe::Discount)
+      expect(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', 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|
-                               expect(e).to be_a Stripe::InvalidRequestError
-                               expect(e.http_status).to eq(400)
-                               expect(e.message).to eq('No such coupon: none')
-                             }
+      expect {
+        Stripe::Subscription.create(plan: plan.id, customer: customer.id, coupon: 'none')
+      }.to raise_error {|e|
+        expect(e).to be_a Stripe::InvalidRequestError
+        expect(e.http_status).to eq(400)
+        expect(e.message).to eq('No such coupon: none')
+      }
     end
 
     it "correctly sets quantity, application_fee_percent and tax_percent" do
-      Stripe::Plan.create(
-        :amount => 2500,
-        :interval => 'month',
-        :product => {
-          :name => 'Test plan'
-        },
-        :currency => 'usd',
-        :id => 'silver',
-        :statement_description => "testPlan"
-      )
       customer = Stripe::Customer.create(id: 'test_customer_sub', source: gen_card_tk)
 
       subscription = Stripe::Subscription.create({
-        plan: "silver", customer: customer.id, quantity: 2, application_fee_percent: 10, tax_percent: 20})
+        plan: plan.id,
+        customer: customer.id,
+        quantity: 2,
+        application_fee_percent: 10,
+        tax_percent: 20
+      })
       expect(subscription.quantity).to eq(2)
       expect(subscription.application_fee_percent).to eq(10)
       expect(subscription.tax_percent).to eq(20)
     end
 
+    it "correctly sets pending invoice item interval" do
+      customer = Stripe::Customer.create(id: 'test_customer_sub', source: gen_card_tk)
+
+      subscription = Stripe::Subscription.create({
+        plan: plan.id,
+        customer: customer.id,
+        quantity: 2,
+        pending_invoice_item_interval: { interval: 'month', interval_count: 1 }
+      })
+
+      expect(subscription.pending_invoice_item_interval.interval).to eq 'month'
+      expect(subscription.pending_invoice_item_interval.interval_count).to eq 1
+    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 })
+      subscription = Stripe::Subscription.create({ plan: plan.id, 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 })
+      subscription = Stripe::Subscription.create({ plan: plan.id, 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')
-      customer = Stripe::Customer.create(id: 'test_customer_sub', source: gen_card_tk, plan: 'gold')
+      silver =  stripe_helper.create_plan(id: 'silver', product: product.id)
+      gold =    stripe_helper.create_plan(id: 'gold', product: product.id)
+      customer = Stripe::Customer.create(id: 'test_customer_sub', product: product.id, source: gen_card_tk, plan: 'gold')
 
       sub = Stripe::Subscription.create({ plan: 'silver', customer: customer.id })
 
@@ -218,7 +262,7 @@ shared_examples 'Customer Subscriptions' do
     end
 
     it "subscribes a cardless customer when specifing a card token" do
-      plan = stripe_helper.create_plan(id: 'enterprise', amount: 499)
+      plan = stripe_helper.create_plan(id: 'enterprise', product: product.id, amount: 499)
       customer = Stripe::Customer.create(id: 'cardless')
 
       sub = Stripe::Subscription.create(plan: 'enterprise', customer: customer.id, source: gen_card_tk)
@@ -247,10 +291,10 @@ shared_examples 'Customer Subscriptions' do
     end
 
     it "throws an error when subscribing a customer with no card" do
-      plan = stripe_helper.create_plan(id: 'enterprise', amount: 499)
+      plan = stripe_helper.create_plan(id: 'enterprise', product: product.id, amount: 499)
       customer = Stripe::Customer.create(id: 'cardless')
 
-      expect { Stripe::Subscription.create({ plan: 'enterprise', customer: customer.id }) }.to raise_error {|e|
+      expect { Stripe::Subscription.create({ plan: plan.id, customer: customer.id }) }.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
@@ -261,12 +305,14 @@ shared_examples 'Customer Subscriptions' do
     end
 
     it "throws an error when subscribing the customer to a second plan in a different currency" do
-      usd_plan = stripe_helper.create_plan(id: 'enterprise_usd', amount: 499, currency: 'usd')
       customer = Stripe::Customer.create(id: 'test_customer_sub', source: gen_card_tk)
-      usd_subscription = Stripe::Subscription.create({ plan: 'enterprise_usd', customer: customer.id })
 
-      eur_plan = stripe_helper.create_plan(id: 'enterprise_eur', amount: 499, currency: 'eur')
-      expect { Stripe::Subscription.create({ plan: 'enterprise_eur', customer: customer.id }) }.to raise_error {|e|
+      expect(plan.currency).to eql("usd")
+      usd_subscription = Stripe::Subscription.create({ plan: plan.id, customer: customer.id })
+
+      eur_plan = stripe_helper.create_plan(plan_attrs.merge(id: "plan_EURO", currency: 'eur'))
+      expect(eur_plan.currency).to eql("eur")
+      expect { Stripe::Subscription.create({ plan: eur_plan.id, customer: customer.id }) }.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
@@ -274,7 +320,7 @@ 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)
+      plan = stripe_helper.create_plan(id: 'trial', product: product.id, 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|
@@ -286,35 +332,34 @@ shared_examples 'Customer Subscriptions' do
     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')
-
-      sub = Stripe::Subscription.create({ plan: 'trial', customer: customer.id })
+      sub = Stripe::Subscription.create({ plan: plan_with_trial.id, customer: customer.id })
 
       expect(sub.object).to eq('subscription')
-      expect(sub.plan.to_hash).to eq(plan.to_hash)
+      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
 
-      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)
+      customer = Stripe::Customer.retrieve(customer.id)
+      subscriptions = Stripe::Subscription.list(customer: customer.id)
+      charges = Stripe::Charge.list(customer: customer.id)
 
-      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)
+      expect(subscriptions.data).to_not be_empty
+      expect(subscriptions.count).to eq(1)
+      expect(subscriptions.data.length).to eq(1)
+
+      expect(subscriptions.data.first.id).to eq(sub.id)
+      expect(subscriptions.data.first.plan.to_hash).to eq(plan_with_trial.to_hash)
+      expect(subscriptions.data.first.customer).to eq(customer.id)
+      expect(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 })
+      sub = Stripe::Subscription.create({ items: [ { plan: plan_with_trial.id } ], customer: customer.id })
 
       expect(sub.object).to eq('subscription')
-      expect(sub.items.data[0].plan.to_hash).to eq(plan.to_hash)
+      expect(sub.items.data[0].plan.to_hash).to eq(plan_with_trial.to_hash)
       # no idea how to fix this one
       # expect(sub.trial_end - sub.trial_start).to eq(14 * 86400)
 
@@ -324,17 +369,17 @@ shared_examples 'Customer Subscriptions' do
       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.items.data.first.plan.to_hash).to eq(plan_with_trial.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
-      plan = stripe_helper.create_plan(id: 'free_tier', amount: 0)
+      plan = stripe_helper.create_plan(id: 'free_tier', product: product.id, amount: 0)
       customer = Stripe::Customer.create(id: 'cardless')
 
-      sub = Stripe::Subscription.create({ plan: 'free_tier', customer: customer.id })
+      sub = Stripe::Subscription.create({ plan: plan.id, customer: customer.id })
 
       expect(sub.object).to eq('subscription')
       expect(sub.plan.to_hash).to eq(plan.to_hash)
@@ -350,36 +395,59 @@ shared_examples 'Customer Subscriptions' do
     end
 
     it "overrides trial length when trial end is 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
 
-      sub = Stripe::Subscription.create({ plan: 'trial', customer: customer.id, trial_end: trial_end })
+      sub = Stripe::Subscription.create({ plan: plan_with_trial.id, customer: customer.id, trial_end: trial_end })
+
+      expect(sub.object).to eq('subscription')
+      expect(sub.plan.to_hash).to eq(plan_with_trial.to_hash)
+      expect(sub.current_period_end).to eq(trial_end)
+      expect(sub.trial_end).to eq(trial_end)
+    end
+
+    it "does not override trial end when trial end is not set" do
+      product = stripe_helper.create_product(name: 'Trial')
+      plan = stripe_helper.create_plan(id: 'trial', amount: 999,
+                                       trial_period_days: 14, product: product.id)
+      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)
 
-      sub = Stripe::Subscription.create({ plan: 'trial', customer: customer.id, trial_end: "now" })
+      sub = Stripe::Subscription.create({ plan: plan_with_trial.id, customer: customer.id, trial_end: "now" })
 
       expect(sub.object).to eq('subscription')
-      expect(sub.plan.to_hash).to eq(plan.to_hash)
+      expect(sub.plan.to_hash).to eq(plan_with_trial.to_hash)
       expect(sub.status).to eq('active')
       expect(sub.trial_start).to be_nil
       expect(sub.trial_end).to be_nil
     end
 
     it "raises error when trial_end is not an integer or 'now'" do
-      plan = stripe_helper.create_plan(id: 'trial', amount: 999, trial_period_days: 14)
       customer = Stripe::Customer.create(id: 'cus_trial')
 
-      expect { Stripe::Subscription.create({ plan: 'trial', customer: customer.id, trial_end: "gazebo" }) }.to raise_error {|e|
+      expect { Stripe::Subscription.create({ plan: plan_with_trial.id, customer: customer.id, trial_end: "gazebo" }) }.to raise_error {|e|
         expect(e).to be_a Stripe::InvalidRequestError
         expect(e.http_status).to eq(400)
         expect(e.message).to eq("Invalid timestamp: must be an integer")
@@ -387,11 +455,10 @@ shared_examples 'Customer Subscriptions' do
     end
 
     it "raises error when trial_end is set to a time in the past" do
-      plan = stripe_helper.create_plan(id: 'trial', amount: 999, trial_period_days: 14)
       customer = Stripe::Customer.create(id: 'past_trial')
       trial_end = Time.now.utc.to_i - 3600
 
-      expect { Stripe::Subscription.create({ plan: 'trial', customer: customer.id, trial_end: trial_end }) }.to raise_error {|e|
+      expect { Stripe::Subscription.create({ plan: plan_with_trial.id, customer: customer.id, trial_end: trial_end }) }.to raise_error {|e|
         expect(e).to be_a Stripe::InvalidRequestError
         expect(e.http_status).to eq(400)
         expect(e.message).to eq("Invalid timestamp: must be an integer Unix timestamp in the future")
@@ -399,11 +466,10 @@ shared_examples 'Customer Subscriptions' do
     end
 
     it "raises error when trial_end is set to a time more than five years in the future" do
-      plan = stripe_helper.create_plan(id: 'trial', amount: 999, trial_period_days: 14)
       customer = Stripe::Customer.create(id: 'long_trial')
       trial_end = Time.now.utc.to_i + 31557600*5 + 3600 # 5 years + 1 hour
 
-      expect { Stripe::Subscription.create({ plan: 'trial', customer: customer.id, trial_end: trial_end }) }.to raise_error {|e|
+      expect { Stripe::Subscription.create({ plan: plan_with_trial.id, customer: customer.id, trial_end: trial_end }) }.to raise_error {|e|
         expect(e).to be_a Stripe::InvalidRequestError
         expect(e.http_status).to eq(400)
         expect(e.message).to eq("Invalid timestamp: can be no more than five years in the future")
@@ -411,11 +477,10 @@ 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 })
+      sub = Stripe::Subscription.create({ plan: plan.id, 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)
@@ -423,17 +488,11 @@ shared_examples 'Customer Subscriptions' do
     end
 
     it 'when plan defined inside items', live: true do
-      plan = stripe_helper.create_plan(id: 'BASE_PRICE_PLAN1')
+      plan = stripe_helper.create_plan(id: 'BASE_PRICE_PLAN1', product: product.id)
 
-      plan2 = stripe_helper.create_plan(id: 'PER_USER_PLAN1')
+      plan2 = stripe_helper.create_plan(id: 'PER_USER_PLAN1', product: product.id)
       customer = Stripe::Customer.create(
-        source: {
-          object: 'card',
-          exp_month: 11,
-          exp_year: 2019,
-          number: '4242424242424242',
-          cvc: '123'
-        }
+        source: stripe_helper.generate_card_token
       )
       subscription = Stripe::Subscription.create(
         customer: customer.id,
@@ -452,9 +511,9 @@ shared_examples 'Customer Subscriptions' do
     end
 
     it 'when plan defined inside items for trials with no card', live: true do
-      plan = stripe_helper.create_plan(id: 'BASE_PRICE_PLAN1')
+      plan = stripe_helper.create_plan(id: 'BASE_PRICE_PLAN1', product: product.id)
 
-      plan2 = stripe_helper.create_plan(id: 'PER_USER_PLAN1')
+      plan2 = stripe_helper.create_plan(id: 'PER_USER_PLAN1', product: product.id)
       customer = Stripe::Customer.create
       trial_end = Time.now.utc.to_i + 3600
 
@@ -472,12 +531,113 @@ 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
+      product = stripe_helper.create_product(id: 'invoice_billing')
+      plan = stripe_helper.create_plan(id: 'silver', product: product.id,
+                                       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 => SecureRandom.hex
+    }}
+
+    it "adds a new subscription to customer with identical idempotency key" do
+      product = stripe_helper.create_product(name: 'Silver Product')
+      plan = stripe_helper.create_plan(id: 'silver', product: product.id,
+                                       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)
+
+      subscription_header = {
+        :idempotency_key => "uniq_idempotency_key_#{customer.id}"
+      }
+
+      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
+      product = stripe_helper.create_product(name: 'Silver Product')
+      plan = stripe_helper.create_plan(id: 'silver', product: product.id,
+                                       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_header_1 = {
+        :idempotency_key => SecureRandom.hex
+      }
+      sub_header_2 = {
+        :idempotency_key => SecureRandom.hex
+      }
+
+      sub1 = Stripe::Subscription.create({ items: [{ plan: 'silver' }], customer: customer.id }, sub_header_1)
+      sub2 = Stripe::Subscription.create({ items: [{ plan: 'silver' }], customer: customer.id }, sub_header_2)
+      expect(sub1).not_to eq(sub2)
+    end
+
+    it "accepts a hash of items" do
+      product = stripe_helper.create_product(name: 'Silver Product')
+      silver = stripe_helper.create_plan(id: 'silver', product: product.id)
+      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_truthy
+    end
+
+    it 'accepts default_tax_rates param' do
+      tax_rate = Stripe::TaxRate.create(
+        display_name: 'VAT',
+        description: 'VAT Germany',
+        jurisdiction: 'DE',
+        percentage: 19.0,
+        inclusive: false,
+      )
+      product = stripe_helper.create_product(name: 'Silver Product')
+      silver = stripe_helper.create_plan(id: 'silver', product: product.id)
+      customer = Stripe::Customer.create(source: gen_card_tk)
+      subscription = Stripe::Subscription.create(
+        customer: customer.id,
+        items: [{ plan: silver.id }],
+        default_tax_rates: [ tax_rate ]
+      )
+
+      aggregate_failures do
+        expect(subscription.default_tax_rates.length).to eq(1)
+        expect(subscription.default_tax_rates.first.id).to eq(tax_rate.id)
+      end
+    end
   end
 
   context "updating a subscription" do
     it 'raises invalid request exception when subscription is cancelled' do
-      stripe_helper.create_plan(id: 'the truth')
-      customer = Stripe::Customer.create(source: gen_card_tk, plan: 'the truth')
+      customer = Stripe::Customer.create(source: gen_card_tk, plan: plan.id)
 
       subscription = Stripe::Subscription.retrieve(customer.subscriptions.data.first.id)
       subscription.delete
@@ -490,24 +650,22 @@ shared_examples 'Customer Subscriptions' do
     end
 
     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 = Stripe::Subscription.create({ items: [ { plan: plan.id } ], 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
+      expect(sub.cancel_at_period_end).to be_truthy
     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')
+      customer = Stripe::Customer.create(id: 'test_customer_sub', source: gen_card_tk, plan: plan.id)
 
+      gold_plan = stripe_helper.create_plan(id: 'gold', product: product.id)
       sub = Stripe::Subscription.retrieve(customer.subscriptions.data.first.id)
-      sub.plan = 'gold'
+      sub.plan = gold_plan.id
       sub.quantity = 5
       sub.metadata.foo     = "bar"
       sub.metadata.example = "yes"
@@ -515,7 +673,7 @@ shared_examples 'Customer Subscriptions' do
       expect(sub.save).to be_truthy
 
       expect(sub.object).to eq('subscription')
-      expect(sub.plan.to_hash).to eq(gold.to_hash)
+      expect(sub.plan.to_hash).to eq(gold_plan.to_hash)
       expect(sub.quantity).to eq(5)
       expect(sub.metadata.foo).to eq( "bar" )
       expect(sub.metadata.example).to eq( "yes" )
@@ -526,16 +684,15 @@ shared_examples 'Customer Subscriptions' do
       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_hash).to eq(gold.to_hash)
+      expect(customer.subscriptions.data.first.plan.to_hash).to eq(gold_plan.to_hash)
       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)
+      customer = Stripe::Customer.create(id: 'test_customer_sub', source: gen_card_tk, plan: plan.id)
 
+      gold_plan = stripe_helper.create_plan(id: 'gold', product: product.id)
+      addon_plan = stripe_helper.create_plan(id: 'addon_plan', product: product.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
@@ -556,12 +713,12 @@ shared_examples 'Customer Subscriptions' do
     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 }])
+      addon1_plan = stripe_helper.create_plan(id: 'addon1', product: product.id)
+      sub = Stripe::Subscription.create(customer: customer.id, items: [{ plan: plan.id }, { plan: addon1_plan.id }])
+
+      gold_plan = stripe_helper.create_plan(id: 'gold', product: product.id)
+      addon2_plan = stripe_helper.create_plan(id: 'addon2', product: product.id)
 
       sub.items = [{ plan: gold_plan.id, quantity: 2 }, { plan: addon2_plan.id, quantity: 2 }]
       expect(sub.save).to be_truthy
@@ -581,9 +738,87 @@ shared_examples 'Customer Subscriptions' do
       expect(customer.subscriptions.data.first.items.data[1].plan.to_hash).to eq(addon2_plan.to_hash)
     end
 
+    it "updates a subscription's cancel_at_period_end" do
+      silver = stripe_helper.create_plan(id: 'silver', product: product.id)
+      customer = Stripe::Customer.create(id: 'test_customer_sub', source: gen_card_tk)
+
+      sub = Stripe::Subscription.create({ items: [ { plan: 'silver' } ], customer: customer.id })
+
+      expect(sub.cancel_at_period_end).to be_falsey
+
+      sub.cancel_at_period_end = true
+      sub.save
+
+      expect(sub.save).to be_truthy
+      expect(sub.cancel_at_period_end).to be_truthy
+      expect(sub.canceled_at).to be_truthy
+
+      sub.cancel_at_period_end = false
+      sub.save
+
+      expect(sub.save).to be_truthy
+      expect(sub.cancel_at_period_end).to be_falsey
+      expect(sub.canceled_at).to be_falsey
+    end
+
+    it "updates a subscription's pending invoice item interval" do
+      customer = Stripe::Customer.create(id: 'test_customer_sub', source: gen_card_tk)
+
+      subscription = Stripe::Subscription.create({
+        plan: plan.id,
+        customer: customer.id,
+        quantity: 2,
+        pending_invoice_item_interval: { interval: 'month', interval_count: 1 }
+      })
+
+      expect(subscription.pending_invoice_item_interval.interval).to eq 'month'
+      expect(subscription.pending_invoice_item_interval.interval_count).to eq 1
+
+      subscription.pending_invoice_item_interval = { interval: 'week', interval_count: 3 }
+      subscription.save
+
+      expect(subscription.pending_invoice_item_interval.interval).to eq 'week'
+      expect(subscription.pending_invoice_item_interval.interval_count).to eq 3
+    end
+
+    it "updates a subscription's default payment method" do
+      plan
+      customer = Stripe::Customer.create(source: gen_card_tk)
+      payment_method_card = Stripe::PaymentMethod.create(
+        type: 'card',
+        card: {
+          number: 4242_4242_4242_4242,
+          exp_month: 9,
+          exp_year: (Time.now.year + 5),
+          cvc: 999
+        }
+      )
+      payment_method_sepa = Stripe::PaymentMethod.create(
+        type: 'sepa_debit',
+        sepa_debit: {iban: 'DE89370400440532013000'},
+      )
+      subscription = Stripe::Subscription.create(
+        plan: 'silver',
+        customer: customer,
+        metadata: { foo: "bar", example: "yes" },
+        default_payment_method: payment_method_card.id,
+      )
+
+      subscriptions = Stripe::Subscription.list(customer: customer)
+      expect(subscriptions.data.first.default_payment_method).to eq(payment_method_card.id)
+
+      Stripe::Subscription.update(
+        subscription.id,
+        default_payment_method: payment_method_sepa.id,
+        collection_method: 'send_invoice',
+      )
+
+      subscriptions = Stripe::Subscription.list(customer: customer)
+      expect(subscriptions.data.first.collection_method).to eq('send_invoice')
+      expect(subscriptions.data.first.default_payment_method).to eq(payment_method_sepa.id)
+    end
+
     it 'when adds coupon', live: true do
-      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)
@@ -592,13 +827,11 @@ 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', 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)
 
@@ -613,8 +846,6 @@ 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)
@@ -628,8 +859,7 @@ shared_examples 'Customer Subscriptions' do
     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')
+      customer = Stripe::Customer.create(id: 'cardless', plan: free_plan.id)
 
       sub = Stripe::Subscription.retrieve(customer.subscriptions.data.first.id)
       sub.plan = 'gazebo'
@@ -643,75 +873,59 @@ shared_examples 'Customer Subscriptions' do
       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)
+      expect(customer.subscriptions.data.first.plan.to_hash).to eq(free_plan.to_hash)
     end
 
     it "throws an error when subscription does not exist" do
-      free = stripe_helper.create_plan(id: 'free', amount: 0)
-      customer = Stripe::Customer.create(id: 'cardless', plan: 'free')
-
-      expect { Stripe::Subscription.retrieve("gazebo") }.to raise_error {|e|
+      expect(stripe_helper.list_subscriptions(50).keys).to_not include("sub_NONEXIST")
+      expect { Stripe::Subscription.retrieve("sub_NONEXIST") }.to raise_error {|e|
         expect(e).to be_a Stripe::InvalidRequestError
         expect(e.http_status).to eq(404)
         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)
     end
 
     [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
+      it "raises an error when updating a customer with no card, and plan trial_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')
+          free_plan
+          paid_plan = stripe_helper.create_plan(id: 'enterprise', product: product.id, amount: 499, trial_period_days: trial_period_days)
+          customer = Stripe::Customer.create(description: 'cardless', plan: free_plan.id)
 
           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)
+          sub.plan = paid_plan.id
+
+          expect {
+            sub.save
+          }.to raise_error(Stripe::InvalidRequestError, "This customer has no attached payment source")
         ensure
           customer.delete if customer
-          paid.delete if paid
-          free.delete if free
+          paid_plan.delete if paid_plan
+          free_plan.delete if free_plan
         end
       end
     end
 
     it 'updates a subscription if the customer has a free trial', live: true do
-      stripe_helper.create_plan(id: 'enterprise', amount: 499)
       trial_end = Time.now.utc.to_i + 3600
-      customer  = Stripe::Customer.create(plan: 'enterprise',
-                                          trial_end: trial_end)
-      subscription          = customer.subscriptions.first
+      customer = Stripe::Customer.create(plan: plan.id, trial_end: trial_end)
+      subscription = customer.subscriptions.first
       subscription.quantity = 2
       subscription.save
       expect(subscription.quantity).to eq(2)
     end
 
     it "updates a customer with no card to a plan with a free trial" do
-      free = stripe_helper.create_plan(id: 'free', amount: 0)
-      trial = stripe_helper.create_plan(id: 'trial', amount: 999, trial_period_days: 14)
-      customer = Stripe::Customer.create(id: 'cardless', plan: 'free')
+      free_plan
+      trial_plan = stripe_helper.create_plan(id: 'trial', product: product.id, amount: 999, trial_period_days: 14)
+      customer = Stripe::Customer.create(id: 'cardless', plan: free_plan.id)
 
       sub = Stripe::Subscription.retrieve(customer.subscriptions.data.first.id)
-      sub.plan = 'trial'
+      sub.plan = trial_plan.id
       sub.save
 
       expect(sub.object).to eq('subscription')
-      expect(sub.plan.to_hash).to eq(trial.to_hash)
+      expect(sub.plan.to_hash).to eq(trial_plan.to_hash)
 
       customer = Stripe::Customer.retrieve('cardless')
       expect(customer.subscriptions.data).to_not be_empty
@@ -719,21 +933,21 @@ shared_examples 'Customer Subscriptions' do
       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_hash).to eq(trial.to_hash)
+      expect(customer.subscriptions.data.first.plan.to_hash).to eq(trial_plan.to_hash)
       expect(customer.subscriptions.data.first.customer).to eq(customer.id)
     end
 
     it "updates a customer with no card to a free plan" do
-      free = stripe_helper.create_plan(id: 'free', amount: 0)
-      gratis = stripe_helper.create_plan(id: 'gratis', amount: 0)
-      customer = Stripe::Customer.create(id: 'cardless', plan: 'free')
+      free_plan
+      customer = Stripe::Customer.create(id: 'cardless', product: product.id, plan: free_plan.id)
 
       sub = Stripe::Subscription.retrieve(customer.subscriptions.data.first.id)
-      sub.plan = 'gratis'
+      gratis_plan = stripe_helper.create_plan(id: 'gratis', product: product.id, amount: 0)
+      sub.plan = gratis_plan.id
       sub.save
 
       expect(sub.object).to eq('subscription')
-      expect(sub.plan.to_hash).to eq(gratis.to_hash)
+      expect(sub.plan.to_hash).to eq(gratis_plan.to_hash)
 
       customer = Stripe::Customer.retrieve('cardless')
       expect(customer.subscriptions.data).to_not be_empty
@@ -741,17 +955,15 @@ shared_examples 'Customer Subscriptions' do
       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_hash).to eq(gratis.to_hash)
+      expect(customer.subscriptions.data.first.plan.to_hash).to eq(gratis_plan.to_hash)
       expect(customer.subscriptions.data.first.customer).to eq(customer.id)
     end
 
     it "sets a card when updating a customer's subscription" do
-      free = stripe_helper.create_plan(id: 'free', amount: 0)
-      paid = stripe_helper.create_plan(id: 'paid', amount: 499)
-      customer = Stripe::Customer.create(id: 'test_customer_sub', plan: 'free')
+      customer = Stripe::Customer.create(id: 'test_customer_sub', plan: free_plan.id)
 
       sub = Stripe::Subscription.retrieve(customer.subscriptions.data.first.id)
-      sub.plan = 'paid'
+      sub.plan = plan.id
       sub.source = gen_card_tk
       sub.save
 
@@ -764,11 +976,8 @@ shared_examples 'Customer Subscriptions' do
     end
 
     it "overrides trial length when trial end is set" do
-      plan = stripe_helper.create_plan(id: 'trial', amount: 999, trial_period_days: 14)
-      customer = Stripe::Customer.create(id: 'test_trial_end', plan: 'trial')
-
+      customer = Stripe::Customer.create(id: 'test_trial_end', plan: plan_with_trial.id)
       sub = Stripe::Subscription.retrieve(customer.subscriptions.data.first.id)
-
       trial_end = Time.now.utc.to_i + 3600
       sub.trial_end = trial_end
       sub.save
@@ -779,8 +988,7 @@ shared_examples 'Customer Subscriptions' do
     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: 'test_trial_end', plan: 'trial')
+      customer = Stripe::Customer.create(id: 'test_trial_end', plan: plan_with_trial.id, default_source: 'tok_visa')
 
       sub = Stripe::Subscription.retrieve(customer.subscriptions.data.first.id)
 
@@ -788,18 +996,15 @@ shared_examples 'Customer Subscriptions' do
       sub.save
 
       expect(sub.object).to eq('subscription')
-      expect(sub.plan.to_hash).to eq(plan.to_hash)
+      expect(sub.plan.to_hash).to eq(plan_with_trial.to_hash)
       expect(sub.status).to eq('active')
       expect(sub.trial_start).to be_nil
       expect(sub.trial_end).to be_nil
     end
 
     it "changes an active subscription to a trial when trial_end is set" do
-      plan = stripe_helper.create_plan(id: 'no_trial', amount: 999)
-      customer = Stripe::Customer.create(id: 'test_trial_end', plan: 'no_trial', source: gen_card_tk)
-
+      customer = Stripe::Customer.create(id: 'test_trial_end', plan: plan.id, source: gen_card_tk)
       sub = Stripe::Subscription.retrieve(customer.subscriptions.data.first.id)
-
       trial_end = Time.now.utc.to_i + 3600
       sub.trial_end = trial_end
       sub.save
@@ -813,8 +1018,8 @@ shared_examples 'Customer Subscriptions' do
 
 
     it "raises error when trial_end is not an integer or 'now'" do
-      plan = stripe_helper.create_plan(id: 'no_trial', amount: 999)
-      customer = Stripe::Customer.create(id: 'test_trial_end', plan: 'no_trial', source: gen_card_tk)
+      expect(plan.trial_period_days).to be_nil
+      customer = Stripe::Customer.create(id: 'test_trial_end', plan: plan.id, source: gen_card_tk)
 
       sub = Stripe::Subscription.retrieve(customer.subscriptions.data.first.id)
       sub.trial_end = "gazebo"
@@ -828,10 +1033,10 @@ shared_examples 'Customer Subscriptions' do
   end
 
   context "cancelling a subscription" do
+    let(:customer) { Stripe::Customer.create(id: 'test_customer_sub', source: gen_card_tk, plan: plan.id) }
 
-    it "cancels a stripe customer's subscription", :live => true do
-      truth = stripe_helper.create_plan(id: 'the truth')
-      customer = Stripe::Customer.create(source: gen_card_tk, plan: "the truth")
+    it "cancels a stripe customer's subscription", live: true do
+      customer = Stripe::Customer.create(source: gen_card_tk, plan: plan.id)
 
       sub = Stripe::Subscription.retrieve(customer.subscriptions.data.first.id)
       result = sub.delete
@@ -846,53 +1051,58 @@ shared_examples 'Customer Subscriptions' do
       expect(customer.subscriptions.count).to eq(0)
       expect(customer.subscriptions.data.length).to eq(0)
     end
+  end
 
-    it "cancels a stripe customer's subscription 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 = sub.delete(at_period_end: true)
+  it "supports 'cancelling' by updating cancel_at_period_end" do
+    product = stripe_helper.create_product(name: 'Truth Product')
+    truth = stripe_helper.create_plan(id: 'the_truth', product: product.id)
+    customer = Stripe::Customer.create(id: 'test_customer_sub', source: gen_card_tk, plan: "the_truth")
 
-      expect(result.status).to eq('active')
-      expect(result.cancel_at_period_end).to eq(true)
-      expect(result.id).to eq(sub.id)
+    sub = Stripe::Subscription.retrieve(customer.subscriptions.data.first.id)
+    result = Stripe::Subscription.update(sub.id, cancel_at_period_end: true)
 
-      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(result.status).to eq('active')
+    expect(result.cancel_at_period_end).to eq(true)
+    expect(result.id).to eq(sub.id)
 
-      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
+    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 an at period end cancelled subscription" do
-      truth = stripe_helper.create_plan(id: 'the_truth')
-      customer = Stripe::Customer.create(id: 'test_customer_sub', source: gen_card_tk, plan: "the_truth")
+  it "resumes a subscription cancelled by updating cancel_at_period_end" do
+    product = stripe_helper.create_product(name: 'Truth Product')
+    truth = stripe_helper.create_plan(id: 'the_truth', product: product.id)
+    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 = sub.delete(at_period_end: true)
+    sub = Stripe::Subscription.retrieve(customer.subscriptions.data.first.id)
+    Stripe::Subscription.update(sub.id, cancel_at_period_end: true)
 
-      sub.plan = 'the_truth'
-      sub.save
+    result = Stripe::Subscription.update(sub.id, cancel_at_period_end: false)
 
-      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(result.status).to eq('active')
+    expect(result.cancel_at_period_end).to eq(false)
+    expect(result.id).to eq(sub.id)
 
-      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
+    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)
+    trial = stripe_helper.create_plan(id: 'trial', product: product.id, trial_period_days: 14)
     customer = Stripe::Customer.create(id: 'test_customer_sub', source: gen_card_tk, plan: "trial")
 
     sub = Stripe::Subscription.retrieve(customer.subscriptions.data.first.id)
@@ -905,11 +1115,11 @@ shared_examples 'Customer Subscriptions' do
     expect(customer.subscriptions.data.first.status).to eq('trialing')
   end
 
-  it "doesn't require a card when trial_end is present", :live => true do
+  it "doesn't require a card when trial_end is present", live: true do
     plan = stripe_helper.create_plan(
       :amount => 2000,
+      :product => product.id,
       :interval => 'month',
-      :name => 'Amazing Gold Plan',
       :currency => 'usd',
       :id => 'gold'
     )
@@ -924,7 +1134,7 @@ shared_examples 'Customer Subscriptions' do
     let(:subscription) { Stripe::Subscription.retrieve(customer.subscriptions.data.first.id) }
 
     before do
-      stripe_helper.create_plan(id: 'free', amount: 0)
+      free_plan
       Stripe::Subscription.create({ plan: 'free', customer: customer.id })
     end
 
@@ -937,7 +1147,7 @@ shared_examples 'Customer Subscriptions' do
       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.id).to include('test_si_')
       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)
@@ -950,12 +1160,12 @@ shared_examples 'Customer Subscriptions' do
   context "retrieve multiple subscriptions" do
 
     it "retrieves a list of multiple subscriptions" do
-      free = stripe_helper.create_plan(id: 'free', amount: 0)
-      paid = stripe_helper.create_plan(id: 'paid', amount: 499)
-      customer = Stripe::Customer.create(id: 'test_customer_sub', source: gen_card_tk, plan: "free")
+      free_plan
+      paid = stripe_helper.create_plan(id: 'paid', product: product.id, amount: 499)
+      customer = Stripe::Customer.create(id: 'test_customer_sub', source: gen_card_tk, plan: free_plan.id)
       Stripe::Subscription.create({ plan: 'paid', customer: customer.id })
 
-      subs = Stripe::Subscription.all({ customer: customer.id })
+      subs = Stripe::Subscription.list({ customer: customer.id })
 
       expect(subs.object).to eq("list")
       expect(subs.count).to eq(2)
@@ -966,7 +1176,7 @@ shared_examples 'Customer Subscriptions' do
       Stripe::Customer.create(id: 'no_subs')
       customer = Stripe::Customer.retrieve('no_subs')
 
-      list = Stripe::Subscription.all({ customer: customer.id })
+      list = Stripe::Subscription.list({ customer: customer.id })
 
       expect(list.object).to eq("list")
       expect(list.count).to eq(0)
@@ -976,15 +1186,13 @@ shared_examples 'Customer Subscriptions' do
 
   describe "metadata" do
 
-    it "creates a stripe customer and subscribes them to a plan with meta data", :live => true do
+    it "creates a stripe customer and subscribes them to a plan with meta data", live: true do
 
       stripe_helper.
         create_plan(
         :amount => 500,
         :interval => 'month',
-        :product => {
-          :name => 'Sample Plan'
-        },
+        :product => product.id,
         :currency => 'usd',
         :id => 'Sample5'
       )
@@ -1007,3 +1215,46 @@ shared_examples 'Customer Subscriptions' do
   end
 
 end
+
+shared_examples 'Customer Subscriptions with prices' do
+  let(:gen_card_tk) { stripe_helper.generate_card_token }
+
+  let(:product) { stripe_helper.create_product }
+  let(:price) { stripe_helper.create_price(product: product.id, amount: 4999, currency: 'usd') }
+
+  context "creating a new subscription" do
+    it "adds a new subscription to customer with none using items", live: true do
+      customer = Stripe::Customer.create(source: gen_card_tk)
+
+      expect(customer.subscriptions.data).to be_empty
+      expect(customer.subscriptions.count).to eq(0)
+
+      subscription = Stripe::Subscription.create({
+        customer: customer.id,
+        items: [{ price: price.id }],
+        metadata: { foo: "bar", example: "yes" }
+      })
+
+      expect(subscription.object).to eq('subscription')
+      expect(subscription.plan.to_hash).to eq(price.to_hash)
+      expect(subscription.metadata.foo).to eq("bar")
+      expect(subscription.metadata.example).to eq("yes")
+
+      customer = Stripe::Customer.retrieve(customer.id)
+      subscriptions = Stripe::Subscription.list(customer: customer.id)
+      charges = Stripe::Charge.list(customer: customer.id)
+
+      expect(subscriptions.data).to_not be_empty
+      expect(subscriptions.count).to eq(1)
+      expect(subscriptions.data.length).to eq(1)
+      expect(charges.data.length).to eq(1)
+      expect(customer.currency).to eq("usd")
+
+      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.customer).to eq(customer.id)
+      expect(subscriptions.data.first.metadata.foo).to eq( "bar" )
+      expect(subscriptions.data.first.metadata.example).to eq( "yes" )
+    end
+  end
+end