stripe-ruby-mock 2.5.8 → 4.0.0

data/spec/shared_stripe_examples/product_examples.rb

@@ -0,0 +1,215 @@
+require "spec_helper"
+
+shared_examples "Product API" do
+  let(:product_attributes) { {id: "prod_123", name: "My Mock Product"} }
+  let(:product) { Stripe::Product.create(product_attributes) }
+
+  it "creates a stripe product" do
+    expect(product.id).to eq("prod_123")
+    expect(product.name).to eq("My Mock Product")
+    expect(product.type).to eq("service")
+  end
+
+  it "stores a created stripe product in memory" do
+    product = Stripe::Product.create(product_attributes)
+    product2 = Stripe::Product.create(product_attributes.merge({id: "prod_456", name: "My Other Product"}))
+
+    data = test_data_source(:products)
+    expect(data[product.id]).to_not be_nil
+    expect(data[product.id][:id]).to eq("prod_123")
+    expect(data[product.id][:name]).to eq("My Mock Product")
+    expect(data[product2.id]).to_not be_nil
+    expect(data[product2.id][:id]).to eq("prod_456")
+    expect(data[product2.id][:name]).to eq("My Other Product")
+  end
+
+  it "retrieves a stripe product" do
+    original = stripe_helper.create_product(product_attributes)
+    product = Stripe::Product.retrieve(original.id)
+
+    expect(product.id).to eq(original.id)
+    expect(product.name).to eq(original.name)
+  end
+
+  it "updates a stripe product" do
+    stripe_helper.create_product(id: "prod_XYZ", name: "Future Product")
+
+    product = Stripe::Product.retrieve("prod_XYZ")
+    expect(product.name).to eq("Future Product")
+
+    product.name = "Updated Product"
+    product.save
+    product = Stripe::Product.retrieve("prod_XYZ")
+    expect(product.name).to eq("Updated Product")
+  end
+
+  it "cannot retrieve a stripe product that doesn't exist" do
+    expect { Stripe::Product.retrieve('nope') }.to raise_error {|e|
+      expect(e).to be_a Stripe::InvalidRequestError
+      expect(e.param).to eq("product")
+      expect(e.http_status).to eq(404)
+    }
+  end
+
+  it "deletes a stripe product" do
+    stripe_helper.create_product(id: "prod_DEL", name: "Aging Product")
+
+    product = Stripe::Product.retrieve("prod_DEL")
+    expect(product).to_not be_nil
+
+    product.delete
+
+    expect { Stripe::Product.retrieve("prod_DEL") }.to raise_error {|e|
+      expect(e).to be_a Stripe::InvalidRequestError
+      expect(e.param).to eq("product")
+      expect(e.http_status).to eq(404)
+    }
+  end
+
+  it "retrieves all products" do
+    stripe_helper.create_product(id: "prod_123", name: "First Product")
+    stripe_helper.create_product(id: "prod_456", name: "Second Product")
+
+    all = Stripe::Product.list
+    expect(all.count).to eq(2)
+    expect(all.map &:id).to include("prod_123", "prod_456")
+    expect(all.map &:name).to include("First Product", "Second Product")
+  end
+
+  it 'retrieves products with limit' do
+    101.times do |i|
+      stripe_helper.create_product(id: "Product #{i}", name: "My Product ##{i}")
+    end
+    all = Stripe::Product.list(limit: 100)
+
+    expect(all.count).to eq(100)
+  end
+
+  context "searching products" do
+    # the Search API requires about a minute between writes and reads, so add sleeps accordingly when running live
+    it "searches products for exact matches", :aggregate_failures do
+      response = Stripe::Product.search({query: 'name:"one"'}, stripe_version: '2020-08-27')
+      expect(response.data.size).to eq(0)
+
+      one = stripe_helper.create_product(
+        id: "product_1",
+        name: "one",
+        description: "un",
+        shippable: true,
+        url: "http://example.com/one",
+        metadata: {key: "uno"},
+      )
+      two = stripe_helper.create_product(
+        id: "product_2",
+        name: "two",
+        active: false,
+        description: "deux",
+        url: "http://example.com/two",
+        metadata: {key: "dos"},
+      )
+
+      response = Stripe::Product.search({query: 'active:"true"'}, stripe_version: '2020-08-27')
+      expect(response.data.map(&:id)).to match_array([one.id])
+
+      response = Stripe::Product.search({query: 'description:"deux"'}, stripe_version: '2020-08-27')
+      expect(response.data.map(&:id)).to match_array([two.id])
+
+      response = Stripe::Product.search({query: 'name:"one"'}, stripe_version: '2020-08-27')
+      expect(response.data.map(&:id)).to match_array([one.id])
+
+      response = Stripe::Product.search({query: 'shippable:"true"'}, stripe_version: '2020-08-27')
+      expect(response.data.map(&:id)).to match_array([one.id])
+
+      response = Stripe::Product.search({query: 'url:"http://example.com/two"'}, stripe_version: '2020-08-27')
+      expect(response.data.map(&:id)).to match_array([two.id])
+
+      response = Stripe::Product.search({query: 'metadata["key"]:"uno"'}, stripe_version: '2020-08-27')
+      expect(response.data.map(&:id)).to match_array([one.id])
+    end
+
+    it "respects limit", :aggregate_failures do
+      11.times do |i|
+        stripe_helper.create_product(id: "product_#{i}", name: "Product #{i}")
+      end
+
+      response = Stripe::Product.search({query: 'active:"true"'}, stripe_version: '2020-08-27')
+      expect(response.data.size).to eq(10)
+      response = Stripe::Product.search({query: 'active:"true"', limit: 1}, stripe_version: '2020-08-27')
+      expect(response.data.size).to eq(1)
+    end
+
+    it "reports search errors", :aggregate_failures do
+      expect {
+        Stripe::Product.search({limit: 1}, stripe_version: '2020-08-27')
+      }.to raise_error(Stripe::InvalidRequestError, /Missing required param: query./)
+
+      expect {
+        Stripe::Product.search({query: 'asdf'}, stripe_version: '2020-08-27')
+      }.to raise_error(Stripe::InvalidRequestError, /We were unable to parse your search query./)
+
+      expect {
+        Stripe::Product.search({query: 'foo:"bar"'}, stripe_version: '2020-08-27')
+      }.to raise_error(Stripe::InvalidRequestError, /Field `foo` is an unsupported search field for resource `products`./)
+    end
+  end
+
+  describe "Validation", :live => true do
+    include_context "stripe validator"
+    let(:params) { stripe_helper.create_product_params }
+    let(:subject) { Stripe::Product.create(params) }
+    before { stripe_helper.delete_product(params[:id]) }
+
+    describe "Required Parameters" do
+      after do
+        params.delete(@attribute_name)
+        message = stripe_validator.missing_param_message(@attribute_name)
+        expect { subject }.to raise_error(Stripe::InvalidRequestError, message)
+      end
+
+      it("requires a name") { @attribute_name = :name }
+    end
+
+    describe "Uniqueness" do
+      let(:already_exists_message){ stripe_validator.already_exists_message(Stripe::Product) }
+
+      it "validates uniqueness of identifier" do
+        stripe_helper.delete_product(params[:id])
+
+        Stripe::Product.create(params)
+        expect {
+          Stripe::Product.create(params)
+        }.to raise_error(Stripe::InvalidRequestError, already_exists_message)
+      end
+    end
+  end
+
+ describe "Mock Data" do
+    let(:mock_object) { StripeMock::Data.mock_product }
+    let(:known_attributes) { [
+      :id,
+      :object,
+      :active,
+      :attributes,
+      :caption,
+      :created,
+      :deactivate_on,
+      :description,
+      :images,
+      :livemode,
+      :metadata,
+      :name,
+      :package_dimensions,
+      :shippable,
+      :statement_descriptor,
+      :type,
+      :unit_label,
+      :updated,
+      :url
+    ] }
+
+    it "includes all retreived attributes" do
+      expect(mock_object.keys).to eql(known_attributes)
+    end
+  end
+
+end

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

data/spec/shared_stripe_examples/setup_intent_examples.rb

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