stripe-ruby-mock 2.5.8 → 4.0.0

data/spec/shared_stripe_examples/plan_examples.rb

@@ -1,93 +1,73 @@
 require 'spec_helper'
 
 shared_examples 'Plan API' do
+  let(:product) { stripe_helper.create_product }
+  let(:product_id) { product.id }
+
+  let(:plan_attributes) { {
+    :id => "plan_abc123",
+    :product => product_id,
+    :nickname => "My Mock Plan",
+    :amount => 9900,
+    :currency => "usd",
+    :interval => "month"
+  } }
+  let(:plan) { Stripe::Plan.create(plan_attributes) }
+
+  let(:plan_attributes_without_id){ plan_attributes.merge(id: nil) }
+  let(:plan_without_id){ Stripe::Plan.create(plan_attributes_without_id) }
+
+  let(:plan_attributes_with_trial) { plan_attributes.merge(id: "prod_TRIAL", :trial_period_days => 30) }
+  let(:plan_with_trial) { Stripe::Plan.create(plan_attributes_with_trial) }
+
+  let(:metadata) { {:description => "desc text", :info => "info text"} }
+  let(:plan_attributes_with_metadata) { plan_attributes.merge(id: "prod_META", metadata: metadata) }
+  let(:plan_with_metadata) { Stripe::Plan.create(plan_attributes_with_metadata) }
+
+  before(:each) do
+    product
+  end
 
   it "creates a stripe plan" do
-    plan = Stripe::Plan.create(
-      :id => 'pid_1',
-      :name => 'The Mock Plan',
-      :amount => 9900,
-      :currency => 'USD',
-      :interval => 1,
-      :product => {
-        :name => 'A product'
-      },
-      :metadata => {
-        :description => "desc text",
-        :info => "info text"
-      },
-      :trial_period_days => 30
-    )
-
-    expect(plan.id).to eq('pid_1')
-    expect(plan.name).to eq('The Mock Plan')
+    expect(plan.id).to eq('plan_abc123')
+    expect(plan.nickname).to eq('My Mock Plan')
     expect(plan.amount).to eq(9900)
 
-    expect(plan.currency).to eq('USD')
-    expect(plan.interval).to eq(1)
+    expect(plan.currency).to eq('usd')
+    expect(plan.interval).to eq("month")
 
-    expect(plan.metadata.description).to eq('desc text')
-    expect(plan.metadata.info).to eq('info text')
+    expect(plan_with_metadata.metadata.description).to eq('desc text')
+    expect(plan_with_metadata.metadata.info).to eq('info text')
 
-    expect(plan.trial_period_days).to eq(30)
+    expect(plan_with_trial.trial_period_days).to eq(30)
   end
 
-
   it "creates a stripe plan without specifying ID" do
-    plan = Stripe::Plan.create(
-      :name => 'The Mock Plan',
-      :amount => 9900,
-      :currency => 'USD',
-      :interval => 1,
-      :product => {
-        :name => 'A product'
-      }
-    )
-
-    expect(plan.id).to match(/^test_plan/)
+    expect(plan_attributes_without_id[:id]).to be_nil
+    expect(plan_without_id.id).to match(/^test_plan_1/)
   end
 
   it "stores a created stripe plan in memory" do
-    plan = Stripe::Plan.create(
-      :id => 'pid_2',
-      :name => 'The Memory Plan',
-      :amount => 1100,
-      :currency => 'USD',
-      :interval => 1,
-      :product => {
-        :name => 'A product'
-      }
-    )
-    plan2 = Stripe::Plan.create(
-      :id => 'pid_3',
-      :name => 'The Bonk Plan',
-      :amount => 7777,
-      :currency => 'USD',
-      :interval => 1,
-      :product => {
-        :name => 'A product'
-      }
-    )
+    plan
+    plan2 = Stripe::Plan.create(plan_attributes.merge(id: "plan_def456", amount: 299))
+
     data = test_data_source(:plans)
     expect(data[plan.id]).to_not be_nil
-    expect(data[plan.id][:amount]).to eq(1100)
-
+    expect(data[plan.id][:amount]).to eq(9900)
     expect(data[plan2.id]).to_not be_nil
-    expect(data[plan2.id][:amount]).to eq(7777)
+    expect(data[plan2.id][:amount]).to eq(299)
   end
 
-
   it "retrieves a stripe plan" do
-    original = stripe_helper.create_plan(amount: 1331)
+    original = stripe_helper.create_plan(product: product_id, amount: 1331, id: 'plan_943843')
     plan = Stripe::Plan.retrieve(original.id)
 
     expect(plan.id).to eq(original.id)
     expect(plan.amount).to eq(original.amount)
   end
 
-
   it "updates a stripe plan" do
-    stripe_helper.create_plan(id: 'super_member', amount: 111)
+    stripe_helper.create_plan(id: 'super_member', product: product_id, amount: 111)
 
     plan = Stripe::Plan.retrieve('super_member')
     expect(plan.amount).to eq(111)
@@ -98,7 +78,6 @@ shared_examples 'Plan API' do
     expect(plan.amount).to eq(789)
   end
 
-
   it "cannot retrieve a stripe plan that doesn't exist" do
     expect { Stripe::Plan.retrieve('nope') }.to raise_error {|e|
       expect(e).to be_a Stripe::InvalidRequestError
@@ -108,7 +87,7 @@ shared_examples 'Plan API' do
   end
 
   it "deletes a stripe plan" do
-    stripe_helper.create_plan(id: 'super_member', amount: 111)
+    stripe_helper.create_plan(id: 'super_member', product: product_id, amount: 111)
 
     plan = Stripe::Plan.retrieve('super_member')
     expect(plan).to_not be_nil
@@ -123,10 +102,10 @@ shared_examples 'Plan API' do
   end
 
   it "retrieves all plans" do
-    stripe_helper.create_plan(id: 'Plan One', amount: 54321)
-    stripe_helper.create_plan(id: 'Plan Two', amount: 98765)
+    stripe_helper.create_plan(id: 'Plan One', product: product_id, amount: 54321)
+    stripe_helper.create_plan(id: 'Plan Two', product: product_id, amount: 98765)
 
-    all = Stripe::Plan.all
+    all = Stripe::Plan.list
     expect(all.count).to eq(2)
     expect(all.map &:id).to include('Plan One', 'Plan Two')
     expect(all.map &:amount).to include(54321, 98765)
@@ -134,33 +113,31 @@ shared_examples 'Plan API' do
 
   it 'retrieves plans with limit' do
     101.times do | i|
-      stripe_helper.create_plan(id: "Plan #{i}", amount: 11)
+      stripe_helper.create_plan(id: "Plan #{i}", product: product_id, amount: 11)
     end
-    all = Stripe::Plan.all(limit: 100)
+    all = Stripe::Plan.list(limit: 100)
 
     expect(all.count).to eq(100)
   end
 
-  it 'validates the amount' do
-    expect {
-      Stripe::Plan.create(
-        :id => 'pid_1',
-        :name => 'The Mock Plan',
-        :amount => 99.99,
-        :currency => 'USD',
-        :interval => 'month',
-        :product => {
-          :name => 'A product'
-        }
-      )
-    }.to raise_error(Stripe::InvalidRequestError, "Invalid integer: 99.99")
-  end
-
-  describe "Validation", :live => true do
-    let(:params) { stripe_helper.create_plan_params }
+  describe "Validations", :live => true do
+    include_context "stripe validator"
+    let(:params) { stripe_helper.create_plan_params(product: product_id) }
     let(:subject) { Stripe::Plan.create(params) }
 
-    describe "Required Parameters" do
+    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_plan_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 =
@@ -172,13 +149,49 @@ shared_examples 'Plan API' do
         expect { subject }.to raise_error(Stripe::InvalidRequestError, message)
       end
 
-      it("requires a product") { @name = :product }
-      it("requires an amount") { @name = :amount }
-      it("requires a currency") { @name = :currency }
-      it("requires an interval") { @name = :interval }
+      it("validates presence of interval") { @name = :interval }
+      it("validates presence of currency") { @name = :currency }
+      it("validates presence of product") { @name = :product }
+      it("validates presence of amount") { @name = :amount }
+    end
+
+    describe "Inclusion" do
+      let(:invalid_interval) { "OOPS" }
+      let(:invalid_interval_message) { stripe_validator.invalid_plan_interval_message }
+      let(:invalid_interval_params) { params.merge({interval: invalid_interval}) }
+      let(:plan_with_invalid_interval) { Stripe::Plan.create(invalid_interval_params) }
+
+      before(:each) do
+        product
+      end
+
+      it "validates inclusion of interval" do
+        expect { plan_with_invalid_interval }.to raise_error(Stripe::InvalidRequestError, invalid_interval_message)
+      end
+
+      let(:invalid_currency) { "OOPS" }
+      let(:invalid_currency_message) { stripe_validator.invalid_currency_message(invalid_currency) }
+      let(:invalid_currency_params) { params.merge({currency: invalid_currency}) }
+      let(:plan_with_invalid_currency) { Stripe::Plan.create(invalid_currency_params) }
+
+      it "validates inclusion of currency" do
+        expect { plan_with_invalid_currency }.to raise_error(Stripe::InvalidRequestError, invalid_currency_message)
+      end
+    end
+
+    describe "Numericality" do
+      let(:invalid_integer) { 99.99 }
+      let(:invalid_integer_message) { stripe_validator.invalid_integer_message(invalid_integer)}
+
+      it 'validates amount is an integer' do
+        expect {
+          Stripe::Plan.create( plan_attributes.merge({amount: invalid_integer}) )
+        }.to raise_error(Stripe::InvalidRequestError, invalid_integer_message)
+      end
     end
 
     describe "Uniqueness" do
+      let(:already_exists_message) { stripe_validator.already_exists_message(Stripe::Plan) }
 
       it "validates for uniqueness" do
         stripe_helper.delete_plan(params[:id])
@@ -186,9 +199,39 @@ shared_examples 'Plan API' do
         Stripe::Plan.create(params)
         expect {
           Stripe::Plan.create(params)
-        }.to raise_error(Stripe::InvalidRequestError, "Plan already exists.")
+        }.to raise_error(Stripe::InvalidRequestError, already_exists_message)
       end
     end
+
+  end
+
+  describe "Mock Data" do
+    let(:mock_object) { StripeMock::Data.mock_plan }
+    let(:known_attributes) { [
+      :id,
+      :object,
+      :active,
+      :aggregate_usage,
+      :amount,
+      :billing_scheme,
+      :created,
+      :currency,
+      :interval,
+      :interval_count,
+      :livemode,
+      :metadata,
+      :nickname,
+      :product,
+      :tiers,
+      :tiers_mode,
+      :transform_usage,
+      :trial_period_days,
+      :usage_type
+    ] }
+
+    it "includes all retreived attributes" do
+      expect(mock_object.keys).to eql(known_attributes)
+    end
   end
 
 end

data/spec/shared_stripe_examples/price_examples.rb

@@ -0,0 +1,292 @@
+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
+
+  context "searching prices" do
+    # the Search API requires about a minute between writes and reads, so add sleeps accordingly when running live
+    it "searches prices for exact matches", :aggregate_failures do
+      response = Stripe::Price.search({query: 'currency:"usd"'}, stripe_version: '2020-08-27')
+      expect(response.data.size).to eq(0)
+
+      one = stripe_helper.create_price(
+        amount: 100,
+        currency: 'usd',
+        lookup_key: 'one',
+        product: product_id,
+        metadata: {key: 'uno'},
+        type: "one_time",
+      )
+      two = stripe_helper.create_price(
+        active: false,
+        amount: 200,
+        currency: 'gbp',
+        lookup_key: 'two',
+        product: product_id,
+        recurring: {interval: 'month'},
+        metadata: {key: 'dos'},
+      )
+
+      response = Stripe::Price.search({query: 'active:"true"'}, stripe_version: '2020-08-27')
+      expect(response.data.map(&:id)).to match_array([one.id])
+
+      response = Stripe::Price.search({query: 'currency:"gbp"'}, stripe_version: '2020-08-27')
+      expect(response.data.map(&:id)).to match_array([two.id])
+
+      response = Stripe::Price.search({query: 'lookup_key:"one"'}, stripe_version: '2020-08-27')
+      expect(response.data.map(&:id)).to match_array([one.id])
+
+      response = Stripe::Price.search({query: %(product:"#{product.id}")}, stripe_version: '2020-08-27')
+      expect(response.data.map(&:id)).to match_array([one.id, two.id])
+
+      response = Stripe::Price.search({query: 'type:"recurring"'}, stripe_version: '2020-08-27')
+      expect(response.data.map(&:id)).to match_array([two.id])
+
+      response = Stripe::Price.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
+        stripe_helper.create_price(product: product_id)
+      end
+
+      response = Stripe::Price.search({query: %(product:"#{product.id}")}, stripe_version: '2020-08-27')
+      expect(response.data.size).to eq(10)
+      response = Stripe::Price.search({query: %(product:"#{product.id}"), limit: 1}, stripe_version: '2020-08-27')
+      expect(response.data.size).to eq(1)
+    end
+
+    it "reports search errors", :aggregate_failures do
+      expect {
+        Stripe::Price.search({limit: 1}, stripe_version: '2020-08-27')
+      }.to raise_error(Stripe::InvalidRequestError, /Missing required param: query./)
+
+      expect {
+        Stripe::Price.search({query: 'asdf'}, stripe_version: '2020-08-27')
+      }.to raise_error(Stripe::InvalidRequestError, /We were unable to parse your search query./)
+
+      expect {
+        Stripe::Price.search({query: 'foo:"bar"'}, stripe_version: '2020-08-27')
+      }.to raise_error(Stripe::InvalidRequestError, /Field `foo` is an unsupported search field for resource `prices`./)
+    end
+  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