solidus_subscriptions 1.0.0.rc1

data/spec/models/spree/variant_spec.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Spree::Variant, type: :model do
+  let(:variant) { build_stubbed :variant }
+
+  describe "#pretty_name" do
+    subject(:pretty_name) { variant.pretty_name }
+
+    it 'includes the product and options', :aggregate_failures do
+      expect(pretty_name).to match variant.name
+      expect(pretty_name).to match variant.options_text
+    end
+  end
+end

data/spec/models/spree/wallet_payment_source_spec.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+RSpec.describe Spree::WalletPaymentSource do
+  describe 'setting it as the default' do
+    it 'reports a payment method changed event for subscriptions that use the default payment source' do
+      stub_const('Spree::Event', class_spy(Spree::Event))
+      user = create(:user)
+      subscription = create(:subscription, user: user)
+      payment_source = create(:credit_card, user: user)
+      wallet_payment_source = user.wallet.add(payment_source)
+
+      user.wallet.default_wallet_payment_source = wallet_payment_source
+
+      expect(Spree::Event).to have_received(:fire).with(
+        'solidus_subscriptions.subscription_payment_method_changed',
+        subscription: subscription,
+      )
+    end
+  end
+end

data/spec/requests/api/v1/line_items_spec.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+RSpec.describe '/api/v1/line_items' do
+  include SolidusSubscriptions::Engine.routes.url_helpers
+
+  describe 'PATCH /:id' do
+    context 'when the subscription belongs to the user' do
+      context 'with valid params' do
+        it 'responds with 200 OK' do
+          user = create(:user, &:generate_spree_api_key!)
+          subscription = create(:subscription, user: user)
+          line_item = create(:subscription_line_item, subscription: subscription)
+
+          patch(
+            api_v1_line_item_path(line_item),
+            params: { subscription_line_item: { quantity: 11 } },
+            headers: { 'Authorization' => "Bearer #{user.spree_api_key}" },
+          )
+
+          expect(response.status).to eq(200)
+        end
+
+        it 'updates the line item' do
+          user = create(:user, &:generate_spree_api_key!)
+          subscription = create(:subscription, user: user)
+          line_item = create(:subscription_line_item, subscription: subscription)
+
+          patch(
+            api_v1_line_item_path(line_item),
+            params: { subscription_line_item: { quantity: 11 } },
+            headers: { 'Authorization' => "Bearer #{user.spree_api_key}" },
+          )
+
+          expect(line_item.reload.quantity).to eq(11)
+        end
+      end
+
+      context 'with invalid params' do
+        it 'responds with 422 Unprocessable Entity' do
+          user = create(:user, &:generate_spree_api_key!)
+          subscription = create(:subscription, user: user)
+          line_item = create(:subscription_line_item, subscription: subscription)
+
+          patch(
+            api_v1_line_item_path(line_item),
+            params: { subscription_line_item: { quantity: -1 } },
+            headers: { 'Authorization' => "Bearer #{user.spree_api_key}" },
+          )
+
+          expect(response.status).to eq(422)
+        end
+      end
+    end
+
+    context 'when the subscription does not belong to the user' do
+      it 'responds with 401 Unauthorized' do
+        user = create(:user, &:generate_spree_api_key!)
+        subscription = create(:subscription)
+        line_item = create(:subscription_line_item, subscription: subscription)
+
+        patch(
+          api_v1_line_item_path(line_item),
+          params: { subscription_line_item: { quantity: 11 } },
+          headers: { 'Authorization' => "Bearer #{user.spree_api_key}" },
+        )
+
+        expect(response.status).to eq(401)
+      end
+    end
+  end
+
+  describe 'DELETE /:id' do
+    context 'when the subscription belongs to the user' do
+      it 'responds with 200 OK' do
+        user = create(:user, &:generate_spree_api_key!)
+        subscription = create(:subscription, user: user)
+        line_item = create(:subscription_line_item, subscription: subscription)
+
+        delete(
+          api_v1_line_item_path(line_item),
+          headers: { 'Authorization' => "Bearer #{user.spree_api_key}" },
+        )
+
+        expect(response.status).to eq(200)
+      end
+
+      it 'deletes the line item' do
+        user = create(:user, &:generate_spree_api_key!)
+        subscription = create(:subscription, user: user)
+        line_item = create(:subscription_line_item, subscription: subscription)
+
+        delete(
+          api_v1_line_item_path(line_item),
+          headers: { 'Authorization' => "Bearer #{user.spree_api_key}" },
+        )
+
+        expect { line_item.reload }.to raise_error(ActiveRecord::RecordNotFound)
+      end
+    end
+
+    context 'when the subscription does not belong to the user' do
+      it 'responds with 401 Unauthorized' do
+        user = create(:user, &:generate_spree_api_key!)
+        subscription = create(:subscription)
+        line_item = create(:subscription_line_item, subscription: subscription)
+
+        delete(
+          api_v1_line_item_path(line_item),
+          headers: { 'Authorization' => "Bearer #{user.spree_api_key}" },
+        )
+
+        expect(response.status).to eq(401)
+      end
+    end
+  end
+end

data/spec/requests/api/v1/subscriptions_spec.rb

@@ -0,0 +1,255 @@
+# frozen_string_literal: true
+
+RSpec.describe '/api/v1/subscriptions' do
+  include SolidusSubscriptions::Engine.routes.url_helpers
+
+  describe 'POST /' do
+    context 'with valid params' do
+      it 'creates the subscription and responds with 200 OK' do
+        user = create(:user, &:generate_spree_api_key!)
+
+        expect do
+          post(
+            api_v1_subscriptions_path,
+            params: { subscription: { interval_length: 11 } },
+            headers: { 'Authorization' => "Bearer #{user.spree_api_key}" },
+          )
+        end.to change(SolidusSubscriptions::Subscription, :count).from(0).to(1)
+
+        expect(response.status).to eq(200)
+      end
+    end
+
+    context 'with invalid params' do
+      it "doesn't create the subscription and responds with 422 Unprocessable Entity" do
+        user = create(:user, &:generate_spree_api_key!)
+
+        expect do
+          post(
+            api_v1_subscriptions_path,
+            params: { subscription: { interval_length: -1 } },
+            headers: { 'Authorization' => "Bearer #{user.spree_api_key}" },
+          )
+        end.not_to change(SolidusSubscriptions::Subscription, :count)
+
+        expect(response.status).to eq(422)
+      end
+    end
+
+    context 'when valid payment attributes are provided' do
+      # rubocop:disable RSpec/MultipleExpectations
+      it 'creates the subscription using the specified payment' do
+        user = create(:user, &:generate_spree_api_key!)
+        payment_source = create(:credit_card, user: user)
+        payment_params = { payment_method_id: payment_source.payment_method.id, payment_source_id: payment_source.id }
+
+        expect(user.wallet.default_wallet_payment_source).to be_nil
+        expect do
+          post(
+            api_v1_subscriptions_path,
+            params: { subscription: { interval_length: 7 }.merge(payment_params) },
+            headers: { 'Authorization' => "Bearer #{user.spree_api_key}" },
+          )
+        end.to change(SolidusSubscriptions::Subscription, :count).from(0).to(1)
+        expect(SolidusSubscriptions::Subscription.last).to have_attributes(payment_params)
+      end
+      # rubocop:enable RSpec/MultipleExpectations
+    end
+
+    # rubocop:disable RSpec/MultipleExpectations
+    context 'when an invalid payment method is provided' do
+      it "doesn't create the subscription and responds with 422 Unprocessable Entity" do
+        user = create(:user, &:generate_spree_api_key!)
+        payment_source = create(:credit_card)
+        payment_params = { payment_source_id: payment_source.id }
+
+        expect do
+          post(
+            api_v1_subscriptions_path,
+            params: { subscription: { interval_length: 7 }.merge(payment_params) },
+            headers: { 'Authorization' => "Bearer #{user.spree_api_key}" },
+          )
+        end.not_to change(SolidusSubscriptions::Subscription, :count)
+
+        error_message = I18n.t('solidus_subscriptions.subscription.invalid_payment_details')
+        response_body = JSON.parse(response.body)
+        expect(response_body).to eq('payment_source_type' => [error_message])
+        expect(response.status).to eq(422)
+      end
+    end
+
+    context 'when an invalid payment source is provided' do
+      it "doesn't create the subscription and responds with 422 Unprocessable Entity" do
+        user = create(:user, &:generate_spree_api_key!)
+        payment_source = create(:credit_card)
+        payment_params = { payment_method_id: payment_source.payment_method.id }
+
+        expect do
+          post(
+            api_v1_subscriptions_path,
+            params: { subscription: { interval_length: 7 }.merge(payment_params) },
+            headers: { 'Authorization' => "Bearer #{user.spree_api_key}" },
+          )
+        end.not_to change(SolidusSubscriptions::Subscription, :count)
+
+        error_message = I18n.t('solidus_subscriptions.subscription.invalid_payment_details')
+        response_body = JSON.parse(response.body)
+        expect(response_body).to eq('payment_source_type' => [error_message])
+        expect(response.status).to eq(422)
+      end
+    end
+    # rubocop:enable RSpec/MultipleExpectations
+  end
+
+  describe 'PATCH /:id' do
+    context 'when the subscription belongs to the user' do
+      context 'with valid params' do
+        it 'responds with 200 OK' do
+          user = create(:user, &:generate_spree_api_key!)
+          subscription = create(:subscription, user: user)
+
+          patch(
+            api_v1_subscription_path(subscription),
+            params: { subscription: { interval_length: 11 } },
+            headers: { 'Authorization' => "Bearer #{user.spree_api_key}" },
+          )
+
+          expect(response.status).to eq(200)
+        end
+
+        it 'updates the subscription' do
+          user = create(:user, &:generate_spree_api_key!)
+          subscription = create(:subscription, user: user)
+
+          patch(
+            api_v1_subscription_path(subscription),
+            params: { subscription: { interval_length: 11 } },
+            headers: { 'Authorization' => "Bearer #{user.spree_api_key}" },
+          )
+
+          expect(subscription.reload.interval_length).to eq(11)
+        end
+      end
+
+      context 'with invalid params' do
+        it 'responds with 422 Unprocessable Entity' do
+          user = create(:user, &:generate_spree_api_key!)
+          subscription = create(:subscription, user: user)
+
+          patch(
+            api_v1_subscription_path(subscription),
+            params: { subscription: { interval_length: -1 } },
+            headers: { 'Authorization' => "Bearer #{user.spree_api_key}" },
+          )
+
+          expect(response.status).to eq(422)
+        end
+      end
+    end
+
+    context 'when the subscription does not belong to the user' do
+      it 'responds with 401 Unauthorized' do
+        user = create(:user, &:generate_spree_api_key!)
+        subscription = create(:subscription)
+
+        patch(
+          api_v1_subscription_path(subscription),
+          params: { subscription: { interval_length: 11 } },
+          headers: { 'Authorization' => "Bearer #{user.spree_api_key}" },
+        )
+
+        expect(response.status).to eq(401)
+      end
+    end
+  end
+
+  describe 'POST /:id/skip' do
+    context 'when the subscription belongs to the user' do
+      it 'responds with 200 OK' do
+        user = create(:user, &:generate_spree_api_key!)
+        subscription = create(:subscription, user: user)
+
+        post(
+          skip_api_v1_subscription_path(subscription),
+          headers: { 'Authorization' => "Bearer #{user.spree_api_key}" },
+        )
+
+        expect(response.status).to eq(200)
+      end
+
+      it 'skips the subscription' do
+        user = create(:user, &:generate_spree_api_key!)
+        subscription = create(
+          :subscription,
+          user: user,
+          interval_length: 1,
+          interval_units: 'week',
+          actionable_date: Time.zone.today,
+        )
+
+        post(
+          skip_api_v1_subscription_path(subscription),
+          headers: { 'Authorization' => "Bearer #{user.spree_api_key}" },
+        )
+
+        expect(subscription.reload.actionable_date).to eq(Time.zone.today + 1.week)
+      end
+    end
+
+    context 'when the subscription does not belong to the user' do
+      it 'responds with 401 Unauthorized' do
+        user = create(:user, &:generate_spree_api_key!)
+        subscription = create(:subscription)
+
+        post(
+          skip_api_v1_subscription_path(subscription),
+          headers: { 'Authorization' => "Bearer #{user.spree_api_key}" },
+        )
+
+        expect(response.status).to eq(401)
+      end
+    end
+  end
+
+  describe 'POST /:id/cancel' do
+    context 'when the subscription belongs to the user' do
+      it 'responds with 200 OK' do
+        user = create(:user, &:generate_spree_api_key!)
+        subscription = create(:subscription, user: user)
+
+        post(
+          cancel_api_v1_subscription_path(subscription),
+          headers: { 'Authorization' => "Bearer #{user.spree_api_key}" },
+        )
+
+        expect(response.status).to eq(200)
+      end
+
+      it 'cancels the subscription' do
+        user = create(:user, &:generate_spree_api_key!)
+        subscription = create(:subscription, user: user)
+
+        post(
+          cancel_api_v1_subscription_path(subscription),
+          headers: { 'Authorization' => "Bearer #{user.spree_api_key}" },
+        )
+
+        expect(subscription.reload.state).to eq('canceled')
+      end
+    end
+
+    context 'when the subscription does not belong to the user' do
+      it 'responds with 401 Unauthorized' do
+        user = create(:user, &:generate_spree_api_key!)
+        subscription = create(:subscription)
+
+        post(
+          cancel_api_v1_subscription_path(subscription),
+          headers: { 'Authorization' => "Bearer #{user.spree_api_key}" },
+        )
+
+        expect(response.status).to eq(401)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+# Configure Rails Environment
+ENV['RAILS_ENV'] = 'test'
+
+# Run Coverage report
+require 'solidus_dev_support/rspec/coverage'
+
+# Create the dummy app if it's still missing.
+dummy_env = "#{__dir__}/dummy/config/environment.rb"
+system 'bin/rake extension:test_app' unless File.exist? dummy_env
+require dummy_env
+
+# Requires factories and other useful helpers defined in spree_core.
+require 'solidus_dev_support/rspec/feature_helper'
+
+# Requires supporting ruby files with custom matchers and macros, etc,
+# in spec/support/ and its subdirectories.
+Dir["#{__dir__}/support/**/*.rb"].sort.each { |f| require f }
+
+SolidusDevSupport::TestingSupport::Factories.load_for(SolidusSubscriptions::Engine)
+
+RSpec.configure do |config|
+  config.infer_spec_type_from_file_location!
+  config.use_transactional_fixtures = false
+
+  if Spree.solidus_gem_version < Gem::Version.new('2.11')
+    config.extend Spree::TestingSupport::AuthorizationHelpers::Request, type: :system
+  end
+end

data/spec/subscribers/solidus_subscriptions/churn_buster_subscriber_spec.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+RSpec.describe SolidusSubscriptions::ChurnBusterSubscriber do
+  describe '#report_subscription_cancellation' do
+    it 'reports the cancellation to Churn Buster' do
+      churn_buster = instance_spy(SolidusSubscriptions::ChurnBuster::Client)
+      allow(SolidusSubscriptions).to receive(:churn_buster).and_return(churn_buster)
+
+      subscription = create(:subscription)
+      Spree::Event.fire('solidus_subscriptions.subscription_canceled', subscription: subscription)
+
+      expect(churn_buster).to have_received(:report_subscription_cancellation).with(subscription)
+    end
+  end
+
+  describe '#report_subscription_ending' do
+    it 'reports the cancellation to Churn Buster' do
+      churn_buster = instance_spy(SolidusSubscriptions::ChurnBuster::Client)
+      allow(SolidusSubscriptions).to receive(:churn_buster).and_return(churn_buster)
+
+      subscription = create(:subscription)
+      Spree::Event.fire('solidus_subscriptions.subscription_ended', subscription: subscription)
+
+      expect(churn_buster).to have_received(:report_subscription_cancellation).with(subscription)
+    end
+  end
+
+  describe '#report_payment_success' do
+    it 'reports the success to Churn Buster' do
+      churn_buster = instance_spy(SolidusSubscriptions::ChurnBuster::Client)
+      allow(SolidusSubscriptions).to receive(:churn_buster).and_return(churn_buster)
+
+      order = build_stubbed(:order)
+      installment = build_stubbed(:installment)
+      Spree::Event.fire(
+        'solidus_subscriptions.installment_succeeded',
+        installment: installment,
+        order: order,
+      )
+
+      expect(churn_buster).to have_received(:report_successful_payment).with(order)
+    end
+  end
+
+  describe '#report_payment_failure' do
+    it 'reports the failure to Churn Buster' do
+      churn_buster = instance_spy(SolidusSubscriptions::ChurnBuster::Client)
+      allow(SolidusSubscriptions).to receive(:churn_buster).and_return(churn_buster)
+
+      order = build_stubbed(:order)
+      installment = build_stubbed(:installment)
+      Spree::Event.fire(
+        'solidus_subscriptions.installment_failed_payment',
+        installment: installment,
+        order: order,
+      )
+
+      expect(churn_buster).to have_received(:report_failed_payment).with(order)
+    end
+  end
+
+  describe '#report_payment_method_change' do
+    it 'reports the payment method change to Churn Buster' do
+      churn_buster = instance_spy(SolidusSubscriptions::ChurnBuster::Client)
+      allow(SolidusSubscriptions).to receive(:churn_buster).and_return(churn_buster)
+
+      subscription = create(:subscription)
+      Spree::Event.fire(
+        'solidus_subscriptions.subscription_payment_method_changed',
+        subscription: subscription,
+      )
+
+      expect(churn_buster).to have_received(:report_payment_method_change).with(subscription)
+    end
+  end
+end