reji 1.0.0

data/spec/dummy/config/database.yml

@@ -0,0 +1,11 @@
+development:
+  adapter: sqlite3
+  database: db/development.sqlite3
+  pool: 5
+  timeout: 5000
+
+test:
+  adapter: sqlite3
+  database: ":memory:"
+  pool: 5
+  timeout: 5000

data/spec/dummy/db/schema.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+ActiveRecord::Schema.define(version: 2020_01_01_00_00_00) do
+  create_table 'subscription_items', force: true do |t|
+    t.bigint 'subscription_id', null: false
+    t.string 'stripe_id', null: false
+    t.string 'stripe_plan', null: false
+    t.integer 'quantity', null: false
+    t.datetime 'created_at', precision: 6, null: false
+    t.datetime 'updated_at', precision: 6, null: false
+    t.index ['stripe_id'], name: 'index_subscription_items_on_stripe_id'
+    t.index ['subscription_id', 'stripe_plan'], name: 'index_subscription_items_on_subscription_id_and_stripe_plan', unique: true
+  end
+
+  create_table 'subscriptions', force: true do |t|
+    t.bigint 'user_id', null: false
+    t.string 'name', null: false
+    t.string 'stripe_id', null: false
+    t.string 'stripe_status', null: false
+    t.string 'stripe_plan'
+    t.integer 'quantity'
+    t.timestamp 'trial_ends_at'
+    t.timestamp 'ends_at'
+    t.datetime 'created_at', precision: 6, null: false
+    t.datetime 'updated_at', precision: 6, null: false
+    t.index ['user_id', 'stripe_status'], name: 'index_subscriptions_on_user_id_and_stripe_status'
+  end
+
+  create_table 'users', force: true do |t|
+    t.string 'email', default: '', null: false
+    t.string 'stripe_id'
+    t.string 'card_brand'
+    t.string 'card_last_four', limit: 4
+    t.timestamp 'trial_ends_at'
+    t.datetime 'created_at', precision: 6, null: false
+    t.datetime 'updated_at', precision: 6, null: false
+    t.index ['email'], name: 'index_users_on_email', unique: true
+  end
+end
+

data/spec/feature/charges_spec.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe 'charges', type: :request do
+  it 'test_customer_can_be_charged' do
+    user = create_customer('customer_can_be_charged')
+    user.create_as_stripe_customer
+
+    response = user.charge(1000, 'pm_card_visa')
+
+    expect(response).to be_an_instance_of(Reji::Payment)
+    expect(response.raw_amount).to eq(1000)
+    expect(response.customer).to eq(user.stripe_id)
+  end
+
+  it 'test_non_stripe_customer_can_be_charged' do
+    user = create_customer('non_stripe_customer_can_be_charged')
+
+    response = user.charge(1000, 'pm_card_visa')
+
+    expect(response).to be_an_instance_of(Reji::Payment)
+    expect(response.raw_amount).to eq(1000)
+    expect(response.customer).to eq(user.stripe_id)
+  end
+
+  it 'test_customer_can_be_charged_and_invoiced_immediately' do
+    user = create_customer('customer_can_be_charged_and_invoiced_immediately')
+    user.create_as_stripe_customer
+    user.update_default_payment_method('pm_card_visa')
+
+    user.invoice_for('Rails Reji', 1000)
+
+    invoice = user.invoices.first
+
+    expect(invoice.total).to eq('$10.00')
+    expect(invoice.invoice_items.first.as_stripe_invoice_line_item.description).to eq('Rails Reji')
+  end
+
+  it 'test_customer_can_be_refunded' do
+    user = create_customer('customer_can_be_refunded')
+    user.create_as_stripe_customer
+    user.update_default_payment_method('pm_card_visa')
+
+    invoice = user.invoice_for('Rails Reji', 1000)
+    refund = user.refund(invoice.payment_intent)
+
+    expect(refund.amount).to eq(1000)
+  end
+
+  it 'test_charging_may_require_an_extra_action' do
+    user = create_customer('charging_may_require_an_extra_action')
+    user.create_as_stripe_customer
+
+    begin
+      user.charge(1000, 'pm_card_threeDSecure2Required')
+
+      raise RSpec::Expectations::ExpectationNotMetError.new('Expected exception PaymentActionRequiredError was not thrown.')
+    rescue Reji::PaymentActionRequiredError => e
+      # Assert that the payment needs an extra action.
+      expect(e.payment.requires_action).to be true
+
+      # Assert that the payment was for the correct amount.
+      expect(e.payment.raw_amount).to eq(1000)
+    end
+  end
+end

data/spec/feature/customer_spec.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe 'customer', type: :request do
+  it 'test_customers_in_stripe_can_be_updated' do
+    user = create_customer('customers_in_stripe_can_be_updated')
+    user.create_as_stripe_customer
+
+    customer = user.update_stripe_customer({:description => 'Van Cam'})
+
+    expect(customer.description).to eq('Van Cam')
+  end
+
+  # it 'test_customers_can_generate_a_billing_portal_url' do
+  #   user = create_customer('customers_in_stripe_can_be_updated')
+  #   user.create_as_stripe_customer
+
+  #   url = user.billing_portal_url('https://example.com')
+
+  #   expect(url).to start_with('https://billing.stripe.com/session/')
+  # end
+end

data/spec/feature/invoices_spec.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe 'invoices', type: :request do
+  it 'test_require_stripe_customer_for_invoicing' do
+    user = create_customer('require_stripe_customer_for_invoicing')
+
+    expect {
+      user.invoice
+    }.to raise_error(Reji::InvalidCustomerError)
+  end
+
+  it 'test_invoicing_fails_with_nothing_to_invoice' do
+    user = create_customer('invoicing_fails_with_nothing_to_invoice')
+    user.create_as_stripe_customer
+    user.update_default_payment_method('pm_card_visa')
+
+    response = user.invoice
+
+    expect(response).to be false
+  end
+
+  it 'test_customer_can_be_invoiced' do
+    user = create_customer('customer_can_be_invoiced')
+    user.create_as_stripe_customer
+    user.update_default_payment_method('pm_card_visa')
+
+    response = user.invoice_for('Rails Reji', 1000)
+
+    expect(response).to be_an_instance_of(Reji::Invoice)
+    expect(response.raw_total).to eq(1000)
+  end
+
+  it 'test_find_invoice_by_id' do
+    user = create_customer('find_invoice_by_id')
+    user.create_as_stripe_customer
+    user.update_default_payment_method('pm_card_visa')
+
+    invoice = user.invoice_for('Rails Reji', 1000)
+
+    invoice = user.find_invoice(invoice.id)
+
+    expect(invoice).to be_an_instance_of(Reji::Invoice)
+    expect(invoice.raw_total).to eq(1000)
+  end
+
+  it 'throws_an_exception_if_the_invoice_does_not_belong_to_the_user' do
+    user = create_customer('it_throws_an_exception_if_the_invoice_does_not_belong_to_the_user')
+    user.create_as_stripe_customer
+    other_user = create_customer('other_user')
+    other_user.create_as_stripe_customer
+    user.update_default_payment_method('pm_card_visa')
+    invoice = user.invoice_for('Rails Reji', 1000)
+
+    expect {
+      other_user.find_invoice(invoice.id)
+    }.to raise_error(Reji::InvalidInvoiceError, "The invoice `#{invoice.id}` does not belong to this customer `#{other_user.stripe_id}`.")
+  end
+
+  it 'test_find_invoice_by_id_or_fail' do
+    user = create_customer('find_invoice_by_id_or_fail')
+    user.create_as_stripe_customer
+    other_user = create_customer('other_user')
+    other_user.create_as_stripe_customer
+    user.update_default_payment_method('pm_card_visa')
+    invoice = user.invoice_for('Rails Reji', 1000)
+
+    expect {
+      other_user.find_invoice_or_fail(invoice.id)
+    }.to raise_error(Reji::AccessDeniedHttpError)
+  end
+end

data/spec/feature/multiplan_subscriptions_spec.rb

@@ -0,0 +1,319 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe 'multiplan subscriptions', type: :request do
+  before(:all) do
+    @product_id = "#{stripe_prefix}product-1-#{SecureRandom.hex(5)}"
+    @plan_id = "#{stripe_prefix}monthly-10-#{SecureRandom.hex(5)}"
+    @other_plan_id = "#{stripe_prefix}monthly-10-#{SecureRandom.hex(5)}"
+    @premium_plan_id = "#{stripe_prefix}monthly-20-premium-#{SecureRandom.hex(5)}"
+
+    Stripe::Product.create({
+      :id => @product_id,
+      :name => 'Rails Reji Test Product',
+      :type => 'service',
+    })
+
+    Stripe::Plan.create({
+      :id => @plan_id,
+      :nickname => 'Monthly $10',
+      :currency => 'USD',
+      :interval => 'month',
+      :billing_scheme => 'per_unit',
+      :amount => 1000,
+      :product => @product_id,
+    })
+
+    Stripe::Plan.create({
+      :id => @other_plan_id,
+      :nickname => 'Monthly $10 Other',
+      :currency => 'USD',
+      :interval => 'month',
+      :billing_scheme => 'per_unit',
+      :amount => 1000,
+      :product => @product_id,
+    })
+
+    Stripe::Plan.create({
+      :id => @premium_plan_id,
+      :nickname => 'Monthly $20 Premium',
+      :currency => 'USD',
+      :interval => 'month',
+      :billing_scheme => 'per_unit',
+      :amount => 2000,
+      :product => @product_id,
+    })
+
+    @tax_rate_id = Stripe::TaxRate.create({
+      :display_name => 'VAT',
+      :description => 'VAT Belgium',
+      :jurisdiction => 'BE',
+      :percentage => 21,
+      :inclusive => false,
+    }).id
+  end
+
+  after(:all) do
+    delete_stripe_resource(Stripe::Plan.retrieve(@plan_id))
+    delete_stripe_resource(Stripe::Plan.retrieve(@other_plan_id))
+    delete_stripe_resource(Stripe::Plan.retrieve(@premium_plan_id))
+    delete_stripe_resource(Stripe::Product.retrieve(@product_id))
+  end
+
+  it 'test_customers_can_have_multiplan_subscriptions' do
+    user = create_customer('customers_can_have_multiplan_subscriptions')
+
+    user.plan_tax_rates = {@other_plan_id => [@tax_rate_id]}
+
+    subscription = user.new_subscription('main', [@plan_id, @other_plan_id])
+      .plan(@premium_plan_id, 5)
+      .quantity(10, @plan_id)
+      .create('pm_card_visa')
+
+    expect(user.subscribed('main', @plan_id)).to be true
+    expect(user.on_plan(@plan_id)).to be true
+
+    item = subscription.find_item_or_fail(@plan_id)
+    other_item = subscription.find_item_or_fail(@other_plan_id)
+    premium_item = subscription.find_item_or_fail(@premium_plan_id)
+
+    expect(subscription.items.count).to eq(3)
+    expect(item.stripe_plan).to eq(@plan_id)
+    expect(item.quantity).to eq(10)
+    expect(other_item.stripe_plan).to eq(@other_plan_id)
+    expect(other_item.quantity).to eq(1)
+    expect(premium_item.stripe_plan).to eq(@premium_plan_id)
+    expect(premium_item.quantity).to eq(5)
+  end
+
+  it 'test_customers_can_add_plans' do
+    user = create_customer('customers_can_add_plans')
+
+    subscription = user.new_subscription('main', @plan_id).create('pm_card_visa')
+
+    subscription.add_plan(@other_plan_id, 5)
+
+    expect(user.on_plan(@plan_id)).to be true
+    expect(user.on_plan(@premium_plan_id)).to be false
+
+    item = subscription.find_item_or_fail(@plan_id)
+    other_item = subscription.find_item_or_fail(@other_plan_id)
+
+    expect(subscription.items.count).to eq(2)
+    expect(item.stripe_plan).to eq(@plan_id)
+    expect(item.quantity).to eq(1)
+    expect(other_item.stripe_plan).to eq(@other_plan_id)
+    expect(other_item.quantity).to eq(5)
+  end
+
+  it 'test_customers_can_remove_plans' do
+    user = create_customer('customers_can_remove_plans')
+
+    subscription = user.new_subscription(
+      'main', [@plan_id, @other_plan_id]
+    ).create('pm_card_visa')
+
+    expect(subscription.items.count).to eq(2)
+
+    subscription.remove_plan(@plan_id)
+
+    expect(subscription.items.count).to eq(1)
+  end
+
+  it 'test_customers_cannot_remove_the_last_plan' do
+    user = create_customer('customers_cannot_remove_the_last_plan')
+
+    subscription = self.create_subscription_with_single_plan(user)
+
+    expect {
+      subscription.remove_plan(@plan_id)
+    }.to raise_error(Reji::SubscriptionUpdateFailureError)
+  end
+
+  it 'test_multiplan_subscriptions_can_be_resumed' do
+    user = create_customer('multiplan_subscriptions_can_be_resumed')
+
+    subscription = user.new_subscription(
+      'main', [@plan_id, @other_plan_id]
+    ).create('pm_card_visa')
+
+    subscription.cancel
+
+    expect(subscription.active).to be true
+    expect(subscription.on_grace_period).to be true
+
+    subscription.resume
+
+    expect(subscription.active).to be true
+    expect(subscription.on_grace_period).to be false
+  end
+
+  it 'test_plan_is_required_when_updating_quantities_for_multiplan_subscriptions' do
+    user = create_customer('plan_is_required_when_updating_quantities_for_multiplan_subscriptions')
+
+    subscription = self.create_subscription_with_multiple_plans(user)
+
+    expect {
+      subscription.update_quantity(5)
+    }.to raise_error(ArgumentError)
+  end
+
+  it 'test_subscription_item_quantities_can_be_updated' do
+    user = create_customer('subscription_item_quantities_can_be_updated')
+
+    subscription = user.new_subscription(
+      'main', [@plan_id, @other_plan_id]
+    ).create('pm_card_visa')
+
+    subscription.update_quantity(5, @other_plan_id)
+
+    item = subscription.find_item_or_fail(@other_plan_id)
+
+    expect(item.quantity).to eq(5)
+  end
+
+  it 'test_subscription_item_quantities_can_be_incremented' do
+    user = create_customer('subscription_item_quantities_can_be_incremented')
+
+    subscription = user.new_subscription(
+      'main', [@plan_id, @other_plan_id]
+    ).create('pm_card_visa')
+
+    subscription.increment_quantity(3, @other_plan_id)
+
+    item = subscription.find_item_or_fail(@other_plan_id)
+
+    expect(item.quantity).to eq(4)
+
+    item.increment_quantity(3)
+
+    expect(item.quantity).to eq(7)
+  end
+
+  it 'test_subscription_item_quantities_can_be_decremented' do
+    user = create_customer('subscription_item_quantities_can_be_decremented')
+
+    subscription = user.new_subscription(
+      'main', [@plan_id, @other_plan_id]
+    ).quantity(5, @other_plan_id).create('pm_card_visa')
+
+    subscription.decrement_quantity(2, @other_plan_id)
+
+    item = subscription.find_item_or_fail(@other_plan_id)
+
+    expect(item.quantity).to eq(3)
+
+    item.decrement_quantity(2)
+
+    expect(item.quantity).to eq(1)
+  end
+
+  it 'test_multiple_plans_can_be_swapped' do
+    user = create_customer('multiple_plans_can_be_swapped')
+
+    subscription = user.new_subscription('main', @plan_id).create('pm_card_visa')
+
+    subscription.swap([@other_plan_id, @premium_plan_id])
+
+    plans = subscription.items.pluck(:stripe_plan)
+
+    expect(plans.count).to eq(2)
+    expect(plans).to contain_exactly(@other_plan_id, @premium_plan_id)
+  end
+
+  it 'test_subscription_items_can_swap_plans' do
+    user = create_customer('subscription_items_can_swap_plans')
+
+    subscription = user.new_subscription('main', @plan_id).create('pm_card_visa')
+
+    item = subscription.items.first.swap(@other_plan_id, {:quantity => 3})
+
+    expect(subscription.items.count).to eq(1)
+    expect(subscription.stripe_plan).to eq(@other_plan_id)
+    expect(item.stripe_plan).to eq(@other_plan_id)
+    expect(item.quantity).to eq(3)
+  end
+
+  it 'test_subscription_item_changes_can_be_prorated' do
+    user = create_customer('subscription_item_changes_can_be_prorated')
+
+    subscription = user.new_subscription('main', @premium_plan_id).create('pm_card_visa')
+
+    invoice = user.invoices.first
+
+    expect(invoice.raw_total).to eq(2000)
+
+    subscription.no_prorate.add_plan(@other_plan_id)
+
+    # Assert that no new invoice was created because of no prorating.
+    expect(user.invoices.first.id).to eq(invoice.id)
+
+    subscription.add_plan_and_invoice(@plan_id)
+
+    # Assert that a new invoice was created because of no prorating.
+    invoice = user.invoices.first
+    expect(invoice.raw_total).to eq(1000)
+    expect(user.upcoming_invoice.raw_total).to eq(4000)
+
+    subscription.no_prorate.remove_plan(@premium_plan_id)
+
+    # Assert that no new invoice was created because of no prorating.
+    expect(user.invoices.first.id).to eq(invoice.id)
+    expect(user.upcoming_invoice.raw_total).to eq(2000)
+  end
+
+  it 'test_subscription_item_quantity_changes_can_be_prorated' do
+    user = create_customer('subscription_item_quantity_changes_can_be_prorated')
+
+    subscription = user.new_subscription('main', [@plan_id, @other_plan_id])
+      .quantity(3, @other_plan_id)
+      .create('pm_card_visa')
+
+    invoice = user.invoices.first
+
+    expect(invoice.raw_total).to eq(4000)
+
+    subscription.no_prorate.update_quantity(1, @other_plan_id)
+
+    expect(user.upcoming_invoice.raw_total).to eq(2000)
+  end
+
+  protected
+
+  # Create a subscription with a single plan.
+  def create_subscription_with_single_plan(user)
+    subscription = user.subscriptions.create({
+      :name => 'main',
+      :stripe_id => 'sub_foo',
+      :stripe_plan => @plan_id,
+      :quantity => 1,
+      :stripe_status => 'active',
+    })
+
+    subscription.items.create({
+      :stripe_id => 'it_foo',
+      :stripe_plan => @plan_id,
+      :quantity => 1,
+    })
+
+    subscription
+  end
+
+  # Create a subscription with multiple plans.
+  def create_subscription_with_multiple_plans(user)
+    subscription = self.create_subscription_with_single_plan(user)
+
+    subscription.stripe_plan = nil
+    subscription.quantity = nil
+    subscription.save
+
+    subscription.items.new({
+      :stripe_id => 'it_foo',
+      :stripe_plan => @other_plan_id,
+      :quantity => 1,
+    })
+
+    subscription
+  end
+end