stripe-ruby-mock 2.5.8 → 3.0.0

data/spec/shared_stripe_examples/payment_method_examples.rb

@@ -0,0 +1,185 @@
+require 'spec_helper'
+
+shared_examples 'PaymentMethod API' do
+
+  let(:billing_details) do
+    {
+      address: {
+        city: 'North New Portland',
+        country: 'US',
+        line1: '2631 Bloomfield Way',
+        line2: 'Apartment 5B',
+        postal_code: '05555',
+        state: 'ME'
+      },
+      email: 'john@example.com',
+      name: 'John Doe',
+      phone: '555-555-5555'
+    }
+  end
+  let(:card_details) do
+    {
+      number: 4242_4242_4242_4242,
+      exp_month: 9,
+      exp_year: (Time.now.year + 5),
+      cvc: 999
+    }
+  end
+
+  # post /v1/payment_methods
+  describe 'Create a PaymentMethod', live: true do
+    let(:payment_method) do
+      Stripe::PaymentMethod.create(
+        type: type,
+        billing_details: billing_details,
+        card: card_details,
+        metadata: {
+          order_id: '123456789'
+        }
+      )
+    end
+    let(:type) { 'card' }
+
+    it 'creates a payment method with a valid id', live: false do
+      expect(payment_method.id).to match(/^test_pm/)
+    end
+
+    it 'creates a payment method with a billing address' do
+      expect(payment_method.billing_details.address.city).to eq('North New Portland')
+      expect(payment_method.billing_details.address.country).to eq('US')
+      expect(payment_method.billing_details.address.line1).to eq('2631 Bloomfield Way')
+      expect(payment_method.billing_details.address.line2).to eq('Apartment 5B')
+      expect(payment_method.billing_details.address.postal_code).to eq('05555')
+      expect(payment_method.billing_details.address.state).to eq('ME')
+      expect(payment_method.billing_details.email).to eq('john@example.com')
+      expect(payment_method.billing_details.name).to  eq('John Doe')
+      expect(payment_method.billing_details.phone).to eq('555-555-5555')
+    end
+
+    it 'creates a payment method with metadata' do
+      expect(payment_method.metadata.order_id).to eq('123456789')
+    end
+
+    context 'when type is invalid' do
+      let(:type) { 'bank_account' }
+
+      it 'raises invalid requestion exception' do
+        expect { payment_method }.to raise_error(Stripe::InvalidRequestError)
+      end
+    end
+  end
+
+  # get /v1/payment_methods/:id
+  describe 'Retrieve a PaymentMethod', live: true do
+    it 'retrieves a given payment method' do
+      customer = Stripe::Customer.create
+      original = Stripe::PaymentMethod.create(type: 'card', card: card_details)
+      Stripe::PaymentMethod.attach(original.id, customer: customer.id)
+
+      payment_method = Stripe::PaymentMethod.retrieve(original.id)
+
+      expect(payment_method.id).to eq(original.id)
+      expect(payment_method.type).to eq(original.type)
+      expect(payment_method.customer).to eq(customer.id)
+    end
+
+    it "cannot retrieve a payment_method that doesn't exist" do
+      expect { Stripe::PaymentMethod.retrieve('nope') }.to raise_error { |e|
+        expect(e).to be_a Stripe::InvalidRequestError
+        expect(e.param).to eq('payment_method')
+        expect(e.http_status).to eq(404)
+      }
+    end
+
+  end
+
+  # get /v1/payment_methods
+  describe "List a Customer's PaymentMethods", live: true do
+    let(:customer)  { Stripe::Customer.create }
+    let(:customer2) { Stripe::Customer.create }
+    before do
+      3.times do
+        payment_method = Stripe::PaymentMethod.create(type: 'card', card: card_details)
+        Stripe::PaymentMethod.attach(payment_method.id, customer: customer.id)
+      end
+    end
+
+    it 'lists all payment methods' do
+      expect(Stripe::PaymentMethod.list(customer: customer.id, type: 'card').count).to eq(3)
+    end
+
+    context 'when passing a limit' do
+      it 'only lists the limited number of payment methods' do
+        expect(Stripe::PaymentMethod.list(customer: customer.id, type: 'card', limit: 2).count).to eq(2)
+      end
+    end
+
+    context 'when listing the payment methods of another customer' do
+      it 'does not list any payment methods' do
+        expect(Stripe::PaymentMethod.list(customer: customer2.id, type: 'card').count).to eq(0)
+      end
+    end
+  end
+
+  # post /v1/payment_methods/:id/attach
+  describe 'Attach a PaymentMethod to a Customer', live: true do
+    let(:customer) { Stripe::Customer.create }
+    let(:payment_method) { Stripe::PaymentMethod.create(type: 'card', card: card_details) }
+
+    it 'attaches a payment method to a customer' do
+      expect { Stripe::PaymentMethod.attach(payment_method.id, customer: customer.id) }
+        .to change { Stripe::PaymentMethod.retrieve(payment_method.id).customer }
+        .from(nil).to(customer.id)
+    end
+
+    context "when the customer doesn't exist" do
+      it 'raises invalid requestion exception' do
+        expect { Stripe::PaymentMethod.attach(payment_method.id, customer: 'cus_invalid') }
+          .to raise_error(Stripe::InvalidRequestError)
+      end
+    end
+  end
+
+  # post /v1/payment_methods/:id/detach
+  describe 'Detach a PaymentMethod from a Customer', live: true do
+    let(:customer) { Stripe::Customer.create }
+    let(:payment_method) do
+      payment_method = Stripe::PaymentMethod.create(type: 'card', card: card_details)
+      Stripe::PaymentMethod.attach(payment_method.id, customer: customer.id)
+    end
+
+    it 'detaches a PaymentMethod from a customer' do
+      expect { Stripe::PaymentMethod.detach(payment_method.id) }
+        .to change { Stripe::PaymentMethod.retrieve(payment_method.id).customer }
+        .from(customer.id).to(nil)
+    end
+  end
+
+  # post /v1/payment_methods/:id
+  describe 'Update a PaymentMethod', live: true do
+    let(:customer) { Stripe::Customer.create }
+    let(:payment_method) do
+      Stripe::PaymentMethod.create(type: 'card', card: card_details)
+    end
+
+    it 'updates the card for the payment method' do
+      Stripe::PaymentMethod.attach(payment_method.id, customer: customer.id)
+
+      original_card_exp_month = payment_method.card.exp_month
+      new_card_exp_month = 12
+
+      expect do
+        Stripe::PaymentMethod.update(payment_method.id, card: { exp_month: new_card_exp_month })
+      end.to change { Stripe::PaymentMethod.retrieve(payment_method.id).card.exp_month }
+        .from(original_card_exp_month).to(new_card_exp_month)
+    end
+
+    context 'without a customer' do
+      it 'raises invalid requestion exception' do
+        expect do
+          Stripe::PaymentMethod.update(payment_method.id, card: { exp_month: 12 })
+        end.to raise_error(Stripe::InvalidRequestError)
+      end
+    end
+  end
+end

data/spec/shared_stripe_examples/payout_examples.rb

@@ -19,11 +19,11 @@ shared_examples 'Payout API' do
     end
 
     it "without params retrieves all tripe payouts" do
-      expect(Stripe::Payout.all.count).to eq(3)
+      expect(Stripe::Payout.list.count).to eq(3)
     end
 
     it "accepts a limit param" do
-      expect(Stripe::Payout.all(limit: 2).count).to eq(2)
+      expect(Stripe::Payout.list(limit: 2).count).to eq(2)
     end
   end
 

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