stripe-ruby-mock 3.0.0 → 3.1.0

data/spec/shared_stripe_examples/subscription_examples.rb

@@ -1,7 +1,7 @@
 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 }
 
   let(:product) { stripe_helper.create_product }
@@ -14,7 +14,7 @@ shared_examples 'Customer Subscriptions' do
   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
+    it "adds a new subscription to customer with none using items", live: true do
       plan
       customer = Stripe::Customer.create(source: gen_card_tk)
 
@@ -49,7 +49,7 @@ shared_examples 'Customer Subscriptions' do
       expect(subscriptions.data.first.metadata.example).to eq( "yes" )
     end
 
-    it "adds a new subscription to customer with none", :live => true do
+    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)
@@ -117,6 +117,33 @@ shared_examples 'Customer Subscriptions' do
       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)
       subscriptions = Stripe::Subscription.list(customer: customer.id)
@@ -152,6 +179,7 @@ shared_examples 'Customer Subscriptions' do
       expect(subscriptions.data).to be_a(Array)
       expect(subscriptions.data.count).to eq(1)
       expect(subscriptions.data.first.discount).not_to be_nil
+      expect(subscriptions.data.first.discount.id).not_to be_nil
       expect(subscriptions.data.first.discount).to be_a(Stripe::Discount)
       expect(subscriptions.data.first.discount.coupon.id).to eq(coupon.id)
     end
@@ -168,6 +196,28 @@ shared_examples 'Customer Subscriptions' do
       }
     end
 
+    it "allows promotion code" do
+      customer = Stripe::Customer.create(source: gen_card_tk)
+      coupon = stripe_helper.create_coupon
+      promotion_code = Stripe::PromotionCode.create(coupon: coupon)
+
+      expect {
+        Stripe::Subscription.create(plan: plan.id, customer: customer.id, promotion_code: promotion_code.id)
+      }.not_to raise_error(Stripe::InvalidRequestError)
+    end
+
+    it "does not permit both coupon and promotion code" do
+      customer = Stripe::Customer.create(source: gen_card_tk)
+
+      expect {
+        Stripe::Subscription.create(plan: plan.id, customer: customer.id, coupon: "test", promotion_code: "test")
+      }.to raise_error { |e|
+        expect(e).to be_a Stripe::InvalidRequestError
+        expect(e.http_status).to eq(400)
+        expect(e.message).to eq("You may only specify one of these parameters: coupon, promotion_code")
+      }
+    end
+
     it "correctly sets quantity, application_fee_percent and tax_percent" do
       customer = Stripe::Customer.create(id: 'test_customer_sub', source: gen_card_tk)
 
@@ -183,6 +233,20 @@ shared_examples 'Customer Subscriptions' do
       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)
       subscription = Stripe::Subscription.create({ plan: plan.id, customer: customer.id })
@@ -249,6 +313,27 @@ 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', product: product.id, amount: 499)
       customer = Stripe::Customer.create(id: 'cardless')
@@ -297,7 +382,7 @@ shared_examples 'Customer Subscriptions' do
       expect(sub.object).to eq('subscription')
       expect(sub.plan.to_hash).to eq(plan_with_trial.to_hash)
       expect(sub.trial_end - sub.trial_start).to eq(14 * 86400)
-      expect(sub.billing_cycle_anchor).to be_nil
+      expect(sub.billing_cycle_anchor).to eq sub.trial_start
 
       customer = Stripe::Customer.retrieve(customer.id)
       subscriptions = Stripe::Subscription.list(customer: customer.id)
@@ -491,6 +576,45 @@ 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
       product = stripe_helper.create_product(id: 'invoice_billing')
       plan = stripe_helper.create_plan(id: 'silver', product: product.id,
@@ -536,7 +660,7 @@ shared_examples 'Customer Subscriptions' do
       expect(sub1).to eq(sub2)
     end
 
-    it "adds a new subscription to customer with different idempotency key", :live => true do
+    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')
@@ -592,6 +716,35 @@ shared_examples 'Customer Subscriptions' do
         expect(subscription.default_tax_rates.first.id).to eq(tax_rate.id)
       end
     end
+
+    it 'expands latest_invoice.payment_intent' do
+      customer = Stripe::Customer.create(source: gen_card_tk)
+      subscription = Stripe::Subscription.create({
+        customer: customer.id,
+        plan: plan.id,
+        expand: ['latest_invoice.payment_intent']
+      })
+
+      expect(subscription.latest_invoice.payment_intent.status).to eq('succeeded')
+
+      subscription = Stripe::Subscription.create({
+        customer: customer.id,
+        plan: plan.id,
+        expand: ['latest_invoice.payment_intent'],
+        payment_behavior: 'default_incomplete'
+      })
+
+      expect(subscription.latest_invoice.payment_intent.status).to eq('requires_payment_method')
+
+      subscription = Stripe::Subscription.create({
+        customer: customer.id,
+        plan: plan.id,
+        expand: ['latest_invoice.payment_intent'],
+        trial_period_days: 14
+      })
+
+      expect(subscription.latest_invoice.payment_intent).to be_nil
+    end
   end
 
   context "updating a subscription" do
@@ -720,6 +873,63 @@ shared_examples 'Customer Subscriptions' do
       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
       coupon = stripe_helper.create_coupon
       customer = Stripe::Customer.create(source: gen_card_tk, plan: plan.id)
@@ -760,6 +970,23 @@ 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
       customer = Stripe::Customer.create(id: 'cardless', plan: free_plan.id)
 
@@ -932,12 +1159,24 @@ 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
+    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)
@@ -1017,7 +1256,7 @@ 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,
@@ -1049,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)
@@ -1057,6 +1296,10 @@ 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
@@ -1084,11 +1327,55 @@ shared_examples 'Customer Subscriptions' do
       expect(list.count).to eq(0)
       expect(list.data.length).to eq(0)
     end
+
+    it "does not include canceled subscriptions by default" do
+      customer = Stripe::Customer.create(source: gen_card_tk)
+      subscription = Stripe::Subscription.create({ plan: plan.id, customer: customer.id })
+      subscription.delete
+
+      list = Stripe::Subscription.list({customer: customer.id})
+
+      expect(list.object).to eq("list")
+      expect(list.data).to be_empty
+      expect(list.data.length).to eq(0)
+    end
+
+    it "filters out subscriptions based on their current_period", live: true do
+      price = stripe_helper.create_price(recurring: { interval: 'month' })
+      price2 = stripe_helper.create_price(recurring: { interval: 'year' })
+
+      subscription1 = Stripe::Subscription.create(
+        customer: Stripe::Customer.create(source: gen_card_tk).id,
+        items: [{ price: price.id, quantity: 1 }]
+      )
+      subscription2 = Stripe::Subscription.create(
+        customer: Stripe::Customer.create(source: gen_card_tk).id,
+        items: [{ price: price2.id, quantity: 1 }]
+      )
+
+      list = Stripe::Subscription.list({ current_period_end: { gt: subscription1.current_period_end }})
+      expect(list.data).to contain_exactly(subscription2)
+
+      list = Stripe::Subscription.list({ current_period_end: { gte: subscription1.current_period_end }})
+      expect(list.data).to contain_exactly(subscription1, subscription2)
+
+      list = Stripe::Subscription.list({ current_period_end: { lt: subscription1.current_period_end }})
+      expect(list.data).to be_empty
+
+      list = Stripe::Subscription.list({ current_period_end: { lte: subscription1.current_period_end }})
+      expect(list.data).to contain_exactly(subscription1)
+
+      list = Stripe::Subscription.list({ current_period_start: subscription1.current_period_start })
+      expect(list.data).to contain_exactly(subscription1, subscription2)
+
+      list = Stripe::Subscription.list({ current_period_end: subscription2.current_period_end })
+      expect(list.data).to contain_exactly(subscription2)
+    end
   end
 
   describe "metadata" do
 
-    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(
@@ -1114,6 +1401,71 @@ 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
+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

data/spec/shared_stripe_examples/transfer_examples.rb

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

data/spec/shared_stripe_examples/webhook_event_examples.rb

@@ -203,6 +203,52 @@ shared_examples 'Webhook Events API' do
       expect(events.map &:type).to include('invoiceitem.created', 'invoice.created', 'coupon.created')
     end
 
+    it "retrieves events with a created timestamp" do
+      timestamp = Time.now.to_i - 7200
+      customer_created_event = StripeMock.mock_webhook_event('customer.created', created: Time.now.to_i - 14_400)
+      plan_created_event = StripeMock.mock_webhook_event('plan.created', created: Time.now.to_i - 10_800)
+      coupon_created_event = StripeMock.mock_webhook_event('coupon.created', created: timestamp)
+      invoice_created_event = StripeMock.mock_webhook_event('invoice.created', created: Time.now.to_i - 3600)
+      invoice_item_created_event = StripeMock.mock_webhook_event('invoiceitem.created')
+
+      events = Stripe::Event.list(created: timestamp)
+      expect(events.count).to eq(1)
+      expect(events.map &:id).to match_array([coupon_created_event.id])
+      expect(events.map &:type).to match_array(['coupon.created'])
+
+      events = Stripe::Event.list(created: timestamp.to_s)
+      expect(events.count).to eq(1)
+      expect(events.map &:id).to match_array([coupon_created_event.id])
+      expect(events.map &:type).to match_array(['coupon.created'])
+    end
+
+    it "retrieves events with a created filter" do
+      timestamp1 = Time.now.to_i - 3600
+      timestamp2 = Time.now.to_i - 7200
+      timestamp3 = Time.now.to_i - 10_800
+      timestamp4 = Time.now.to_i - 14_400
+      customer_created_event = StripeMock.mock_webhook_event('customer.created', created: timestamp4)
+      plan_created_event = StripeMock.mock_webhook_event('plan.created', created: timestamp3)
+      coupon_created_event = StripeMock.mock_webhook_event('coupon.created', created: timestamp2)
+      invoice_created_event = StripeMock.mock_webhook_event('invoice.created', created: timestamp1)
+      invoice_item_created_event = StripeMock.mock_webhook_event('invoiceitem.created')
+
+      events = Stripe::Event.list(created: {gte: timestamp2, lte: timestamp1})
+      expect(events.count).to eq(2)
+      expect(events.map &:id).to match_array([coupon_created_event.id, invoice_created_event.id])
+      expect(events.map &:type).to match_array(['coupon.created', 'invoice.created'])
+
+      events = Stripe::Event.list(created: {gt: timestamp3})
+      expect(events.count).to eq(3)
+      expect(events.map &:id).to match_array([coupon_created_event.id, invoice_created_event.id, invoice_item_created_event.id])
+      expect(events.map &:type).to match_array(['coupon.created', 'invoice.created', 'invoiceitem.created'])
+
+      events = Stripe::Event.list(created: {lt: timestamp3.to_s})
+      expect(events.count).to eq(1)
+      expect(events.map &:id).to match_array([customer_created_event.id])
+      expect(events.map &:type).to match_array(['customer.created'])
+    end
+
   end
 
   describe 'Subscription events' do
@@ -211,7 +257,7 @@ shared_examples 'Webhook Events API' do
       expect(subscription_created_event).to be_a(Stripe::Event)
       expect(subscription_created_event.id).to_not be_nil
       expect(subscription_created_event.data.object.items.data.class).to be Array
-      expect(subscription_created_event.data.object.items.data.length).to be 2
+      expect(subscription_created_event.data.object.items.data.length).to be 1
       expect(subscription_created_event.data.object.items.data.first).to respond_to(:plan)
       expect(subscription_created_event.data.object.items.data.first.id).to eq('si_00000000000000')
     end
@@ -221,7 +267,7 @@ shared_examples 'Webhook Events API' do
       expect(subscription_deleted_event).to be_a(Stripe::Event)
       expect(subscription_deleted_event.id).to_not be_nil
       expect(subscription_deleted_event.data.object.items.data.class).to be Array
-      expect(subscription_deleted_event.data.object.items.data.length).to be 2
+      expect(subscription_deleted_event.data.object.items.data.length).to be 1
       expect(subscription_deleted_event.data.object.items.data.first).to respond_to(:plan)
       expect(subscription_deleted_event.data.object.items.data.first.id).to eq('si_00000000000000')
     end
@@ -231,7 +277,7 @@ shared_examples 'Webhook Events API' do
       expect(subscription_updated_event).to be_a(Stripe::Event)
       expect(subscription_updated_event.id).to_not be_nil
       expect(subscription_updated_event.data.object.items.data.class).to be Array
-      expect(subscription_updated_event.data.object.items.data.length).to be 2
+      expect(subscription_updated_event.data.object.items.data.length).to be 1
       expect(subscription_updated_event.data.object.items.data.first).to respond_to(:plan)
       expect(subscription_updated_event.data.object.items.data.first.id).to eq('si_00000000000000')
     end
@@ -253,9 +299,9 @@ shared_examples 'Webhook Events API' do
       expect(invoice_payment_succeeded).to be_a(Stripe::Event)
       expect(invoice_payment_succeeded.id).to_not be_nil
       expect(invoice_payment_succeeded.data.object.lines.data.class).to be Array
-      expect(invoice_payment_succeeded.data.object.lines.data.length).to be 2
+      expect(invoice_payment_succeeded.data.object.lines.data.length).to be 1
       expect(invoice_payment_succeeded.data.object.lines.data.first).to respond_to(:plan)
-      expect(invoice_payment_succeeded.data.object.lines.data.first.id).to eq('sub_00000000000000')
+      expect(invoice_payment_succeeded.data.object.lines.data.first.id).to eq('il_000000000000000000000000')
     end
   end
 end

data/spec/spec_helper.rb

@@ -5,6 +5,9 @@ require 'rspec'
 require 'stripe'
 require 'stripe_mock'
 require 'stripe_mock/server'
+require 'dotenv'
+
+Dotenv.load('.env')
 
 # Requires supporting ruby files with custom matchers and macros, etc,
 # in spec/support/ and its subdirectories.
@@ -33,6 +36,7 @@ RSpec.configure do |c|
       when '2.4.6'  then ENV['STRIPE_TEST_SECRET_KEY_A']
       when '2.5.5' then ENV['STRIPE_TEST_SECRET_KEY_B']
       when '2.6.3'  then ENV['STRIPE_TEST_SECRET_KEY_C']
+      when '2.7.0'  then ENV['STRIPE_TEST_SECRET_KEY_D']
       end
     else
       api_key = ENV['STRIPE_TEST_SECRET_KEY']

data/spec/stripe_mock_spec.rb

@@ -35,8 +35,8 @@ describe StripeMock do
     StripeMock.stop
     StripeMock.start
 
-    expect(StripeMock.instance.customers[:x]).to be_nil
-    expect(StripeMock.instance.customers.keys.length).to eq(0)
+    expect(StripeMock.instance.customers[''][:x]).to be_nil
+    expect(StripeMock.instance.customers[''].keys.length).to eq(0)
     StripeMock.stop
   end