solidus_subscriptions 1.0.0.rc1

data/spec/jobs/solidus_subscriptions/process_installment_job_spec.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+RSpec.describe SolidusSubscriptions::ProcessInstallmentJob do
+  it 'processes checkout for the installment' do
+    installment = build_stubbed(:installment)
+    checkout = instance_spy(SolidusSubscriptions::Checkout)
+    allow(SolidusSubscriptions::Checkout).to receive(:new).with(installment).and_return(checkout)
+
+    described_class.perform_now(installment)
+
+    expect(checkout).to have_received(:process)
+  end
+
+  context 'when handling #perform errors' do
+    it 'swallows error when a proc is not configured' do
+      checkout = instance_double(SolidusSubscriptions::Checkout).tap do |c|
+        allow(c).to receive(:process).and_raise('test error')
+      end
+      allow(SolidusSubscriptions::Checkout).to receive(:new).and_return(checkout)
+
+      expect {
+        described_class.perform_now(build_stubbed(:installment))
+      }.not_to raise_error
+    end
+
+    it 'runs proc when a proc is configured' do
+      stub_config(processing_error_handler: proc { |e| raise e } )
+      checkout = instance_double(SolidusSubscriptions::Checkout).tap do |c|
+        allow(c).to receive(:process).and_raise('test error')
+      end
+      allow(SolidusSubscriptions::Checkout).to receive(:new).and_return(checkout)
+
+      expect {
+        described_class.perform_now(build_stubbed(:installment))
+      }.to raise_error(/test error/)
+    end
+  end
+end

data/spec/jobs/solidus_subscriptions/process_subscription_job_spec.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+RSpec.describe SolidusSubscriptions::ProcessSubscriptionJob do
+  context 'when clear_past_installments is enabled' do
+    it 'voids the actionable date of the unfulfilled installments' do
+      stub_config(clear_past_installments: true)
+      subscription = create(:subscription)
+      unfulfilled_installment =  create(:installment, :failed, subscription: subscription)
+
+      described_class.perform_now(subscription)
+
+      expect(unfulfilled_installment.reload.actionable_date).to eq(nil)
+    end
+  end
+
+  context 'when the subscription is actionable' do
+    it 'resets the successive_skip_count' do
+      subscription = create(:subscription, :actionable, successive_skip_count: 3)
+
+      described_class.perform_now(subscription)
+
+      expect(subscription.reload.successive_skip_count).to eq(0)
+    end
+
+    it 'creates a new installment' do
+      subscription = create(:subscription, :actionable)
+
+      described_class.perform_now(subscription)
+
+      expect(subscription.installments.count).to eq(1)
+    end
+
+    it 'advances the actionable date' do
+      subscription = create(:subscription, :actionable)
+      subscription.update_columns(interval_length: 1, interval_units: 'week')
+      old_actionable_date = subscription.reload.actionable_date
+
+      described_class.perform_now(subscription)
+
+      expect(subscription.reload.actionable_date.to_date).to eq((old_actionable_date + 1.week).to_date)
+    end
+  end
+
+  context 'when the subscription is pending cancellation' do
+    it 'cancels the subscription' do
+      subscription = create(
+        :subscription,
+        :actionable,
+        :pending_cancellation,
+      )
+      described_class.perform_now(subscription)
+
+      expect(subscription.reload.state).to eq('canceled')
+    end
+  end
+
+  context 'when the subscription is pending of deactivation' do
+    it 'deactivates the subscription' do
+      subscription = create(
+        :subscription,
+        :actionable,
+        interval_units: 'week',
+        interval_length: 2,
+        end_date: 3.days.from_now,
+      )
+      described_class.perform_now(subscription)
+
+      expect(subscription.reload.state).to eq('inactive')
+    end
+  end
+
+  it 'schedules all the subscription actionable installments for processing' do
+    subscription = create(:subscription, :actionable)
+    unfulfilled_installment = create(:installment, :failed, subscription: subscription)
+
+    described_class.perform_now(subscription)
+
+    new_installment = subscription.reload.installments.last
+    [unfulfilled_installment, new_installment].each do |installment|
+      expect(SolidusSubscriptions::ProcessInstallmentJob).to have_been_enqueued.with(installment)
+    end
+  end
+end

data/spec/lib/solidus_subscriptions/checkout_spec.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+RSpec.describe SolidusSubscriptions::Checkout, :checkout do
+  context 'when the order can be created and paid' do
+    # rubocop:disable RSpec/MultipleExpectations
+    it 'creates and finalizes a new order for the installment' do
+      stub_spree_preferences(auto_capture: true)
+      installment = create(:installment, :actionable)
+
+      order = described_class.new(installment).process
+
+      expect(order).to be_complete
+      expect(order).to be_paid
+    end
+
+    it 'copies basic information from the subscription' do
+      stub_spree_preferences(auto_capture: true)
+      installment = create(:installment, :actionable)
+      subscription = installment.subscription
+
+      order = described_class.new(installment).process
+
+      expect(order.ship_address.value_attributes).to eq(subscription.shipping_address_to_use.value_attributes)
+      expect(order.bill_address.value_attributes).to eq(subscription.billing_address_to_use.value_attributes)
+      expect(order.payments.first.payment_method).to eq(subscription.payment_method_to_use)
+      expect(order.payments.first.source).to eq(subscription.payment_source_to_use)
+      expect(order.currency).to eq(subscription.currency)
+      expect(order.user).to eq(subscription.user)
+      expect(order.email).to eq(subscription.user.email)
+    end
+
+    it 'marks the order as a subscription order' do
+      stub_spree_preferences(auto_capture: true)
+      installment = create(:installment, :actionable)
+      subscription = installment.subscription
+
+      order = described_class.new(installment).process
+
+      expect(order.subscription).to eq(subscription)
+      expect(order.subscription_order).to eq(true)
+    end
+    # rubocop:enable RSpec/MultipleExpectations
+
+    it 'matches the total on the subscription' do
+      stub_spree_preferences(auto_capture: true)
+      installment = create(:installment, :actionable)
+      subscription = installment.subscription
+
+      order = described_class.new(installment).process
+
+      expect(order.item_total).to eq(subscription.line_items.first.subscribable.price)
+    end
+
+    it 'calls the success dispatcher' do
+      stub_spree_preferences(auto_capture: true)
+      installment = create(:installment, :actionable)
+      success_dispatcher = stub_dispatcher(SolidusSubscriptions::Dispatcher::SuccessDispatcher, installment)
+
+      described_class.new(installment).process
+
+      expect(success_dispatcher).to have_received(:dispatch)
+    end
+  end
+
+  context 'when payment of the order fails' do
+    it 'calls the payment failed dispatcher' do
+      stub_spree_preferences(auto_capture: true)
+      installment = create(:installment, :actionable).tap do |i|
+        i.subscription.update!(payment_source: create(:credit_card, number: '4111123412341234', user: i.subscription.user))
+      end
+      payment_failed_dispatcher = stub_dispatcher(SolidusSubscriptions::Dispatcher::PaymentFailedDispatcher, installment)
+
+      described_class.new(installment).process
+
+      expect(payment_failed_dispatcher).to have_received(:dispatch)
+    end
+  end
+
+  context 'when an item is out of stock' do
+    it 'calls the out of stock dispatcher' do
+      stub_spree_preferences(auto_capture: true)
+      installment = create(:installment, :actionable).tap do |i|
+        i.subscription.line_items.first.subscribable.stock_items.each do |stock_item|
+          stock_item.update!(backorderable: false)
+        end
+      end
+      out_of_stock_dispatcher = stub_dispatcher(SolidusSubscriptions::Dispatcher::OutOfStockDispatcher, installment)
+
+      described_class.new(installment).process
+
+      expect(out_of_stock_dispatcher).to have_received(:dispatch)
+    end
+  end
+
+  context 'when a generic transition error happens during checkout' do
+    it 'calls the failure dispatcher' do
+      stub_spree_preferences(auto_capture: true)
+      installment = create(:installment, :actionable)
+      failure_dispatcher = stub_dispatcher(SolidusSubscriptions::Dispatcher::FailureDispatcher, installment)
+      # rubocop:disable RSpec/AnyInstance
+      allow_any_instance_of(Spree::Order).to receive(:next!)
+        .and_raise(StateMachines::InvalidTransition.new(
+          Spree::Order.new,
+          Spree::Order.state_machines[:state],
+          :next,
+        ))
+      # rubocop:enable RSpec/AnyInstance
+
+      described_class.new(installment).process
+
+      expect(failure_dispatcher).to have_received(:dispatch)
+    end
+  end
+
+  private
+
+  def stub_dispatcher(klass, installment)
+    instance_spy(klass).tap do |dispatcher|
+      allow(klass).to receive(:new).with(
+        installment,
+        an_instance_of(Spree::Order)
+      ).and_return(dispatcher)
+    end
+  end
+end

data/spec/lib/solidus_subscriptions/churn_buster/client_spec.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+RSpec.describe SolidusSubscriptions::ChurnBuster::Client, vcr: { cassette_name: 'churn_buster', record: :new_episodes } do
+  describe '#report_failed_payment' do
+    it 'reports the failed payment to Churn Buster' do
+      client = described_class.new(
+        account_id: 'test_account_id',
+        api_key: 'test_api_key',
+      )
+
+      order = create(:order, subscription: create(:subscription))
+      response = client.report_failed_payment(order)
+
+      expect(response).to be_success
+    end
+  end
+
+  describe '#report_successful_payment' do
+    it 'reports the successful payment to Churn Buster' do
+      client = described_class.new(
+        account_id: 'test_account_id',
+        api_key: 'test_api_key',
+      )
+
+      order = create(:order, subscription: create(:subscription))
+      response = client.report_successful_payment(order)
+
+      expect(response).to be_success
+    end
+  end
+
+  describe '#report_subscription_cancellation' do
+    it 'reports the failed payment to Churn Buster' do
+      client = described_class.new(
+        account_id: 'test_account_id',
+        api_key: 'test_api_key',
+      )
+
+      subscription = create(:subscription)
+      response = client.report_subscription_cancellation(subscription)
+
+      expect(response).to be_success
+    end
+  end
+
+  describe '#report_payment_method_change' do
+    it 'reports the payment method change to Churn Buster' do
+      client = described_class.new(
+        account_id: 'test_account_id',
+        api_key: 'test_api_key',
+      )
+
+      subscription = create(:subscription)
+      response = client.report_payment_method_change(subscription)
+
+      expect(response).to be_success
+    end
+  end
+end

data/spec/lib/solidus_subscriptions/dispatcher/failure_dispatcher_spec.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+RSpec.describe SolidusSubscriptions::Dispatcher::FailureDispatcher do
+  describe '#dispatch' do
+    it 'marks the installment as failed' do
+      installment = instance_spy(SolidusSubscriptions::Installment)
+      order = create(:order_with_line_items)
+
+      dispatcher = described_class.new(installment, order)
+      dispatcher.dispatch
+
+      expect(installment).to have_received(:failed!).with(order)
+    end
+
+    it 'cancels the order' do
+      if Spree.solidus_gem_version > Gem::Version.new('2.10')
+        skip 'Orders in `cart` state cannot be canceled starting from Solidus 2.11.'
+      end
+
+      installment = instance_spy(SolidusSubscriptions::Installment)
+      order = create(:order_with_line_items)
+
+      dispatcher = described_class.new(installment, order)
+      dispatcher.dispatch
+
+      expect(order.state).to eq('canceled')
+    end
+  end
+end

data/spec/lib/solidus_subscriptions/dispatcher/out_of_stock_dispatcher_spec.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+RSpec.describe SolidusSubscriptions::Dispatcher::OutOfStockDispatcher do
+  describe '#dispatch' do
+    it 'marks the installment as out of stock' do
+      installment = instance_spy(SolidusSubscriptions::Installment)
+      order = build_stubbed(:order)
+
+      dispatcher = described_class.new(installment, order)
+      dispatcher.dispatch
+
+      expect(installment).to have_received(:out_of_stock)
+    end
+  end
+end

data/spec/lib/solidus_subscriptions/dispatcher/payment_failed_dispatcher_spec.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+RSpec.describe SolidusSubscriptions::Dispatcher::PaymentFailedDispatcher do
+  describe '#dispatch' do
+    it 'marks the installment as payment_failed' do
+      installment = instance_spy(SolidusSubscriptions::Installment)
+      order = create(:order_with_line_items)
+
+      dispatcher = described_class.new(installment, order)
+      dispatcher.dispatch
+
+      expect(installment).to have_received(:payment_failed!).with(order)
+    end
+
+    it 'cancels the order' do
+      if Spree.solidus_gem_version > Gem::Version.new('2.10')
+        skip 'Orders in `cart` state cannot be canceled starting from Solidus 2.11.'
+      end
+
+      installment = instance_spy(SolidusSubscriptions::Installment)
+      order = create(:order_with_line_items)
+
+      dispatcher = described_class.new(installment, order)
+      dispatcher.dispatch
+
+      expect(order.state).to eq('canceled')
+    end
+
+    it 'fires an installments_failed_payment event' do
+      stub_const('Spree::Event', class_spy(Spree::Event))
+      installment = instance_spy(SolidusSubscriptions::Installment)
+      order = create(:order_with_line_items)
+
+      dispatcher = described_class.new(installment, order)
+      dispatcher.dispatch
+
+      expect(Spree::Event).to have_received(:fire).with(
+        'solidus_subscriptions.installment_failed_payment',
+        installment: installment,
+        order: order,
+      )
+    end
+  end
+end

data/spec/lib/solidus_subscriptions/dispatcher/success_dispatcher_spec.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+RSpec.describe SolidusSubscriptions::Dispatcher::SuccessDispatcher do
+  describe '#dispatch' do
+    it 'marks the installment as success' do
+      installment = instance_spy(SolidusSubscriptions::Installment)
+      order = create(:order_with_line_items)
+
+      dispatcher = described_class.new(installment, order)
+      dispatcher.dispatch
+
+      expect(installment).to have_received(:success!).with(order)
+    end
+
+    it 'fires an installments_succeeded event' do
+      stub_const('Spree::Event', class_spy(Spree::Event))
+      installment = instance_spy(SolidusSubscriptions::Installment)
+      order = create(:order_with_line_items)
+
+      dispatcher = described_class.new(installment, order)
+      dispatcher.dispatch
+
+      expect(Spree::Event).to have_received(:fire).with(
+        'solidus_subscriptions.installment_succeeded',
+        installment: installment,
+        order: order,
+      )
+    end
+  end
+end

data/spec/lib/solidus_subscriptions/permission_sets/default_customer_spec.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+RSpec.describe SolidusSubscriptions::PermissionSets::DefaultCustomer do
+  context 'when the user is authenticated' do
+    it 'is allowed to display and update their subscriptions' do
+      user = create(:user)
+      subscription = create(:subscription, user: user)
+
+      ability = Spree::Ability.new(user)
+      permission_set = described_class.new(ability)
+      permission_set.activate!
+
+      expect(ability).to be_able_to([:show, :display, :update], subscription)
+    end
+
+    it "is not allowed to display or update someone else's subscriptions" do
+      user = create(:user)
+      subscription = create(:subscription)
+
+      ability = Spree::Ability.new(user)
+      permission_set = described_class.new(ability)
+      permission_set.activate!
+
+      expect(ability).not_to be_able_to([:show, :display, :update], subscription)
+    end
+
+    it 'is allowed to display and update line items on their subscriptions' do
+      user = create(:user)
+      subscription = create(:subscription, user: user)
+      line_item = create(:subscription_line_item, subscription: subscription)
+
+      ability = Spree::Ability.new(user)
+      permission_set = described_class.new(ability)
+      permission_set.activate!
+
+      expect(ability).to be_able_to([:show, :display, :update], line_item)
+    end
+
+    it "is not allowed to display or update line items on someone else's subscriptions" do
+      user = create(:user)
+      subscription = create(:subscription)
+      line_item = create(:subscription_line_item, subscription: subscription)
+
+      ability = Spree::Ability.new(user)
+      permission_set = described_class.new(ability)
+      permission_set.activate!
+
+      expect(ability).not_to be_able_to([:show, :display, :update], line_item)
+    end
+  end
+
+  context 'when the user provides a guest token' do
+    it 'is allowed to display and update their subscriptions' do
+      subscription = create(:subscription)
+
+      ability = Spree::Ability.new(nil)
+      permission_set = described_class.new(ability)
+      permission_set.activate!
+
+      expect(ability).to be_able_to([:show, :display, :update], subscription, subscription.guest_token)
+    end
+
+    it "is not allowed to display or update someone else's subscriptions" do
+      subscription = create(:subscription)
+
+      ability = Spree::Ability.new(nil)
+      permission_set = described_class.new(ability)
+      permission_set.activate!
+
+      expect(ability).not_to be_able_to([:show, :display, :update], subscription, 'invalid')
+    end
+
+    it 'is allowed to display and update line items on their subscriptions' do
+      subscription = create(:subscription)
+      line_item = create(:subscription_line_item, subscription: subscription)
+
+      ability = Spree::Ability.new(nil)
+      permission_set = described_class.new(ability)
+      permission_set.activate!
+
+      expect(ability).to be_able_to([:show, :display, :update], line_item, subscription.guest_token)
+    end
+
+    it "is not allowed to display or update line items on someone else's subscriptions" do
+      subscription = create(:subscription)
+      line_item = create(:subscription_line_item, subscription: subscription)
+
+      ability = Spree::Ability.new(nil)
+      permission_set = described_class.new(ability)
+      permission_set.activate!
+
+      expect(ability).not_to be_able_to([:show, :display, :update], line_item, 'invalid')
+    end
+  end
+end