stripe-ruby-mock 2.5.8 → 4.0.0

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,172 @@ 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::Discount)
-      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.id).not_to be_nil
+      expect(subscriptions.data.first.discount).to be_a(Stripe::Discount)
+      expect(subscriptions.data.first.discount.coupon.id).to eq(coupon.id)
     end
 
     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 "allows promotion code" do
+      customer = Stripe::Customer.create(source: gen_card_tk)
+      coupon = stripe_helper.create_coupon
+      promotion_code = Stripe::PromotionCode.create(coupon: coupon)
+
+      expect {
+        Stripe::Subscription.create(plan: plan.id, customer: customer.id, promotion_code: promotion_code.id)
+      }.not_to raise_error(Stripe::InvalidRequestError)
+    end
+
+    it "does not permit both coupon and promotion code" do
+      customer = Stripe::Customer.create(source: gen_card_tk)
+
+      expect {
+        Stripe::Subscription.create(plan: plan.id, customer: customer.id, coupon: "test", promotion_code: "test")
+      }.to raise_error { |e|
+        expect(e).to be_a Stripe::InvalidRequestError
+        expect(e.http_status).to eq(400)
+        expect(e.message).to eq("You may only specify one of these parameters: coupon, promotion_code")
+      }
     end
 
     it "correctly sets quantity, application_fee_percent and tax_percent" do
-      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 +285,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)
@@ -246,11 +313,32 @@ shared_examples 'Customer Subscriptions' do
       expect(customer.subscriptions.count).to eq(0)
     end
 
+    it "creates a subscription when subscription's payment_behavior is default_incomplete" do
+      plan = stripe_helper.create_plan(id: 'enterprise', product: product.id, amount: 499)
+      customer = Stripe::Customer.create(id: 'cardless')
+
+      sub = Stripe::Subscription.create({ plan: plan.id, customer: customer.id, payment_behavior: 'default_incomplete' })
+      customer = Stripe::Customer.retrieve('cardless')
+
+      expect(customer.subscriptions.count).to eq(1)
+      expect(customer.subscriptions.data.first.id).to eq(sub.id)
+      expect(customer.subscriptions.data.first.status).to eq('incomplete')
+    end
+
+    it "allows setting transfer_data" do
+      customer = Stripe::Customer.create(id: 'test_customer_sub', source: gen_card_tk)
+
+      sub = Stripe::Subscription.create({ customer: customer.id, plan: plan.id, transfer_data: {destination: "acct_0000000000000000", amount_percent: 50} })
+
+      expect(sub.transfer_data.destination).to eq("acct_0000000000000000")
+      expect(sub.transfer_data.amount_percent).to eq(50)
+    end
+
     it "throws an error when subscribing a customer with no card" do
-      plan = stripe_helper.create_plan(id: 'enterprise', 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 +349,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 +364,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 +376,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
+      expect(sub.billing_cycle_anchor).to eq sub.trial_start
 
-      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 +413,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,20 +439,21 @@ 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.to_hash)
+      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
-      plan = stripe_helper.create_plan(id: 'trial', amount: 999, trial_period_days: 14)
+      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'}
@@ -387,23 +477,21 @@ 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: '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")
@@ -411,11 +499,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")
@@ -423,11 +510,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")
@@ -435,11 +521,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)
@@ -447,17 +532,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,
@@ -476,9 +555,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
 
@@ -497,8 +576,48 @@ shared_examples 'Customer Subscriptions' do
       expect(subscription.items.data[1].plan.id).to eq plan2.id
     end
 
+    it 'sets current_period_end based on price week interval', live: true do
+      price = stripe_helper.create_price(recurring: {interval: 'week'})
+
+      subscription = Stripe::Subscription.create(
+        customer: Stripe::Customer.create(source: gen_card_tk).id,
+        items: [
+          {price: price.id, quantity: 1}
+        ]
+      )
+
+      expect(subscription.current_period_end).to eq (Time.now + (7 * 60 * 60 * 24)).to_i
+    end
+
+    it 'sets current_period_end based on price month interval', live: true do
+      price = stripe_helper.create_price(recurring: {interval: 'month'})
+
+      subscription = Stripe::Subscription.create(
+        customer: Stripe::Customer.create(source: gen_card_tk).id,
+        items: [
+          {price: price.id, quantity: 1}
+        ]
+      )
+
+      expect(subscription.current_period_end).to eq (DateTime.now >> 1).to_time.to_i
+    end
+
+    it 'sets current_period_end based on price year interval', live: true do
+      price = stripe_helper.create_price(recurring: {interval: 'year'})
+
+      subscription = Stripe::Subscription.create(
+        customer: Stripe::Customer.create(source: gen_card_tk).id,
+        items: [
+          {price: price.id, quantity: 1}
+        ]
+      )
+
+      expect(subscription.current_period_end).to eq (DateTime.now >> 12).to_time.to_i
+    end
+
     it 'add a new subscription to bill via an invoice' do
-      plan = stripe_helper.create_plan(id: 'silver', product: { name: 'Silver Plan' },
+      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')
 
@@ -520,60 +639,120 @@ shared_examples 'Customer Subscriptions' do
     end
 
     let(:subscription_header) {{
-      :idempotency_key => 'a_idempotency_key'
+      :idempotency_key => SecureRandom.hex
     }}
 
     it "adds a new subscription to customer with identical idempotency key" do
-      plan = stripe_helper.create_plan(id: 'silver', product: { name: 'Silver Plan' },
+      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
-      plan = stripe_helper.create_plan(id: 'silver', product: { name: 'Silver Plan' },
+    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)
 
-      another_subscription_header = {
-        :idempotency_key => 'another_idempotency_key'
+      sub_header_1 = {
+        :idempotency_key => SecureRandom.hex
+      }
+      sub_header_2 = {
+        :idempotency_key => SecureRandom.hex
       }
 
-      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)
+      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
-      silver = stripe_helper.create_plan(id: 'silver')
+      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)
+      sub.cancel(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 '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
 
+    it 'expands latest_invoice.payment_intent' do
+      customer = Stripe::Customer.create(source: gen_card_tk)
+      subscription = Stripe::Subscription.create({
+        customer: customer.id,
+        plan: plan.id,
+        expand: ['latest_invoice.payment_intent']
+      })
+
+      expect(subscription.latest_invoice.payment_intent.status).to eq('succeeded')
+
+      subscription = Stripe::Subscription.create({
+        customer: customer.id,
+        plan: plan.id,
+        expand: ['latest_invoice.payment_intent'],
+        payment_behavior: 'default_incomplete'
+      })
+
+      expect(subscription.latest_invoice.payment_intent.status).to eq('requires_payment_method')
+
+      subscription = Stripe::Subscription.create({
+        customer: customer.id,
+        plan: plan.id,
+        expand: ['latest_invoice.payment_intent'],
+        trial_period_days: 14
+      })
+
+      expect(subscription.latest_invoice.payment_intent).to be_nil
+    end
   end
 
   context "updating a subscription" do
     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
+      subscription.cancel
 
       expect { subscription.save }.to raise_error { |e|
         expect(e).to be_a(Stripe::InvalidRequestError)
@@ -583,24 +762,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.delete(at_period_end: true)
+      sub = Stripe::Subscription.create({ items: [ { plan: plan.id } ], customer: customer.id })
+      sub.cancel(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"
@@ -608,7 +785,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" )
@@ -619,16 +796,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
@@ -649,12 +825,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
@@ -674,9 +850,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)
@@ -690,8 +944,6 @@ shared_examples 'Customer Subscriptions' do
     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)
 
@@ -706,8 +958,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)
@@ -720,9 +970,25 @@ shared_examples 'Customer Subscriptions' do
       expect(subscription.discount).to be_nil
     end
 
+    it "throws an error when promotion code has an amount restriction" do
+      coupon = stripe_helper.create_coupon
+      promotion_code = Stripe::PromotionCode.create(
+        coupon: coupon, restrictions: {minimum_amount: 100, minimum_amount_currency: "USD"}
+      )
+      customer = Stripe::Customer.create(source: gen_card_tk, plan: plan.id)
+      subscription = Stripe::Subscription.retrieve(customer.subscriptions.data.first.id)
+
+      subscription.promotion_code = promotion_code.id
+
+      expect { subscription.save }.to raise_error { |e|
+        expect(e).to be_a Stripe::InvalidRequestError
+        expect(e.http_status).to eq(400)
+        expect(e.message).to_not be_nil
+      }
+    end
+
     it "throws an error when plan does not exist" do
-      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'
@@ -736,75 +1002,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
@@ -812,21 +1062,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
@@ -834,17 +1084,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
 
@@ -857,11 +1105,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
@@ -872,8 +1117,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)
 
@@ -881,18 +1125,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
@@ -906,8 +1147,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"
@@ -918,16 +1159,28 @@ shared_examples 'Customer Subscriptions' do
         expect(e.message).to eq("Invalid timestamp: must be an integer")
       }
     end
+
+    it "converts billing_cycle_anchor=now to a timestamp" do
+      customer = Stripe::Customer.create(id: 'test_billing_anchor', plan: plan.id, source: gen_card_tk)
+
+      sub = Stripe::Subscription.retrieve(customer.subscriptions.data.first.id)
+      sub.billing_cycle_anchor = 'now'
+      sub.save
+
+      expect(sub.billing_cycle_anchor).to be_a(Integer)
+    end
+
+
   end
 
   context "cancelling a subscription" do
+    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
+      result = sub.cancel
 
       expect(result.status).to eq('canceled')
       expect(result.cancel_at_period_end).to eq false
@@ -939,53 +1192,11 @@ shared_examples 'Customer Subscriptions' do
       expect(customer.subscriptions.count).to eq(0)
       expect(customer.subscriptions.data.length).to eq(0)
     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)
-
-      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 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")
-
-      sub = Stripe::Subscription.retrieve(customer.subscriptions.data.first.id)
-      result = sub.delete(at_period_end: true)
-
-      sub.plan = 'the_truth'
-      sub.save
-
-      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
   end
 
   it "supports 'cancelling' by updating cancel_at_period_end" do
-    truth = stripe_helper.create_plan(id: 'the_truth')
+    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)
@@ -1007,7 +1218,8 @@ shared_examples 'Customer Subscriptions' do
   end
 
   it "resumes a subscription cancelled by updating cancel_at_period_end" do
-    truth = stripe_helper.create_plan(id: 'the_truth')
+    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)
@@ -1031,11 +1243,11 @@ shared_examples 'Customer Subscriptions' do
   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)
-    result = sub.delete(at_period_end: true)
+    result = sub.cancel(at_period_end: true)
 
     expect(result.status).to eq('trialing')
 
@@ -1044,11 +1256,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'
     )
@@ -1063,7 +1275,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
 
@@ -1076,7 +1288,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)
@@ -1084,17 +1296,21 @@ shared_examples 'Customer Subscriptions' do
       expect(subscription.items.data.first.plan.currency).to eq('usd')
       expect(subscription.items.data.first.quantity).to eq(2)
     end
+
+    it "has a start_date attribute" do
+      expect(subscription).to respond_to(:start_date)
+    end
   end
 
   context "retrieve multiple subscriptions" do
 
     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)
@@ -1105,25 +1321,67 @@ 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)
       expect(list.data.length).to eq(0)
     end
+
+    it "does not include canceled subscriptions by default" do
+      customer = Stripe::Customer.create(source: gen_card_tk)
+      subscription = Stripe::Subscription.create({ plan: plan.id, customer: customer.id })
+      subscription.cancel
+
+      list = Stripe::Subscription.list({customer: customer.id})
+
+      expect(list.object).to eq("list")
+      expect(list.data).to be_empty
+      expect(list.data.length).to eq(0)
+    end
+
+    it "filters out subscriptions based on their current_period", live: true do
+      price = stripe_helper.create_price(recurring: { interval: 'month' })
+      price2 = stripe_helper.create_price(recurring: { interval: 'year' })
+
+      subscription1 = Stripe::Subscription.create(
+        customer: Stripe::Customer.create(source: gen_card_tk).id,
+        items: [{ price: price.id, quantity: 1 }]
+      )
+      subscription2 = Stripe::Subscription.create(
+        customer: Stripe::Customer.create(source: gen_card_tk).id,
+        items: [{ price: price2.id, quantity: 1 }]
+      )
+
+      list = Stripe::Subscription.list({ current_period_end: { gt: subscription1.current_period_end }})
+      expect(list.data).to contain_exactly(subscription2)
+
+      list = Stripe::Subscription.list({ current_period_end: { gte: subscription1.current_period_end }})
+      expect(list.data).to contain_exactly(subscription1, subscription2)
+
+      list = Stripe::Subscription.list({ current_period_end: { lt: subscription1.current_period_end }})
+      expect(list.data).to be_empty
+
+      list = Stripe::Subscription.list({ current_period_end: { lte: subscription1.current_period_end }})
+      expect(list.data).to contain_exactly(subscription1)
+
+      list = Stripe::Subscription.list({ current_period_start: subscription1.current_period_start })
+      expect(list.data).to contain_exactly(subscription1, subscription2)
+
+      list = Stripe::Subscription.list({ current_period_end: subscription2.current_period_end })
+      expect(list.data).to contain_exactly(subscription2)
+    end
   end
 
   describe "metadata" do
 
-    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'
       )
@@ -1143,6 +1401,130 @@ shared_examples 'Customer Subscriptions' do
       expect(customer.subscriptions.first.plan.id).to eq('Sample5')
       expect(customer.subscriptions.first.metadata['foo']).to eq('bar')
     end
+
+    it "saves subscription item metadata" do
+      stripe_helper.
+        create_plan(
+        :amount => 500,
+        :interval => 'month',
+        :product => product.id,
+        :currency => 'usd',
+        :id => 'Sample5'
+      )
+      customer = Stripe::Customer.create({
+        email: 'johnny@appleseed.com',
+        source: gen_card_tk
+      })
+
+      subscription = Stripe::Subscription.create(
+        customer: customer.id,
+        items: [{plan: "Sample5", metadata: {foo: 'bar'}}],
+      )
+      expect(subscription.items.data[0].metadata.to_h).to eq(foo: 'bar')
+    end
+  end
+
+  context "search" do
+    # the Search API requires about a minute between writes and reads, so add sleeps accordingly when running live
+    it "searches subscriptions for exact matches", :aggregate_failures do
+      response = Stripe::Subscription.search({query: 'status:"active"'}, stripe_version: '2020-08-27')
+      expect(response.data.size).to eq(0)
+
+      stripe_helper.create_plan(
+        amount: 500,
+        interval: 'month',
+        product: product.id,
+        currency: 'usd',
+        id: 'Sample5'
+      )
+      customer = Stripe::Customer.create(email: 'johnny@appleseed.com', source: gen_card_tk)
+      one = Stripe::Subscription.create(customer: customer.id, items: [{plan: "Sample5"}], metadata: {key: 'uno'})
+      two = Stripe::Subscription.create(customer: customer.id, items: [{plan: "Sample5"}], metadata: {key: 'dos'})
+      Stripe::Subscription.cancel(two.id)
+
+      response = Stripe::Subscription.search({query: 'status:"active"'}, stripe_version: '2020-08-27')
+      expect(response.data.map(&:id)).to match_array([one.id])
+
+      response = Stripe::Subscription.search({query: 'metadata["key"]:"dos"'}, stripe_version: '2020-08-27')
+      expect(response.data.map(&:id)).to match_array([two.id])
+    end
+
+    it "respects limit", :aggregate_failures do
+      stripe_helper.create_plan(
+        amount: 500,
+        interval: 'month',
+        product: product.id,
+        currency: 'usd',
+        id: 'Sample5'
+      )
+      customer = Stripe::Customer.create(email: 'johnny@appleseed.com', source: gen_card_tk)
+      11.times do
+        Stripe::Subscription.create(customer: customer.id, items: [{plan: "Sample5"}])
+      end
+
+      response = Stripe::Subscription.search({query: 'status:"active"'}, stripe_version: '2020-08-27')
+      expect(response.data.size).to eq(10)
+      response = Stripe::Subscription.search({query: 'status:"active"', limit: 1}, stripe_version: '2020-08-27')
+      expect(response.data.size).to eq(1)
+    end
+
+    it "reports search errors", :aggregate_failures do
+      expect {
+        Stripe::Subscription.search({limit: 1}, stripe_version: '2020-08-27')
+      }.to raise_error(Stripe::InvalidRequestError, /Missing required param: query./)
+
+      expect {
+        Stripe::Subscription.search({query: 'asdf'}, stripe_version: '2020-08-27')
+      }.to raise_error(Stripe::InvalidRequestError, /We were unable to parse your search query./)
+
+      expect {
+        Stripe::Subscription.search({query: 'foo:"bar"'}, stripe_version: '2020-08-27')
+      }.to raise_error(Stripe::InvalidRequestError, /Field `foo` is an unsupported search field for resource `subscriptions`./)
+    end
   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.items.first.price.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.items.first.price.to_hash).to eq(price.to_hash)
+      expect(subscriptions.data.first.customer).to eq(customer.id)
+      expect(subscriptions.data.first.metadata.foo).to eq( "bar" )
+      expect(subscriptions.data.first.metadata.example).to eq( "yes" )
+    end
+  end
 end