stripe-rails 2.0.0.pre → 2.3.0

data/lib/stripe/rails.rb

@@ -4,6 +4,7 @@ require 'stripe/engine'
 require 'stripe/configuration_builder'
 require 'stripe/current_api_version'
 require 'stripe/plans'
+require 'stripe/prices'
 require 'stripe/billing_tier'
 require 'stripe/coupons'
 require 'stripe/products'

data/lib/stripe/rails/tasks.rake

@@ -30,6 +30,15 @@ namespace :stripe do
     Stripe::Coupons.reset!
   end
 
-  desc "create all plans and coupons defined in config/stripe/{products|plans|coupons}.rb"
-  task 'prepare' => ['products:prepare', 'plans:prepare', 'coupons:prepare']
+  task 'prices:prepare' => 'environment' do
+    Stripe::Prices.put!
+  end
+
+  desc 'delete and redefine all prices defined in config/stripe/prices.rb'
+  task 'prices:reset!' => 'environment' do
+    Stripe::Prices.reset!
+  end
+
+  desc "create all plans and coupons defined in config/stripe/{products|plans|prices|coupons}.rb"
+  task 'prepare' => ['products:prepare', 'plans:prepare', 'prices:prepare', 'coupons:prepare']
 end

data/lib/stripe/rails/version.rb

@@ -1,5 +1,5 @@
 module Stripe
   module Rails
-    VERSION = '2.0.0.pre'.freeze
+    VERSION = '2.3.0'.freeze
   end
 end

data/test/coupon_builder_spec.rb

@@ -7,6 +7,7 @@ describe 'building coupons' do
   describe 'default values' do
     before do
       @coupon = Stripe.coupon(:firesale) do |coupon|
+        coupon.name = '100% OFF FIRESALE'
         coupon.duration = 'once'
         coupon.duration_in_months = 100
         coupon.amount_off = 100

data/test/dummy/config/stripe/prices.rb

@@ -0,0 +1,59 @@
+Stripe.price :gold do |price|
+   price.name = 'Solid Gold'
+   price.unit_amount = 699
+   price.recurring = {
+     interval: 'month'
+   }
+end
+
+Stripe.price "Solid Gold".to_sym do |price|
+   price.constant_name = 'SOLID_GOLD'
+   price.name = 'Solid Gold'
+   price.unit_amount = 699
+   price.recurring = {
+     interval: 'month'
+   }
+end
+
+Stripe.price :alternative_currency do |price|
+   price.name = 'Alternative Currency'
+   price.unit_amount = 699
+   price.recurring = {
+     interval: 'month'
+   }
+   price.currency = 'cad'
+end
+
+Stripe.price :metered do |price|
+  price.name = 'Metered'
+  price.unit_amount = 699
+  price.recurring = {
+    interval: 'month',
+    aggregate_usage: 'max',
+    usage_type: 'metered'
+  }
+  price.billing_scheme = 'per_unit'
+end
+
+Stripe.price :tiered do |price|
+  price.name = 'Tiered'
+  price.billing_scheme = 'tiered'
+  # interval must be either 'day', 'week', 'month' or 'year'
+  price.recurring = {
+    interval: 'month',
+    interval_count: 2,
+    aggregate_usage: 'max',
+    usage_type: 'metered'
+  }
+  price.tiers = [
+    {
+      unit_amount: 1500,
+      up_to: 10
+    },
+    {
+      unit_amount: 1000,
+      up_to: 'inf'
+    }
+  ]
+  price.tiers_mode = 'graduated'
+end

data/test/dummy_apis_controller_spec.rb

@@ -9,7 +9,7 @@ describe ApisController do
     header 'Content-Type', 'application/json'
   end
 
-  describe 'the ping interface' do
+  describe 'the apis interface' do
     subject { get '/apis/' }
 
     it { _(subject).must_be :ok? }

data/test/events_controller_spec.rb

@@ -10,6 +10,10 @@ describe Stripe::EventsController do
   end
 
   describe 'the events interface' do
+    subject { post '/stripe/events', params.to_json }
+
+    before { stripe_events_stub }
+
     let(:params) {
       {
         id: 'evt_00000000000000',
@@ -17,14 +21,29 @@ describe Stripe::EventsController do
         data: {object: 'customer'},
       }
     }
-
-    before do
+    let(:stripe_events_stub) do
       stub_request(:get, "https://api.stripe.com/v1/events/evt_00000000000000").
         to_return(status: 200, body: Stripe::Event.construct_from(params).to_json, headers: {})
     end
-    subject { post '/stripe/events', params.to_json }
 
     it { _(subject).must_be :ok? }
+
+    it 'should call the stripe_events_stub' do
+      subject
+      assert_requested(stripe_events_stub)
+    end
+
+    describe 'when signing_secret is nil' do
+      before do
+        header 'Stripe-Signature', 't=1537832721,v1=123,v0=123'
+        app.config.stripe.signing_secret = nil
+      end
+
+      it 'should call the stripe_events_stub' do
+        subject
+        assert_requested(stripe_events_stub)
+      end
+    end
   end
 
   describe 'signed webhooks' do

data/test/fixtures/stripe_prices.json

@@ -0,0 +1,7 @@
+{
+  "object": "list",
+  "count": 0,
+  "data": [],
+  "has_more": false,
+  "url": "/v1/prices"
+}

data/test/plan_builder_spec.rb

@@ -140,7 +140,7 @@ describe 'building plans' do
       }).must_raise Stripe::InvalidConfigurationError
     end
 
-    it 'denies aggregate_usage if usage type is liecensed' do
+    it 'denies aggregate_usage if usage type is licensed' do
       _(lambda {
         Stripe.plan :broken do |plan|
           plan.name = 'Acme as a service'

data/test/price_builder_spec.rb

@@ -0,0 +1,594 @@
+require 'spec_helper'
+
+describe 'building prices' do
+  describe 'simply' do
+    before do
+      Stripe.price :lite do |price|
+        price.name = 'Acme as a service LITE'
+        price.unit_amount = 699
+        price.recurring = {
+          interval: 'month',
+          interval_count: 3,
+          usage_type: 'metered',
+          aggregate_usage: 'sum'
+        }
+        price.metadata = {:number_of_awesome_things => 5}
+        price.statement_descriptor = 'Acme Lite'
+        price.active = true
+        price.nickname = 'lite'
+        price.billing_scheme = 'per_unit'
+        price.tiers_mode = 'graduated'
+      end
+    end
+
+    after { Stripe::Prices.send(:remove_const, :LITE) }
+
+    it 'is accessible via id' do
+      _(Stripe::Prices::LITE).wont_be_nil
+    end
+
+    it 'is accessible via collection' do
+      _(Stripe::Prices.all).must_include Stripe::Prices::LITE
+    end
+
+    it 'is accessible via hash lookup (symbol/string agnostic)' do
+      _(Stripe::Prices[:lite]).must_equal Stripe::Prices::LITE
+      _(Stripe::Prices['lite']).must_equal Stripe::Prices::LITE
+    end
+
+    it 'sets the lookup key' do
+      _(Stripe::Prices::LITE.lookup_key).must_equal 'lite'
+    end
+
+    it 'accepts a billing interval of a day' do
+      Stripe.price :daily do |price|
+        price.name = 'Acme as a service daily'
+        price.unit_amount = 100
+        price.recurring = {
+          interval: 'day'
+        }
+      end
+
+      _(Stripe::Prices::DAILY).wont_be_nil
+    end
+
+    it 'denies a billing interval of a day and excessive intervals' do
+      _(lambda {
+        Stripe.price :broken do |price|
+          price.name = 'Acme as a service daily'
+          price.unit_amount = 100
+          price.recurring = {
+            interval: 'day',
+            interval_count: 366
+          }
+        end
+      }).must_raise Stripe::InvalidConfigurationError
+    end
+
+    it 'accepts a billing interval of a week' do
+      Stripe.price :weekly do |price|
+        price.name = 'Acme as a service weekly'
+        price.unit_amount = 100
+        price.recurring = {
+          interval: 'week'
+        }
+      end
+
+      _(Stripe::Prices::WEEKLY).wont_be_nil
+    end
+
+    it 'denies a billing interval of a week and excessive intervals' do
+      _(lambda {
+        Stripe.price :broken do |price|
+          price.name = 'Acme as a service weekly'
+          price.unit_amount = 100
+          price.recurring = {
+            interval: 'week',
+            interval_count: 53
+          }
+        end
+      }).must_raise Stripe::InvalidConfigurationError
+    end
+
+    it 'accepts a billing interval of a month' do
+      Stripe.price :monthly do |price|
+        price.name = 'Acme as a service monthly'
+        price.unit_amount = 400
+        price.recurring = {
+          interval: 'month'
+        }
+      end
+
+      _(Stripe::Prices::MONTHLY).wont_be_nil
+    end
+
+    it 'denies a billing interval of a month and excessive intervals' do
+      _(lambda {
+        Stripe.price :broken do |price|
+          price.name = 'Acme as a service monthly'
+          price.unit_amount = 400
+          price.recurring = {
+            interval: 'month',
+            interval_count: 13
+          }
+        end
+      }).must_raise Stripe::InvalidConfigurationError
+    end
+
+    it 'accepts a billing interval of a year' do
+      Stripe.price :yearly do |price|
+        price.name = 'Acme as a service yearly'
+        price.unit_amount = 4800
+        price.recurring = {
+          interval: 'year'
+        }
+      end
+
+      _(Stripe::Prices::YEARLY).wont_be_nil
+    end
+
+    it 'denies a billing interval of a year and excessive intervals' do
+      _(lambda {
+        Stripe.price :broken do |price|
+          price.name = 'Acme as a service yearly'
+          price.unit_amount = 4800
+          price.recurring = {
+            interval: 'year',
+            interval_count: 2
+          }
+        end
+      }).must_raise Stripe::InvalidConfigurationError
+    end
+
+    it 'denies arbitrary billing intervals' do
+      _(lambda {
+        Stripe.price :broken do |price|
+          price.name = 'Acme as a service BROKEN'
+          price.unit_amount = 999
+          price.recurring = {
+            interval: 'anything'
+          }
+        end
+      }).must_raise Stripe::InvalidConfigurationError
+    end
+
+    it 'accepts empty recurring options' do
+      Stripe.price :singular do |price|
+        price.name = 'Acme as a service one time'
+        price.unit_amount = 888
+      end
+
+      _(Stripe::Prices::SINGULAR).wont_be_nil
+    end
+
+    it 'accepts a statement descriptor' do
+      Stripe.price :described do |price|
+        price.name = 'Acme as a service'
+        price.unit_amount = 999
+        price.recurring = {
+          interval: 'month'
+        }
+        price.statement_descriptor = 'ACME Monthly'
+      end
+
+      _(Stripe::Prices::DESCRIBED).wont_be_nil
+    end
+
+    it 'denies statement descriptors that are too long' do
+      _(lambda {
+        Stripe.price :described do |price|
+          price.name = 'Acme as a service'
+          price.unit_amount = 999
+          price.recurring = {
+            interval: 'month'
+          }
+          price.statement_descriptor = 'ACME as a Service Monthly'
+        end
+      }).must_raise Stripe::InvalidConfigurationError
+    end
+
+    it 'denies invalid values for active' do
+      _(lambda {
+        Stripe.price :broken do |price|
+          price.name = 'Acme as a service'
+          price.unit_amount = 999
+          price.recurring = {
+            interval: 'month'
+          }
+          price.active = 'whatever'
+        end
+      }).must_raise Stripe::InvalidConfigurationError
+    end
+
+    it 'denies invalid values for usage_type' do
+      _(lambda {
+        Stripe.price :broken do |price|
+          price.name = 'Acme as a service'
+          price.unit_amount = 999
+          price.recurring = {
+            interval: 'month',
+            usage_type: 'whatever'
+          }
+        end
+      }).must_raise Stripe::InvalidConfigurationError
+    end
+
+    it 'denies invalid values for aggregate_usage' do
+      _(lambda {
+        Stripe.price :broken do |price|
+          price.name = 'Acme as a service'
+          price.unit_amount = 999
+          price.recurring = {
+            interval: 'month',
+            aggregate_usage: 'whatever'
+          }
+        end
+      }).must_raise Stripe::InvalidConfigurationError
+    end
+
+    it 'denies aggregate_usage if usage type is licensed' do
+      _(lambda {
+        Stripe.price :broken do |price|
+          price.name = 'Acme as a service'
+          price.unit_amount = 999
+          price.recurring = {
+            interval: 'month',
+            usage_type: 'licensed',
+            aggregate_usage: 'sum'
+          }
+        end
+      }).must_raise Stripe::InvalidConfigurationError
+    end
+
+
+    it 'denies invalid values for billing_scheme' do
+      _(lambda {
+        Stripe.price :broken do |price|
+          price.name = 'Acme as a service'
+          price.unit_amount = 999
+          price.recurring = {
+            interval: 'month'
+          }
+          price.billing_scheme = 'whatever'
+        end
+      }).must_raise Stripe::InvalidConfigurationError
+    end
+
+    it 'denies invalid values for tiers_mode' do
+      _(lambda {
+        Stripe.price :broken do |price|
+          price.name = 'Acme as a service'
+          price.unit_amount = 999
+          price.recurring = {
+            interval: 'month'
+          }
+          price.tiers_mode = 'whatever'
+        end
+      }).must_raise Stripe::InvalidConfigurationError
+    end
+
+    describe 'name and product id validation' do
+      it 'should be valid when using just the product id' do
+        Stripe.price :prodded do |price|
+          price.product_id = 'acme'
+          price.unit_amount = 999
+          price.recurring = {
+            interval: 'month'
+          }
+        end
+        _(Stripe::Prices::PRODDED).wont_be_nil
+      end
+
+      it 'should be invalid when using both name and product id' do
+        _(lambda {
+          Stripe.price :broken do |price|
+            price.name = 'Acme as a service'
+            price.product_id = 'acme'
+            price.unit_amount = 999
+            price.recurring = {
+              interval: 'month'
+            }
+          end
+        }).must_raise Stripe::InvalidConfigurationError
+      end
+    end
+
+    describe 'uploading' do
+      include FixtureLoader
+
+      describe 'when none exists on stripe.com' do
+        before do
+          Stripe::Price.stubs(:list).returns(Stripe::Price.construct_from(data: []))
+
+          stub_request(:get, "https://api.stripe.com/v1/prices").
+            with(headers: { 'Authorization'=>'Bearer XYZ',}).
+            to_return(status: 200, body: load_request_fixture('stripe_prices.json'))
+        end
+
+        it 'creates the price online' do
+          Stripe::Price.expects(:create).with(
+            :lookup_key => 'gold',
+            :nickname => 'gold',
+            :currency => 'usd',
+            :product_data => {
+              :name => 'Solid Gold',
+              :statement_descriptor => nil
+            },
+            :unit_amount => 699,
+            :recurring => {
+              :interval => 'month'
+            }
+          )
+          Stripe::Prices::GOLD.put!
+        end
+
+        it 'creates a price with an alternative currency' do
+          Stripe::Price.expects(:create).with(
+            :lookup_key => 'alternative_currency',
+            :nickname => 'alternative_currency',
+            :currency => 'cad',
+            :product_data => {
+              :name => 'Alternative Currency',
+              :statement_descriptor => nil
+            },
+            :unit_amount => 699,
+            :recurring => {
+              :interval => 'month'
+            }
+          )
+          Stripe::Prices::ALTERNATIVE_CURRENCY.put!
+        end
+
+        it 'creates a metered price' do
+          Stripe::Price.expects(:create).with(
+            :lookup_key => 'metered',
+            :nickname => 'metered',
+            :currency => 'usd',
+            :product_data => {
+              :name => 'Metered',
+              :statement_descriptor => nil,
+            },
+            :unit_amount => 699,
+            :recurring => {
+              :interval => 'month',
+              :usage_type => 'metered',
+              :aggregate_usage => 'max',
+            },
+            :billing_scheme => 'per_unit'
+          )
+          Stripe::Prices::METERED.put!
+        end
+
+        it 'creates a tiered price' do
+          Stripe::Price.expects(:create).with(
+            :lookup_key => 'tiered',
+            :nickname => 'tiered',
+            :currency => 'usd',
+            :product_data => {
+              :name => 'Tiered',
+              :statement_descriptor => nil,
+            },
+            :recurring => {
+              :interval => 'month',
+              :interval_count => 2,
+              :usage_type => 'metered',
+              :aggregate_usage => 'max'
+            },
+            :billing_scheme => 'tiered',
+            :tiers => [
+              {
+                :unit_amount => 1500,
+                :up_to => 10
+              },
+              {
+                :unit_amount => 1000,
+                :up_to => 'inf'
+              }
+            ],
+            :tiers_mode => 'graduated'
+          )
+          Stripe::Prices::TIERED.put!
+        end
+
+        describe 'when passed invalid arguments for tiered pricing' do
+          it 'raises a Stripe::InvalidConfigurationError when billing tiers are invalid' do
+            lambda {
+              Stripe.price "Bad Tiers".to_sym do |price|
+                price.name = 'Acme as a service BAD TIERS'
+                price.constant_name = 'BAD_TIERS'
+                price.recurring = {
+                  interval: 'month',
+                  interval_count: 1,
+                  usage_type: 'metered',
+                  aggregate_usage: 'sum'
+                }
+                price.tiers_mode = 'graduated'
+                price.billing_scheme = 'per_unit'
+                price.tiers = [
+                  {
+                    unit_amount: 1500,
+                    up_to: 10
+                  },
+                  {
+                    unit_amount: 1000,
+                  }
+                ]
+              end
+            }.must_raise Stripe::InvalidConfigurationError
+          end
+
+          it 'raises a Stripe::InvalidConfigurationError when billing tiers is not an array' do
+            lambda {
+              Stripe.price "Bad Tiers".to_sym do |price|
+                price.name = 'Acme as a service BAD TIERS'
+                price.constant_name = 'BAD_TIERS'
+                price.recurring = {
+                  interval: 'month',
+                  interval_count: 1,
+                  usage_type: 'metered',
+                  aggregate_usage: 'sum'
+                }
+                price.tiers_mode = 'graduated'
+                price.billing_scheme = 'per_unit'
+                price.tiers = {
+                  unit_amount: 1500,
+                  up_to: 10
+                }
+              end
+            }.must_raise Stripe::InvalidConfigurationError
+          end
+        end
+
+        describe 'when using a product id' do
+          before do
+            Stripe::Prices::GOLD.product_id = 'prod_XXXXXXXXXXXXXX'
+            Stripe::Prices::GOLD.name = nil
+          end
+          after do
+            Stripe::Prices::GOLD.product_id = nil
+            Stripe::Prices::GOLD.name = 'Solid Gold'
+          end
+
+          it 'creates the price online with the product id' do
+            Stripe::Price.expects(:create).with(
+              :lookup_key => 'gold',
+              :nickname => 'gold',
+              :currency => 'usd',
+              :product => 'prod_XXXXXXXXXXXXXX',
+              :unit_amount => 699,
+              :recurring => {
+                :interval => 'month'
+              }
+            )
+            Stripe::Prices::GOLD.put!
+          end
+        end
+      end
+
+      describe 'when it is already present on stripe.com' do
+        before do
+          Stripe::Prices::GOLD.product_id = nil
+          Stripe::Price.stubs(:list).returns(Stripe::Price.construct_from(
+            data: [{
+              :lookup_key => 'gold',
+              :product => 'prod_XXXXXXXXXXXXXX'
+          }]))
+        end
+        after do
+          Stripe::Prices::GOLD.product_id = nil
+        end
+
+
+        it 'is a no-op on put!' do
+          Stripe::Price.expects(:create).never
+          Stripe::Prices::GOLD.put!
+        end
+
+        it 'transfers lookup key on reset!' do
+          Stripe::Price.expects(:create).with(
+            :lookup_key => 'gold',
+            :transfer_lookup_key => true,
+            :nickname => 'gold',
+            :currency => 'usd',
+            :product => 'prod_XXXXXXXXXXXXXX',
+            :unit_amount => 699,
+            :recurring => {
+              :interval => 'month'
+            }
+          )
+
+          Stripe::Prices::GOLD.reset!
+        end
+      end
+    end
+  end
+
+  describe 'with missing mandatory values' do
+    it 'raises an exception after configuring it' do
+      _(-> { Stripe.price(:bad) {} }).must_raise Stripe::InvalidConfigurationError
+    end
+  end
+
+  describe 'with custom constant name' do
+    before do
+      Stripe.price "Lite price".to_sym do |price|
+        price.name = 'Acme as a service LITE'
+        price.constant_name = 'LITE_PRICE'
+        price.unit_amount = 699
+        price.recurring = {
+          interval: 'month',
+          interval_count: 3,
+          usage_type: 'metered',
+          aggregate_usage: 'sum'
+        }
+        price.metadata = {:number_of_awesome_things => 5}
+        price.statement_descriptor = 'Acme Lite'
+        price.active = true
+        price.nickname = 'lite'
+        price.billing_scheme = 'per_unit'
+        price.tiers_mode = 'graduated'
+      end
+    end
+
+    after { Stripe::Prices.send(:remove_const, :LITE_PRICE) }
+
+    it 'is accessible via upcased constant_name' do
+      _(Stripe::Prices::LITE_PRICE).wont_be_nil
+    end
+
+    it 'is accessible via collection' do
+      _(Stripe::Prices.all).must_include Stripe::Prices::LITE_PRICE
+    end
+
+    it 'is accessible via hash lookup (symbol/string agnostic)' do
+      _(Stripe::Prices[:lite_price]).must_equal Stripe::Prices::LITE_PRICE
+      _(Stripe::Prices['lite_price']).must_equal Stripe::Prices::LITE_PRICE
+    end
+
+    describe 'constant name validation' do
+      it 'should be invalid when providing a constant name that can not be used for Ruby constant' do
+        _(lambda {
+          Stripe.price "Lite price".to_sym do |price|
+            price.name = 'Acme as a service LITE'
+            price.constant_name = 'LITE PRICE'
+            price.unit_amount = 999
+            price.recurring = {
+              interval: 'month'
+            }
+          end
+        }).must_raise Stripe::InvalidConfigurationError
+      end
+    end
+
+    describe 'uploading' do
+      include FixtureLoader
+
+      describe 'when none exists on stripe.com' do
+        before do
+          Stripe::Price.stubs(:list).returns(Stripe::Price.construct_from(data: []))
+
+          stub_request(:get, "https://api.stripe.com/v1/prices").
+            with(headers: { 'Authorization'=>'Bearer XYZ',}).
+            to_return(status: 200, body: load_request_fixture('stripe_prices.json'))
+        end
+
+        it 'creates the price online' do
+          Stripe::Price.expects(:create).with(
+            :lookup_key => "Solid Gold",
+            :nickname => "Solid Gold",
+            :currency => 'usd',
+            :product_data => {
+              :name => 'Solid Gold',
+              :statement_descriptor => nil
+            },
+            :unit_amount => 699,
+            :recurring => {
+              :interval => 'month'
+            }
+          )
+          Stripe::Prices::SOLID_GOLD.put!
+        end
+      end
+    end
+  end
+end