solidus_subscriptions 1.0.0.rc1

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+RSpec.describe SolidusSubscriptions::PermissionSets::SubscriptionManagement do
+  it 'is allowed to manage all subscriptions' do
+    user = create(:user)
+    subscription = create(:subscription)
+
+    ability = Spree::Ability.new(user)
+    permission_set = described_class.new(ability)
+    permission_set.activate!
+
+    expect(ability).to be_able_to(:manage, subscription)
+  end
+
+  it "is allowed to manage all line items" 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).to be_able_to(:manage, line_item)
+  end
+end

data/spec/lib/solidus_subscriptions/processor_spec.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+RSpec.describe SolidusSubscriptions::Processor do
+  it 'schedules the processing of actionable subscriptions' do
+    actionable_subscription = create(:subscription, :actionable)
+
+    described_class.run
+
+    expect(SolidusSubscriptions::ProcessSubscriptionJob).to have_been_enqueued
+      .with(actionable_subscription)
+  end
+
+  it 'schedules the processing of non actionable subscriptions with actionable installments' do
+    subscription_with_actionable_installment = create(
+      :subscription,
+      actionable_date: Time.zone.today + 7.days,
+      installments: [create(:installment, :actionable)]
+    )
+
+    described_class.run
+
+    expect(SolidusSubscriptions::ProcessSubscriptionJob).to have_been_enqueued
+      .with(subscription_with_actionable_installment)
+  end
+
+  it 'does not schedule the processing of non actionable subscriptions' do
+    non_actionable_subscription = create(:subscription, actionable_date: Time.zone.today + 14.days)
+
+    described_class.run
+
+    expect(SolidusSubscriptions::ProcessSubscriptionJob).not_to have_been_enqueued
+      .with(non_actionable_subscription)
+  end
+end

data/spec/lib/solidus_subscriptions/promotion/rules/subscription_creation_order_spec.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SolidusSubscriptions::Promotion::Rules::SubscriptionCreationOrder do
+  let(:rule) { described_class.new }
+
+  describe '#applicable' do
+    subject { rule.applicable? promotable }
+
+    context 'when the promotable is a Spree::Order' do
+      let(:promotable) { build_stubbed :order }
+
+      it { is_expected.to be_truthy }
+    end
+
+    context 'when the promotable is not a Spree::Order' do
+      let(:promotable) { build_stubbed :line_item }
+
+      it { is_expected.to be_falsy }
+    end
+  end
+
+  describe '#eligible?' do
+    subject { rule.eligible? order }
+
+    let(:order) { create(:order, line_items: line_items) }
+
+    context 'when the order contains a line item with a subscription' do
+      let(:line_items) { build_list(:line_item, 1, :with_subscription_line_items) }
+
+      it { is_expected.to be_truthy }
+    end
+
+    context 'when the order does not contain a line item with a subscription' do
+      let(:line_items) { build_list(:line_item, 1) }
+
+      it { is_expected.to be_falsy }
+    end
+  end
+
+  describe '#actionable?' do
+    subject { rule.actionable? line_item }
+
+    context 'when the line item has a subscription' do
+      let(:line_item) { build_stubbed(:line_item, :with_subscription_line_items) }
+
+      it { is_expected.to be_truthy }
+    end
+
+    context 'when the line item has no subscription' do
+      let(:line_item) { build_stubbed :line_item }
+
+      it { is_expected.to be_falsy }
+    end
+  end
+end

data/spec/lib/solidus_subscriptions/promotion/rules/subscription_installment_order_spec.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SolidusSubscriptions::Promotion::Rules::SubscriptionInstallmentOrder do
+  let(:rule) { described_class.new }
+
+  describe '#applicable' do
+    subject { rule.applicable? promotable }
+
+    context 'when the promotable is a Spree::Order' do
+      let(:promotable) { build_stubbed :order }
+
+      it { is_expected.to be_truthy }
+    end
+
+    context 'when the promotable is not a Spree::Order' do
+      let(:promotable) { build_stubbed :line_item }
+
+      it { is_expected.to be_falsy }
+    end
+  end
+
+  describe '#eligible?' do
+    subject { rule.eligible? order }
+
+    context 'when the order fulfills a subscription installment' do
+      let(:order) { create(:order, subscription_order: true) }
+
+      it { is_expected.to be_truthy }
+    end
+
+    context 'when the order contains does not fulfill a subscription installment' do
+      let(:order) { create(:order) }
+
+      it { is_expected.to be_falsy }
+    end
+  end
+end

data/spec/lib/solidus_subscriptions/subscription_generator_spec.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SolidusSubscriptions::SubscriptionGenerator do
+  describe '.activate' do
+    it 'creates the correct number of subscriptions' do
+      subscription_line_items = build_list(:subscription_line_item, 2)
+
+      expect {
+        described_class.activate(subscription_line_items)
+      }.to change(SolidusSubscriptions::Subscription, :count).by(1)
+    end
+
+    it 'creates subscriptions with the correct attributes', :aggregate_failures do
+      subscription_line_items = build_list(:subscription_line_item, 2)
+      subscription_line_item = subscription_line_items.first
+
+      subscription = described_class.activate(subscription_line_items)
+
+      expect(subscription.line_items).to match_array(subscription_line_items)
+      expect(subscription).to have_attributes(
+        user: subscription_line_item.order.user,
+        shipping_address: subscription_line_item.spree_line_item.order.ship_address,
+        billing_address: subscription_line_item.spree_line_item.order.bill_address,
+        interval_length: subscription_line_item.interval_length,
+        interval_units: subscription_line_item.interval_units,
+        end_date: subscription_line_item.end_date,
+        store: subscription_line_item.order.store,
+        currency: subscription_line_item.order.currency
+      )
+    end
+
+    it 'copies the payment method from the order' do
+      subscription_line_item = build(:subscription_line_item)
+      payment_method = create(:credit_card_payment_method)
+      payment_source = create(:credit_card, payment_method: payment_method, user: subscription_line_item.order.user)
+      create(:payment,
+        order: subscription_line_item.spree_line_item.order,
+        source: payment_source,
+        payment_method: payment_method,)
+
+      subscription = described_class.activate([subscription_line_item])
+
+      expect(subscription).to have_attributes(
+        payment_method: payment_method,
+        payment_source: payment_source,
+      )
+    end
+
+    it 'cleanups the subscription line items fields duplicated on the subscription' do
+      attrs = { interval_length: 2, interval_units: :week, end_date: Time.zone.tomorrow }
+      subscription_line_item = create(:subscription_line_item, attrs)
+
+      described_class.activate([subscription_line_item])
+
+      expect(subscription_line_item.reload).to have_attributes(
+        interval_length: nil,
+        interval_units: nil,
+        end_date: nil
+      )
+    end
+  end
+
+  describe '.group' do
+    it 'groups subscriptions by interval and end date' do
+      monthly_subscriptions = build_stubbed_list(:subscription_line_item, 2)
+      bimonthly_subscriptions = build_stubbed_list(:subscription_line_item, 2, interval_length: 2)
+      weekly_subscriptions = build_stubbed_list(:subscription_line_item, 2, interval_units: :week)
+      expiring_subscriptions = build_stubbed_list(:subscription_line_item, 2, end_date: Time.zone.tomorrow)
+
+      subscriptions = [
+        monthly_subscriptions,
+        bimonthly_subscriptions,
+        weekly_subscriptions,
+        expiring_subscriptions,
+      ]
+      grouping_result = described_class.group(subscriptions.sum)
+
+      expect(grouping_result).to match_array(subscriptions)
+    end
+  end
+end

data/spec/lib/solidus_subscriptions_spec.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+RSpec.describe SolidusSubscriptions do
+  describe '.churn_buster' do
+    context 'when Churn Buster was configured' do
+      it 'returns a Churn Buster client instance' do
+        allow(described_class.configuration).to receive_messages(
+          churn_buster?: true,
+          churn_buster_account_id: 'account_id',
+          churn_buster_api_key: 'api_key',
+        )
+        churn_buster = instance_double(SolidusSubscriptions::ChurnBuster::Client)
+        allow(SolidusSubscriptions::ChurnBuster::Client).to receive(:new).with(
+          account_id: 'account_id',
+          api_key: 'api_key',
+        ).and_return(churn_buster)
+
+        expect(described_class.churn_buster).to eq(churn_buster)
+      end
+    end
+
+    context 'when Churn Buster was not configured' do
+      it 'returns nil' do
+        allow(described_class.configuration).to receive_messages(churn_buster?: false)
+
+        expect(described_class.churn_buster).to be_nil
+      end
+    end
+  end
+end

data/spec/models/solidus_subscriptions/installment_detail_spec.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SolidusSubscriptions::InstallmentDetail, type: :model do
+  it { is_expected.to validate_presence_of :installment }
+
+  describe '#failed?' do
+    subject { build(:installment_detail, success: success).failed? }
+
+    context 'when the detail was successful' do
+      let(:success) { true }
+
+      it { is_expected.to be_falsy }
+    end
+
+    context 'when the detail was not successfuly' do
+      let(:success) { false }
+
+      it { is_expected.to be_truthy }
+    end
+  end
+end

data/spec/models/solidus_subscriptions/installment_spec.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SolidusSubscriptions::Installment, type: :model do
+  let(:installment) { create :installment }
+
+  it { is_expected.to validate_presence_of :subscription }
+
+  describe '#out_of_stock' do
+    subject(:out_of_stock) { installment.out_of_stock }
+
+    let(:expected_date) do
+      Time.zone.today + SolidusSubscriptions.configuration.reprocessing_interval
+    end
+
+    it { is_expected.to be_a SolidusSubscriptions::InstallmentDetail }
+    it { is_expected.not_to be_successful }
+
+    it 'has the correct message' do
+      expect(out_of_stock).to have_attributes(
+        message: I18n.t('solidus_subscriptions.installment_details.out_of_stock')
+      )
+    end
+
+    it 'advances the installment actionable_date' do
+      out_of_stock
+      actionable_date = installment.reload.actionable_date
+      expect(actionable_date).to eq expected_date
+    end
+  end
+
+  describe '#success!' do
+    subject(:success) { installment.success!(order) }
+
+    let(:order) { create :order }
+
+    let(:installment) { create :installment, actionable_date: actionable_date }
+    let(:actionable_date) { 1.month.from_now.to_date }
+
+    it 'removes any actionable date if any' do
+      expect { success }.
+        to change(installment, :actionable_date).
+        from(actionable_date).to(nil)
+    end
+
+    it 'creates a new installment detail' do
+      expect { success }.
+        to change { SolidusSubscriptions::InstallmentDetail.count }.
+        by(1)
+    end
+
+    it 'creates a successful installment detail' do
+      success
+      expect(installment.details.last).to be_successful && have_attributes(
+        order: order,
+        message: I18n.t('solidus_subscriptions.installment_details.success')
+      )
+    end
+  end
+
+  describe '#failed!' do
+    subject(:failed) { installment.failed!(order) }
+
+    let(:order) { create :order }
+
+    let(:expected_date) do
+      Time.zone.today + SolidusSubscriptions.configuration.reprocessing_interval
+    end
+
+    it { is_expected.to be_a SolidusSubscriptions::InstallmentDetail }
+    it { is_expected.not_to be_successful }
+
+    it 'has the correct message' do
+      expect(failed).to have_attributes(
+        message: I18n.t('solidus_subscriptions.installment_details.failed'),
+        order: order
+      )
+    end
+
+    it 'advances the installment actionable_date' do
+      failed
+      actionable_date = installment.reload.actionable_date
+      expect(actionable_date).to eq expected_date
+    end
+
+    context 'when the reprocessing interval is set to nil' do
+      before { stub_config(reprocessing_interval: nil) }
+
+      it 'does not advance the installment actionable_date' do
+        failed
+        actionable_date = installment.reload.actionable_date
+        expect(actionable_date).to be_nil
+      end
+    end
+  end
+
+  describe '#unfulfilled?' do
+    subject { installment.unfulfilled? }
+
+    let(:installment) { create(:installment, details: details) }
+
+    context 'when the installment has an associated successful detail' do
+      let(:details) { create_list :installment_detail, 1, success: true }
+
+      it { is_expected.to be_falsy }
+    end
+
+    context 'when the installment has no associated successful detail' do
+      let(:details) { create_list :installment_detail, 1 }
+
+      it { is_expected.to be_truthy }
+    end
+  end
+
+  describe '#fulfilled' do
+    subject { installment.fulfilled? }
+
+    let(:installment) { create(:installment, details: details) }
+
+    context 'when the installment has an associated completed order' do
+      let(:details) { create_list :installment_detail, 1, success: true }
+
+      it { is_expected.to be_truthy }
+    end
+
+    context 'when the installment has no associated completed order' do
+      let(:details) { create_list :installment_detail, 1 }
+
+      it { is_expected.to be_falsy }
+    end
+  end
+
+  describe '#payment_failed!' do
+    context 'when the maximum reprocessing time has been reached' do
+      it 'creates a new installment detail' do
+        subscription = create(:subscription)
+        allow(subscription).to receive(:maximum_reprocessing_time_reached?).and_return(true)
+
+        current_installment = create(:installment, subscription: subscription)
+        current_installment.payment_failed!(create(:order))
+
+        expect(current_installment.details.count).to eq(1)
+      end
+
+      it 'sets the actionable_date to nil' do
+        subscription = create(:subscription)
+        allow(subscription).to receive(:maximum_reprocessing_time_reached?).and_return(true)
+
+        current_installment = create(:installment, subscription: subscription)
+        current_installment.payment_failed!(create(:order))
+
+        expect(current_installment.actionable_date).to eq(nil)
+      end
+
+      it 'cancels the subscription' do
+        subscription = create(:subscription)
+        allow(subscription).to receive(:maximum_reprocessing_time_reached?).and_return(true)
+
+        current_installment = create(:installment, subscription: subscription)
+        current_installment.payment_failed!(create(:order))
+
+        expect(current_installment.subscription.state).to eq('canceled')
+      end
+    end
+
+    context 'when the maximum reprocessing time has not been reached' do
+      it 'creates a new installment detail' do
+        subscription = create(:subscription)
+        allow(subscription).to receive(:maximum_reprocessing_time_reached?).and_return(false)
+
+        current_installment = create(:installment, subscription: subscription)
+        current_installment.payment_failed!(create(:order))
+        current_installment.payment_failed!(create(:order))
+
+        expect(current_installment.details.count).to eq(2)
+      end
+
+      it "advances the installment's actionable_date" do
+        subscription = create(:subscription)
+        allow(subscription).to receive(:maximum_reprocessing_time_reached?).and_return(false)
+        stub_config(reprocessing_interval: 2.days)
+
+        current_installment = create(:installment, subscription: subscription)
+        current_installment.payment_failed!(create(:order))
+
+        expect(current_installment.actionable_date).to eq(Time.zone.today + 2.days)
+      end
+
+      it 'does not cancel the subscription' do
+        subscription = create(:subscription)
+        allow(subscription).to receive(:maximum_reprocessing_time_reached?).and_return(false)
+
+        current_installment = create(:installment, subscription: subscription)
+        current_installment.payment_failed!(create(:order))
+
+        expect(subscription.state).to eq('active')
+      end
+    end
+  end
+end