stripe-ruby-mock 3.0.1 → 3.1.0

data/spec/shared_stripe_examples/price_examples.rb

@@ -0,0 +1,223 @@
+require 'spec_helper'
+
+shared_examples 'Price API' do
+  let(:product_id) { "product_id_1" }
+  let(:product) { stripe_helper.create_product(id: product_id) }
+
+  let(:other_product_id) { "product_id_2" }
+  let(:other_product) { stripe_helper.create_product(id: other_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
+    other_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
+
+  it "retrieves prices filtering by currency" do
+    5.times do | i|
+      stripe_helper.create_price(id: "usd price #{i}", product: product_id, amount: 11, currency: 'usd')
+      stripe_helper.create_price(id: "brl price #{i}", product: product_id, amount: 11, currency: 'brl')
+    end
+
+    all = Stripe::Price.list()
+    expect(all.count).to eq(10)
+
+    usd = Stripe::Price.list({currency: 'usd'})
+    expect(usd.count).to eq(5)
+    expect(usd.all? {|p| p.currency == 'usd' }).to be_truthy
+
+    brl = Stripe::Price.list({currency: 'brl'})
+    expect(brl.count).to eq(5)
+    expect(brl.all? {|p| p.currency == 'brl' }).to be_truthy
+  end
+
+  it "retrieves prices filtering by product" do
+    5.times do | i|
+      stripe_helper.create_price(id: "product 1 price #{i}", product: product_id)
+      stripe_helper.create_price(id: "product 2 price #{i}", product: other_product_id)
+    end
+
+    all = Stripe::Price.list()
+    expect(all.count).to eq(10)
+
+    product_prices = Stripe::Price.list({product: product.id})
+    expect(product_prices.count).to eq(5)
+    expect(product_prices.all? {|p| p.product == product.id }).to be_truthy
+
+    other_product_prices = Stripe::Price.list({product: other_product.id})
+    expect(other_product_prices.count).to eq(5)
+    expect(other_product_prices.all? {|p| p.product == other_product.id }).to be_truthy
+  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/product_examples.rb

@@ -1,7 +1,7 @@
 require "spec_helper"
 
 shared_examples "Product API" do
-  let(:product_attributes) { {id: "prod_123", name: "My Mock Product", type: "service"} }
+  let(:product_attributes) { {id: "prod_123", name: "My Mock Product"} }
   let(:product) { Stripe::Product.create(product_attributes) }
 
   it "creates a stripe product" do
@@ -101,14 +101,6 @@ shared_examples "Product API" do
       it("requires a name") { @attribute_name = :name }
     end
 
-    describe "Inclusion" do
-      it "validates inclusion of type in 'good' or 'service'" do
-        expect {
-          Stripe::Product.create(params.merge({type: "OOPS"}))
-        }.to raise_error(Stripe::InvalidRequestError, "Invalid type: must be one of good or service")
-      end
-    end
-
     describe "Uniqueness" do
       let(:already_exists_message){ stripe_validator.already_exists_message(Stripe::Product) }
 

data/spec/shared_stripe_examples/promotion_code_examples.rb

@@ -0,0 +1,68 @@
+require "spec_helper"
+
+shared_examples "PromotionCode API" do
+  let(:coupon) { stripe_helper.create_coupon }
+
+  it "creates a promotion code" do
+    promotion_code = Stripe::PromotionCode.create({id: "promo_123", coupon: coupon.id, code: "FREESTUFF"})
+
+    expect(promotion_code.id).to eq("promo_123")
+    expect(promotion_code.code).to eq("FREESTUFF")
+    expect(promotion_code.coupon).to eq(coupon.id)
+  end
+
+  it "creates a promotion code without specifying code" do
+    promotion_code = Stripe::PromotionCode.create({id: "promo_123", coupon: coupon.id})
+
+    expect(promotion_code.id).to eq("promo_123")
+    expect(promotion_code.code).to eq("TESTCODE")
+    expect(promotion_code.coupon).to eq(coupon.id)
+  end
+
+  it "cannot create a promotion code without a coupon" do
+    expect {
+      Stripe::PromotionCode.create
+    }.to raise_error { |e|
+      expect(e).to be_a(Stripe::InvalidRequestError)
+      expect(e.message).to eq("Missing required param: coupon")
+    }
+  end
+
+  it "requires minimum amount currency when minimum amount is provided" do
+    expect {
+      Stripe::PromotionCode.create(coupon: coupon, restrictions: {minimum_amount: 100})
+    }.to raise_error { |e|
+      expect(e).to be_a(Stripe::InvalidRequestError)
+      expect(e.message).to eq("You must pass minimum_amount_currency when passing minimum_amount")
+    }
+  end
+
+  it "updates a promotion code" do
+    promotion_code = Stripe::PromotionCode.create({coupon: coupon.id})
+    expect(promotion_code.active).to eq(true)
+
+    updated = Stripe::PromotionCode.update(promotion_code.id, active: false)
+
+    expect(updated.active).to eq(false)
+  end
+
+  it "retrieves a promotion code" do
+    original = Stripe::PromotionCode.create({coupon: coupon.id})
+
+    promotion_code = Stripe::PromotionCode.retrieve(original.id)
+
+    expect(promotion_code.id).to eq(original.id)
+    expect(promotion_code.code).to eq(original.code)
+    expect(promotion_code.coupon).to eq(original.coupon)
+  end
+
+  it "lists all promotion codes" do
+    Stripe::PromotionCode.create({coupon: coupon.id, code: "10PERCENT"})
+    Stripe::PromotionCode.create({coupon: coupon.id, code: "20PERCENT"})
+
+    all = Stripe::PromotionCode.list
+
+    expect(all.count).to eq(2)
+    expect(all.map(&:code)).to include("10PERCENT", "20PERCENT")
+  end
+end

data/spec/shared_stripe_examples/refund_examples.rb

@@ -22,6 +22,19 @@ shared_examples 'Refund API' do
       expect(charge.amount_refunded).to eq(999)
     end
 
+    it "refunds a stripe payment intent" do
+      payment_intent = Stripe::PaymentIntent.create(
+        amount: 999,
+        currency: 'USD'
+      )
+
+      refund = Stripe::Refund.create(
+        payment_intent: payment_intent.id
+      )
+      expect(refund.amount).to eq(999)
+    end
+
+
     it "creates a stripe refund with a status" do
       charge = Stripe::Charge.create(
         amount: 999,

data/spec/shared_stripe_examples/setup_intent_examples.rb

@@ -10,6 +10,14 @@ shared_examples 'SetupIntent API' do
     expect(setup_intent.status).to eq('requires_payment_method')
   end
 
+  it 'creates a stripe setup intent with payment method' do
+    setup_intent = Stripe::SetupIntent.create(payment_method: 'random')
+
+    expect(setup_intent.id).to match(/^test_si/)
+    expect(setup_intent.metadata.to_hash).to eq({})
+    expect(setup_intent.status).to eq('requires_action')
+  end
+
   describe "listing setup_intent" do
     before do
       3.times do
@@ -42,6 +50,15 @@ shared_examples 'SetupIntent API' do
     }
   end
 
+  it "expands payment_method" do
+    payment_method = Stripe::PaymentMethod.create(type: "card")
+    original = Stripe::SetupIntent.create(payment_method: payment_method.id)
+
+    setup_intent = Stripe::SetupIntent.retrieve({id: original.id, expand: ["payment_method"]})
+
+    expect(setup_intent.payment_method).to eq(payment_method)
+  end
+
   it "confirms a stripe setup_intent" do
     setup_intent = Stripe::SetupIntent.create()
     confirmed_setup_intent = setup_intent.confirm()