solidus_core 2.10.5 → 3.0.8

data/spec/models/spree/stock_quantities_spec.rb

@@ -1,249 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::StockQuantities, type: :model do
-  let(:variant1) { mock_model(Spree::Variant) }
-  let(:variant2) { mock_model(Spree::Variant) }
-
-  subject do
-    described_class.new(quantities)
-  end
-
-  describe "#each" do
-    def expect_each
-      expect { |item| subject.each(&item) }
-    end
-
-    context "with no items" do
-      let(:quantities) { {} }
-
-      it "doesn't yield" do
-        expect_each.not_to yield_control
-      end
-    end
-
-    context "with one item" do
-      let(:quantities) { { variant1 => 2 } }
-
-      it "yields values" do
-        expect_each.to yield_with_args([variant1, 2])
-      end
-    end
-
-    context "with two items" do
-      let(:quantities) { { variant1 => 2, variant2 => 3 } }
-
-      it "yields values" do
-        expect_each.to yield_successive_args([variant1, 2], [variant2, 3])
-      end
-    end
-  end
-
-  describe "#variants" do
-    context "with one item" do
-      let(:quantities) { { variant1 => 2 } }
-
-      it "returns variant" do
-        expect(subject.variants).to eq [variant1]
-      end
-    end
-
-    context "with two items" do
-      let(:quantities) { { variant1 => 2, variant2 => 3 } }
-
-      it "returns both variants" do
-        expect(subject.variants).to eq [variant1, variant2]
-      end
-    end
-  end
-
-  describe "#empty?" do
-    context "no variants" do
-      let(:quantities) { {} }
-      it { is_expected.to be_empty }
-    end
-
-    context "only quantity 0" do
-      let(:quantities) { { variant1 => 0 } }
-      it { is_expected.to be_empty }
-    end
-
-    context "positive quantity" do
-      let(:quantities) { { variant1 => 1 } }
-      it { is_expected.not_to be_empty }
-    end
-
-    context "one variant positive one zero" do
-      let(:quantities) { { variant1 => 1, variant2 => 0 } }
-      it { is_expected.not_to be_empty }
-    end
-
-    context "negative quantity" do
-      # empty? doesn't make a whole lot of sense in this case, but returning
-      # false is probably more accurate.
-      let(:quantities) { { variant1 => -1 } }
-      it { is_expected.not_to be_empty }
-    end
-  end
-
-  describe "==" do
-    subject do
-      described_class.new(quantity1) == described_class.new(quantity2)
-    end
-
-    context "when both empty" do
-      let(:quantity1) { {} }
-      let(:quantity2) { {} }
-      it { is_expected.to be true }
-    end
-
-    context "when both equal" do
-      let(:quantity1) { { variant1 => 1 } }
-      let(:quantity2) { { variant1 => 1 } }
-      it { is_expected.to be true }
-    end
-
-    context "with different order" do
-      let(:quantity1) { { variant1 => 1, variant2 => 2 } }
-      let(:quantity2) { { variant2 => 2, variant1 => 1 } }
-      it { is_expected.to be true }
-    end
-
-    context "with different variant" do
-      let(:quantity1) { { variant1 => 1 } }
-      let(:quantity2) { { variant2 => 1 } }
-      it { is_expected.to be false }
-    end
-
-    context "with different quantities" do
-      let(:quantity1) { { variant1 => 1 } }
-      let(:quantity2) { { variant1 => 2 } }
-      it { is_expected.to be false }
-    end
-
-    context "nil != 0" do
-      let(:quantity1) { { variant1 => 0 } }
-      let(:quantity2) { {} }
-      it { is_expected.to be false }
-    end
-  end
-
-  describe "+" do
-    subject do
-      described_class.new(quantity1) + described_class.new(quantity2)
-    end
-
-    context "same variant" do
-      let(:quantity1) { { variant1 => 20 } }
-      let(:quantity2) { { variant1 => 22 } }
-
-      it { is_expected.to eq described_class.new({ variant1 => 42 }) }
-    end
-
-    context "different variants" do
-      let(:quantity1) { { variant1 => 1 } }
-      let(:quantity2) { { variant2 => 2 } }
-
-      it { is_expected.to eq described_class.new({ variant1 => 1, variant2 => 2 }) }
-    end
-
-    context "0 quantities" do
-      let(:quantity1) { { variant1 => 0 } }
-      let(:quantity2) { { variant2 => 1 } }
-
-      it { is_expected.to eq described_class.new({ variant1 => 0, variant2 => 1 }) }
-    end
-
-    context "empty quantity" do
-      let(:quantity1) { { variant1 => 1 } }
-      let(:quantity2) { {} }
-
-      it { is_expected.to eq described_class.new({ variant1 => 1 }) }
-    end
-  end
-
-  describe "-" do
-    subject do
-      described_class.new(quantity1) - described_class.new(quantity2)
-    end
-
-    context "same variant" do
-      let(:quantity1) { { variant1 => 22 } }
-      let(:quantity2) { { variant1 => 20 } }
-
-      it { is_expected.to eq described_class.new({ variant1 => 2 }) }
-    end
-
-    context "different variants" do
-      let(:quantity1) { { variant1 => 1 } }
-      let(:quantity2) { { variant2 => 2 } }
-
-      it { is_expected.to eq described_class.new({ variant1 => 1, variant2 => -2 }) }
-    end
-
-    context "0 quantity" do
-      let(:quantity1) { { variant1 => 0 } }
-      let(:quantity2) { { variant1 => 1 } }
-
-      it { is_expected.to eq described_class.new({ variant1 => -1 }) }
-    end
-
-    context "empty quantity RHS" do
-      let(:quantity1) { { variant1 => 1 } }
-      let(:quantity2) { {} }
-
-      it { is_expected.to eq described_class.new({ variant1 => 1 }) }
-    end
-
-    context "empty quantity LHS" do
-      let(:quantity1) { {} }
-      let(:quantity2) { { variant1 => 1 } }
-
-      it { is_expected.to eq described_class.new({ variant1 => -1 }) }
-    end
-  end
-
-  # Common subset
-  describe "&" do
-    subject do
-      described_class.new(quantity1) & described_class.new(quantity2)
-    end
-
-    context "same variant" do
-      let(:quantity1) { { variant1 => 20 } }
-      let(:quantity2) { { variant1 => 22 } }
-
-      it { is_expected.to eq described_class.new({ variant1 => 20 }) }
-    end
-
-    context "multiple variants" do
-      let(:quantity1) { { variant1 => 10, variant2 => 20 } }
-      let(:quantity2) { { variant1 => 12, variant2 => 14 } }
-
-      it { is_expected.to eq described_class.new({ variant1 => 10, variant2 => 14 }) }
-    end
-
-    context "different variants" do
-      let(:quantity1) { { variant1 => 1 } }
-      let(:quantity2) { { variant2 => 2 } }
-
-      it { is_expected.to be_empty }
-      it { is_expected.to eq described_class.new({}) }
-    end
-
-    context "0 quantities" do
-      let(:quantity1) { { variant1 => 0 } }
-      let(:quantity2) { { variant1 => 1 } }
-
-      it { is_expected.to eq described_class.new({ variant1 => 0 }) }
-    end
-
-    context "empty quantity" do
-      let(:quantity1) { { variant1 => 1 } }
-      let(:quantity2) { {} }
-
-      it { is_expected.to eq described_class.new({}) }
-    end
-  end
-end

data/spec/models/spree/store_credit_category_spec.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::StoreCreditCategory, type: :model do
-  describe "#non_expiring?" do
-    let(:store_credit_category) { build(:store_credit_category, name: category_name) }
-
-    context "non-expiring type store credit" do
-      let(:category_name) { "Non-expiring" }
-      it { expect(store_credit_category).to be_non_expiring }
-    end
-
-    context "expiring type store credit" do
-      let(:category_name) { "Expiring" }
-      it { expect(store_credit_category).not_to be_non_expiring }
-    end
-  end
-end

data/spec/models/spree/store_credit_event_spec.rb

@@ -1,328 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::StoreCreditEvent do
-  describe ".exposed_events" do
-    [
-      Spree::StoreCredit::ELIGIBLE_ACTION,
-      Spree::StoreCredit::AUTHORIZE_ACTION
-    ].each do |action|
-      let(:action) { action }
-      it "excludes #{action} actions" do
-        event = create(:store_credit_event, action: action)
-        expect(described_class.exposed_events).not_to include event
-      end
-    end
-
-    [
-      Spree::StoreCredit::VOID_ACTION,
-      Spree::StoreCredit::CREDIT_ACTION,
-      Spree::StoreCredit::CAPTURE_ACTION,
-      Spree::StoreCredit::ALLOCATION_ACTION
-    ].each do |action|
-      it "includes #{action} actions" do
-        event = create(:store_credit_event, action: action)
-        expect(described_class.exposed_events).to include event
-      end
-    end
-
-    it "excludes invalidated store credit events" do
-      invalidated_store_credit = create(:store_credit, invalidated_at: Time.current)
-      event = create(:store_credit_event, action: Spree::StoreCredit::VOID_ACTION, store_credit: invalidated_store_credit)
-      expect(described_class.exposed_events).not_to include event
-    end
-  end
-
-  describe "update store credit reason validation" do
-    subject { event.valid? }
-
-    context "adjustment event" do
-      context "has a store credit reason" do
-        let(:event) { build(:store_credit_adjustment_event) }
-
-        it "returns true" do
-          expect(subject).to eq true
-        end
-      end
-
-      context "doesn't have a store credit reason" do
-        let(:event) { build(:store_credit_adjustment_event, store_credit_reason: nil) }
-
-        it "returns false" do
-          expect(subject).to eq false
-        end
-
-        it "adds an error message indicating the store credit reason is missing" do
-          subject
-          expect(event.errors.full_messages).to match ["Store credit reason can't be blank"]
-        end
-      end
-    end
-
-    context "invalidate event" do
-      context "has a store credit reason" do
-        let(:event) { build(:store_credit_invalidate_event) }
-
-        it "returns true" do
-          expect(subject).to eq true
-        end
-      end
-
-      context "doesn't have a store credit reason" do
-        let(:event) { build(:store_credit_invalidate_event, store_credit_reason: nil) }
-
-        it "returns false" do
-          expect(subject).to eq false
-        end
-
-        it "adds an error message indicating the store credit reason is missing" do
-          subject
-          expect(event.errors.full_messages).to match ["Store credit reason can't be blank"]
-        end
-      end
-    end
-
-    context "event doesn't require a store credit reason" do
-      let(:event) { build(:store_credit_auth_event) }
-
-      it "returns true" do
-        expect(subject).to eq true
-      end
-    end
-  end
-
-  describe "#capture_action?" do
-    subject { event.capture_action? }
-
-    context "for capture events" do
-      let(:event) { create(:store_credit_capture_event) }
-
-      it "returns true" do
-        expect(subject).to eq true
-      end
-    end
-
-    context "for non-capture events" do
-      let(:event) { create(:store_credit_auth_event) }
-
-      it "returns false" do
-        expect(subject).to eq false
-      end
-    end
-  end
-
-  describe "#authorization_action?" do
-    subject { event.authorization_action? }
-
-    context "for auth events" do
-      let(:event) { create(:store_credit_auth_event) }
-
-      it "returns true" do
-        expect(subject).to eq true
-      end
-    end
-
-    context "for non-auth events" do
-      let(:event) { create(:store_credit_capture_event) }
-
-      it "returns false" do
-        expect(subject).to eq false
-      end
-    end
-  end
-
-  describe "#action_requires_reason?" do
-    subject { event.action_requires_reason? }
-
-    context "for adjustment events" do
-      let(:event) { create(:store_credit_adjustment_event) }
-
-      it "returns true" do
-        expect(subject).to eq true
-      end
-    end
-
-    context "for invalidate events" do
-      let(:event) { create(:store_credit_invalidate_event) }
-
-      it "returns true" do
-        expect(subject).to eq true
-      end
-    end
-
-    context "for capture events" do
-      let(:event) { create(:store_credit_capture_event) }
-
-      it "returns false" do
-        expect(subject).to eq false
-      end
-    end
-
-    context "for authorize events" do
-      let(:event) { create(:store_credit_auth_event) }
-
-      it "returns false" do
-        expect(subject).to eq false
-      end
-    end
-
-    context "for allocation events" do
-      let(:event) { create(:store_credit_event, action: Spree::StoreCredit::ALLOCATION_ACTION) }
-
-      it "returns false" do
-        expect(subject).to eq false
-      end
-    end
-
-    context "for void events" do
-      let(:event) { create(:store_credit_event, action: Spree::StoreCredit::VOID_ACTION) }
-
-      it "returns false" do
-        expect(subject).to eq false
-      end
-    end
-
-    context "for credit events" do
-      let(:event) { create(:store_credit_event, action: Spree::StoreCredit::CREDIT_ACTION) }
-
-      it "returns false" do
-        expect(subject).to eq false
-      end
-    end
-  end
-
-  describe "#display_amount" do
-    let(:event_amount) { 120.0 }
-
-    subject { create(:store_credit_auth_event, amount: event_amount) }
-
-    it "returns a Spree::Money instance" do
-      expect(subject.display_amount).to be_instance_of(Spree::Money)
-    end
-
-    it "uses the events amount attribute" do
-      expect(subject.display_amount).to eq Spree::Money.new(event_amount, { currency: subject.currency })
-    end
-  end
-
-  describe "#display_user_total_amount" do
-    let(:user_total_amount) { 300.0 }
-
-    subject { create(:store_credit_auth_event, user_total_amount: user_total_amount) }
-
-    it "returns a Spree::Money instance" do
-      expect(subject.display_user_total_amount).to be_instance_of(Spree::Money)
-    end
-
-    it "uses the events user_total_amount attribute" do
-      expect(subject.display_user_total_amount).to eq Spree::Money.new(user_total_amount, { currency: subject.currency })
-    end
-  end
-
-  describe "#display_remaining_amount" do
-    let(:amount_remaining) { 300.0 }
-
-    subject { create(:store_credit_auth_event, amount_remaining: amount_remaining) }
-
-    it "returns a Spree::Money instance" do
-      expect(subject.display_remaining_amount).to be_instance_of(Spree::Money)
-    end
-
-    it "uses the events amount_remaining attribute" do
-      expect(subject.display_remaining_amount).to eq Spree::Money.new(amount_remaining, { currency: subject.currency })
-    end
-  end
-
-  describe "#display_event_date" do
-    let(:date) { Time.zone.parse("2014-06-01") }
-
-    subject { create(:store_credit_auth_event, created_at: date) }
-
-    it "returns the date the event was created with the format month/date/year" do
-      expect(subject.display_event_date).to eq "June 01, 2014"
-    end
-  end
-
-  describe "#display_action" do
-    subject { event.display_action }
-
-    context "capture event" do
-      let(:event) { create(:store_credit_capture_event) }
-
-      it "returns the action's display text" do
-        expect(subject).to eq "Used"
-      end
-    end
-
-    context "allocation event" do
-      let(:event) { create(:store_credit_event, action: Spree::StoreCredit::ALLOCATION_ACTION) }
-
-      it "returns the action's display text" do
-        expect(subject).to eq "Added"
-      end
-    end
-
-    context "void event" do
-      let(:event) { create(:store_credit_event, action: Spree::StoreCredit::VOID_ACTION) }
-
-      it "returns the action's display text" do
-        expect(subject).to eq "Credit"
-      end
-    end
-
-    context "credit event" do
-      let(:event) { create(:store_credit_event, action: Spree::StoreCredit::CREDIT_ACTION) }
-
-      it "returns the action's display text" do
-        expect(subject).to eq "Credit"
-      end
-    end
-
-    context "adjustment event" do
-      let(:event) { create(:store_credit_adjustment_event) }
-
-      it "returns the action's display text" do
-        expect(subject).to eq "Adjustment"
-      end
-    end
-
-    context "authorize event" do
-      let(:event) { create(:store_credit_auth_event) }
-
-      it "returns nil" do
-        expect(subject).to be_nil
-      end
-    end
-
-    context "eligible event" do
-      let(:event) { create(:store_credit_event, action: Spree::StoreCredit::ELIGIBLE_ACTION) }
-
-      it "returns nil" do
-        expect(subject).to be_nil
-      end
-    end
-  end
-
-  describe "#order" do
-    context "there is no associated payment with the event" do
-      subject { create(:store_credit_auth_event) }
-
-      it "returns nil" do
-        expect(subject.order).to be_nil
-      end
-    end
-
-    context "there is an associated payment with the event" do
-      let(:authorization_code) { "1-SC-TEST" }
-      let(:order)              { create(:order) }
-      let!(:payment)           { create(:store_credit_payment, order: order, response_code: authorization_code) }
-
-      subject { create(:store_credit_auth_event, action: Spree::StoreCredit::CAPTURE_ACTION, authorization_code: authorization_code) }
-
-      it "returns the order associated with the payment" do
-        expect(subject.order).to eq order
-      end
-    end
-  end
-end