stripe-ruby-mock 3.0.1 → 3.1.0.rc2

data/spec/shared_stripe_examples/price_examples.rb

@@ -0,0 +1,183 @@
+require 'spec_helper'
+
+shared_examples 'Price API' do
+  let(:product) { stripe_helper.create_product }
+  let(:product_id) { product.id }
+
+  let(:price_attributes) { {
+    :id => "price_abc123",
+    :product => product_id,
+    :nickname => "My Mock price",
+    :amount => 9900,
+    :currency => "usd",
+    :interval => "month"
+  } }
+  let(:price) { Stripe::Price.create(price_attributes) }
+
+  let(:price_attributes_without_id){ price_attributes.merge(id: nil) }
+  let(:price_without_id){ Stripe::Price.create(price_attributes_without_id) }
+
+  let(:price_attributes_with_trial) { price_attributes.merge(id: "prod_TRIAL", :trial_period_days => 30) }
+  let(:price_with_trial) { Stripe::Price.create(price_attributes_with_trial) }
+
+  let(:metadata) { {:description => "desc text", :info => "info text"} }
+  let(:price_attributes_with_metadata) { price_attributes.merge(id: "prod_META", metadata: metadata) }
+  let(:price_with_metadata) { Stripe::Price.create(price_attributes_with_metadata) }
+
+  before(:each) do
+    product
+  end
+
+  it "creates a stripe price" do
+    expect(price.id).to eq('price_abc123')
+    expect(price.nickname).to eq('My Mock price')
+    expect(price.amount).to eq(9900)
+
+    expect(price.currency).to eq('usd')
+    expect(price.interval).to eq("month")
+
+    expect(price_with_metadata.metadata.description).to eq('desc text')
+    expect(price_with_metadata.metadata.info).to eq('info text')
+
+    expect(price_with_trial.trial_period_days).to eq(30)
+  end
+
+  it "creates a stripe price without specifying ID" do
+    expect(price_attributes_without_id[:id]).to be_nil
+    expect(price_without_id.id).to match(/^test_price_1/)
+  end
+
+  it "stores a created stripe price in memory" do
+    price
+    price2 = Stripe::Price.create(price_attributes.merge(id: "price_def456", amount: 299))
+
+    data = test_data_source(:prices)
+    expect(data[price.id]).to_not be_nil
+    expect(data[price.id][:amount]).to eq(9900)
+    expect(data[price2.id]).to_not be_nil
+    expect(data[price2.id][:amount]).to eq(299)
+  end
+
+  it "retrieves a stripe price" do
+    original = stripe_helper.create_price(product: product_id, amount: 1331, id: 'price_943843')
+    price = Stripe::Price.retrieve(original.id)
+
+    expect(price.id).to eq(original.id)
+    expect(price.amount).to eq(original.amount)
+  end
+
+  it "updates a stripe price" do
+    stripe_helper.create_price(id: 'super_member', product: product_id, amount: 111)
+
+    price = Stripe::Price.retrieve('super_member')
+    expect(price.amount).to eq(111)
+
+    price.amount = 789
+    price.save
+    price = Stripe::Price.retrieve('super_member')
+    expect(price.amount).to eq(789)
+  end
+
+  it "cannot retrieve a stripe price that doesn't exist" do
+    expect { Stripe::Price.retrieve('nope') }.to raise_error {|e|
+      expect(e).to be_a Stripe::InvalidRequestError
+      expect(e.param).to eq('price')
+      expect(e.http_status).to eq(404)
+    }
+  end
+
+  it "retrieves all prices" do
+    stripe_helper.create_price(id: 'price One', product: product_id, amount: 54321)
+    stripe_helper.create_price(id: 'price Two', product: product_id, amount: 98765)
+
+    all = Stripe::Price.list
+    expect(all.count).to eq(2)
+    expect(all.map &:id).to include('price One', 'price Two')
+    expect(all.map &:amount).to include(54321, 98765)
+  end
+
+  it 'retrieves prices with limit' do
+    101.times do | i|
+      stripe_helper.create_price(id: "price #{i}", product: product_id, amount: 11)
+    end
+    all = Stripe::Price.list(limit: 100)
+
+    expect(all.count).to eq(100)
+  end
+
+  it "retrieves prices with lookup keys" do
+    stripe_helper.create_price(id: 'price One', product: product_id, amount: 54321, lookup_key: 'one')
+    stripe_helper.create_price(id: 'price Two', product: product_id, amount: 98765, lookup_key: 'two')
+
+    all = Stripe::Price.list({lookup_keys: ['one', 'two']})
+    expect(all.count).to eq(2)
+    expect(all.map &:id).to include('price One', 'price Two')
+    expect(all.map &:amount).to include(54321, 98765)
+
+    one = Stripe::Price.list({lookup_keys: ['one']})
+    expect(one.count).to eq(1)
+    expect(one.map &:id).to include('price One')
+    expect(one.map &:amount).to include(54321)
+
+    two = Stripe::Price.list({lookup_keys: ['two']})
+    expect(two.count).to eq(1)
+    expect(two.map &:id).to include('price Two')
+    expect(two.map &:amount).to include(98765)
+  end
+
+  describe "Validations", :live => true do
+    include_context "stripe validator"
+    let(:params) { stripe_helper.create_price_params(product: product_id) }
+    let(:subject) { Stripe::Price.create(params) }
+
+    describe "Associations" do
+      let(:not_found_product_id){ "prod_NONEXIST" }
+      let(:not_found_message) { stripe_validator.not_found_message(Stripe::Product, not_found_product_id) }
+      let(:params) { stripe_helper.create_price_params(product: not_found_product_id) }
+      let(:products) { stripe_helper.list_products(100).data }
+
+      it "validates associated product" do
+        expect(products.map(&:id)).to_not include(not_found_product_id)
+        expect { subject }.to raise_error(Stripe::InvalidRequestError, not_found_message)
+      end
+    end
+
+    describe "Presence" do
+      after do
+        params.delete(@name)
+        message = "Missing required param: #{@name}."
+        expect { subject }.to raise_error(Stripe::InvalidRequestError, message)
+      end
+
+      it("validates presence of currency") { @name = :currency }
+    end
+  end
+
+  describe "Mock Data" do
+    let(:mock_object) { StripeMock::Data.mock_price }
+    let(:known_attributes) { [
+        :id,
+        :object,
+        :active,
+        :billing_scheme,
+        :created,
+        :currency,
+        :livemode,
+        :lookup_key,
+        :metadata,
+        :nickname,
+        :product,
+        :recurring,
+        :tiers_mode,
+        :transform_quantity,
+        :type,
+        :unit_amount,
+        :unit_amount_decimal
+    ] }
+
+    it "includes all retreived attributes" do
+      expect(mock_object.keys).to eql(known_attributes)
+    end
+  end
+
+end

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)
@@ -550,7 +577,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')
@@ -754,6 +781,43 @@ shared_examples 'Customer Subscriptions' do
       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)
@@ -971,7 +1035,7 @@ shared_examples 'Customer Subscriptions' do
   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)
@@ -1051,7 +1115,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,
@@ -1083,7 +1147,7 @@ shared_examples 'Customer Subscriptions' do
       expect(subscription.items.object).to eq('list')
       expect(subscription.items.data.class).to eq(Array)
       expect(subscription.items.data.count).to eq(1)
-      expect(subscription.items.data.first.id).to eq('test_txn_default')
+      expect(subscription.items.data.first.id).to include('test_si_')
       expect(subscription.items.data.first.created).to eq(1504716183)
       expect(subscription.items.data.first.object).to eq('subscription_item')
       expect(subscription.items.data.first.plan.amount).to eq(0)
@@ -1122,7 +1186,7 @@ shared_examples 'Customer Subscriptions' do
 
   describe "metadata" do
 
-    it "creates a stripe customer and subscribes them to a plan with meta data", :live => true do
+    it "creates a stripe customer and subscribes them to a plan with meta data", live: true do
 
       stripe_helper.
         create_plan(
@@ -1151,3 +1215,46 @@ shared_examples 'Customer Subscriptions' do
   end
 
 end
+
+shared_examples 'Customer Subscriptions with prices' do
+  let(:gen_card_tk) { stripe_helper.generate_card_token }
+
+  let(:product) { stripe_helper.create_product }
+  let(:price) { stripe_helper.create_price(product: product.id, amount: 4999, currency: 'usd') }
+
+  context "creating a new subscription" do
+    it "adds a new subscription to customer with none using items", live: true do
+      customer = Stripe::Customer.create(source: gen_card_tk)
+
+      expect(customer.subscriptions.data).to be_empty
+      expect(customer.subscriptions.count).to eq(0)
+
+      subscription = Stripe::Subscription.create({
+        customer: customer.id,
+        items: [{ price: price.id }],
+        metadata: { foo: "bar", example: "yes" }
+      })
+
+      expect(subscription.object).to eq('subscription')
+      expect(subscription.plan.to_hash).to eq(price.to_hash)
+      expect(subscription.metadata.foo).to eq("bar")
+      expect(subscription.metadata.example).to eq("yes")
+
+      customer = Stripe::Customer.retrieve(customer.id)
+      subscriptions = Stripe::Subscription.list(customer: customer.id)
+      charges = Stripe::Charge.list(customer: customer.id)
+
+      expect(subscriptions.data).to_not be_empty
+      expect(subscriptions.count).to eq(1)
+      expect(subscriptions.data.length).to eq(1)
+      expect(charges.data.length).to eq(1)
+      expect(customer.currency).to eq("usd")
+
+      expect(subscriptions.data.first.id).to eq(subscription.id)
+      expect(subscriptions.data.first.plan.to_hash).to eq(price.to_hash)
+      expect(subscriptions.data.first.customer).to eq(customer.id)
+      expect(subscriptions.data.first.metadata.foo).to eq( "bar" )
+      expect(subscriptions.data.first.metadata.example).to eq( "yes" )
+    end
+  end
+end

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
 

data/spec/support/stripe_examples.rb

@@ -5,6 +5,7 @@ end
 
 def it_behaves_like_stripe(&block)
   it_behaves_like 'Account API', &block
+  it_behaves_like 'Account Link API', &block
   it_behaves_like 'Balance API', &block
   it_behaves_like 'Balance Transaction API', &block
   it_behaves_like 'Bank Account Token Mocking', &block
@@ -12,6 +13,7 @@ def it_behaves_like_stripe(&block)
   it_behaves_like 'Card API', &block
   it_behaves_like 'Charge API', &block
   it_behaves_like 'Bank API', &block
+  it_behaves_like 'Express Login Link API', &block
   it_behaves_like 'External Account API', &block
   it_behaves_like 'Coupon API', &block
   it_behaves_like 'Customer API', &block
@@ -20,6 +22,7 @@ def it_behaves_like_stripe(&block)
   it_behaves_like 'Invoice API', &block
   it_behaves_like 'Invoice Item API', &block
   it_behaves_like 'Plan API', &block
+  it_behaves_like 'Price API', &block
   it_behaves_like 'Product API', &block
   it_behaves_like 'Recipient API', &block
   it_behaves_like 'Refund API', &block
@@ -29,7 +32,8 @@ def it_behaves_like_stripe(&block)
   it_behaves_like 'PaymentMethod API', &block
   it_behaves_like 'SetupIntent API', &block
   it_behaves_like 'Stripe Error Mocking', &block
-  it_behaves_like 'Customer Subscriptions', &block
+  it_behaves_like 'Customer Subscriptions with plans', &block
+  it_behaves_like 'Customer Subscriptions with prices', &block
   it_behaves_like 'Subscription Items API', &block
   it_behaves_like 'Webhook Events API', &block
   it_behaves_like 'Country Spec API', &block

data/stripe-ruby-mock.gemspec

@@ -10,7 +10,12 @@ Gem::Specification.new do |gem|
   gem.license       = "MIT"
   gem.authors       = ["Gilbert"]
   gem.email         = "gilbertbgarza@gmail.com"
-  gem.homepage      = "https://github.com/rebelidealist/stripe-ruby-mock"
+  gem.homepage      = "https://github.com/stripe-ruby-mock/stripe-ruby-mock"
+  gem.metadata      = {
+    "bug_tracker_uri" => "https://github.com/stripe-ruby-mock/stripe-ruby-mock/issues",
+    "changelog_uri"   => "https://github.com/stripe-ruby-mock/stripe-ruby-mock/blob/master/CHANGELOG.md",
+    "source_code_uri" => "https://github.com/stripe-ruby-mock/stripe-ruby-mock"
+  }
 
   gem.files         = `git ls-files`.split($/)
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }