solidus_core 2.10.5 → 3.0.8

data/spec/models/spree/concerns/user_address_book_spec.rb

@@ -1,358 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-module Spree
-  RSpec.describe UserAddressBook do
-    #
-    # Using LegacyUser as a subject
-    # since it uses the UserAddressBookExtension
-    #
-    let!(:user) { create(:user) }
-
-    describe "#save_in_address_book" do
-      context "saving a default address" do
-        let(:user_address) { user.user_addresses.find_first_by_address_values(address.attributes) }
-
-        subject { user.save_in_address_book(address.attributes, true) }
-
-        context "the address is a new record" do
-          let(:address) { build(:address) }
-
-          it "creates a new Address" do
-            expect { subject }.to change { Spree::Address.count }.by(1)
-          end
-
-          it "creates a UserAddress" do
-            expect { subject }.to change { Spree::UserAddress.count }.by(1)
-          end
-
-          it "sets the UserAddress default flag to true" do
-            subject
-            expect(user_address.default).to eq true
-          end
-
-          it "adds the address to the user's the associated addresses" do
-            expect { subject }.to change { user.reload.addresses.count }.by(1)
-          end
-        end
-
-        context "user already has a default address" do
-          let(:address) { create(:address) }
-          let(:original_default_address) { create(:ship_address) }
-          let(:original_user_address) { user.user_addresses.find_first_by_address_values(original_default_address.attributes) }
-
-          before do
-            user.user_addresses.create(address: original_default_address, default: true)
-          end
-
-          it "makes all the other associated addresses not be the default" do
-            expect { subject }.to change { original_user_address.reload.default }.from(true).to(false)
-          end
-
-          context "an odd flip-flop corner case discovered running backfill rake task" do
-            before do
-              user.save_in_address_book(original_default_address.attributes, true)
-              user.save_in_address_book(address.attributes, true)
-            end
-
-            it "handles setting 2 addresses as default without a reload of user" do
-              user.save_in_address_book(original_default_address.attributes, true)
-              user.save_in_address_book(address.attributes, true)
-              expect(user.addresses.count).to eq 2
-              expect(user.default_address.address1).to eq address.address1
-            end
-          end
-        end
-
-        context "changing existing address to default" do
-          let(:address) { create(:address) }
-
-          before do
-            user.user_addresses.create(address: address, default: false)
-          end
-
-          it "properly sets the default flag" do
-            expect(subject).to eq user.default_address
-          end
-
-          context "and changing another address field at the same time" do
-            let(:updated_address_attributes) { address.attributes.tap { |value| value[:first_name] = "Newbie" } }
-
-            subject { user.save_in_address_book(updated_address_attributes, true) }
-
-            it "changes first name" do
-              expect(subject.first_name).to eq updated_address_attributes[:first_name]
-            end
-
-            it "preserves last name" do
-              expect(subject.last_name).to eq address.last_name
-            end
-
-            it "is a new immutable address instance" do
-              expect(subject.id).to_not eq address.id
-            end
-
-            it "is the new default" do
-              expect(subject).to eq user.default_address
-            end
-          end
-        end
-      end
-
-      context "updating an address and making default at once" do
-        let(:address1) { create(:address) }
-        let(:address2) { create(:address, firstname: "Different") }
-        let(:updated_attrs) do
-          address2.attributes.tap { |value| value[:firstname] = "Johnny" }
-        end
-
-        before do
-          user.save_in_address_book(address1.attributes, true)
-          user.save_in_address_book(address2.attributes, false)
-        end
-
-        it "returns the edit as the first address" do
-          user.save_in_address_book(updated_attrs, true)
-          expect(user.user_addresses.first.address.firstname).to eq "Johnny"
-        end
-      end
-
-      context "saving a non-default address" do
-        let(:user_address) { user.user_addresses.find_first_by_address_values(address.attributes) }
-
-        subject { user.save_in_address_book(address.attributes) }
-
-        context "the address is a new record" do
-          let(:address) { build(:address) }
-
-          it "creates a new Address" do
-            expect { subject }.to change { Spree::Address.count }.by(1)
-          end
-
-          it "creates a UserAddress" do
-            expect { subject }.to change { Spree::UserAddress.count }.by(1)
-          end
-
-          context "it is not the first address" do
-            before { user.user_addresses.create!(address: create(:address)) }
-            it "sets the UserAddress default flag to false" do
-              expect { subject }.to change { Spree::UserAddress.count }.by(1)
-              expect(user_address.default).to eq false
-            end
-          end
-
-          context "it is the first address" do
-            it "sets the UserAddress default flag to true" do
-              subject
-              expect(user_address.default).to eq true
-            end
-          end
-
-          it "adds the address to the user's the associated addresses" do
-            expect { subject }.to change { user.reload.addresses.count }.by(1)
-          end
-        end
-      end
-
-      context "resurrecting a previously saved (but now archived) address" do
-        let(:address) { create(:address) }
-        before do
-          user.save_in_address_book(address.attributes, true)
-          user.remove_from_address_book(address.id)
-        end
-        subject { user.save_in_address_book(address.attributes, true) }
-
-        it "returns the address" do
-          expect(subject).to eq address
-        end
-
-        it "sets it as default" do
-          subject
-          expect(user.default_address).to eq address
-        end
-
-        context "via an edit to another address" do
-          let(:address2) { create(:address, firstname: "Different") }
-          let(:edited_attributes) do
-            # conceptually edit address2 to match the values of address
-            edited_attributes = address.attributes
-            edited_attributes[:id] = address2.id
-            edited_attributes
-          end
-
-          before { user.save_in_address_book(address2.attributes, true) }
-
-          subject { user.save_in_address_book(edited_attributes) }
-
-          it "returns the address" do
-            expect(subject).to eq address
-          end
-
-          it "archives address2" do
-            subject
-            user_address_two = user.user_addresses.all_historical.find_by(address_id: address2.id)
-            expect(user_address_two.archived).to be true
-          end
-
-          context "via a new address that matches an archived one" do
-            let(:added_attributes) do
-              added_attributes = address.attributes
-              added_attributes.delete(:id)
-              added_attributes
-            end
-
-            subject { user.save_in_address_book(added_attributes) }
-
-            it "returns the address" do
-              expect(subject).to eq address
-            end
-
-            it "no longer has archived user_addresses" do
-              subject
-              expect(user.user_addresses.all_historical).to eq user.user_addresses
-            end
-          end
-        end
-      end
-    end
-
-    context "#remove_from_address_book" do
-      let(:address1) { create(:address) }
-      let(:address2) { create(:address, firstname: "Different") }
-      let(:remove_id) { address1.id }
-      subject { user.remove_from_address_book(remove_id) }
-
-      before do
-        user.save_in_address_book(address1.attributes)
-        user.save_in_address_book(address2.attributes)
-      end
-
-      it "removes the address from user_addresses" do
-        subject
-        expect(user.user_addresses.find_first_by_address_values(address1.attributes)).to be_nil
-      end
-
-      it "leaves user_address record in an archived state" do
-        subject
-        archived_user_address = user.user_addresses.all_historical.find_first_by_address_values(address1.attributes)
-        expect(archived_user_address).to be_archived
-      end
-
-      it "returns false if the addresses is not there" do
-        expect(user.remove_from_address_book(0)).to be false
-      end
-    end
-
-    context "#persist_order_address" do
-      it 'will save the bill/ship_address reference if it can' do
-        order = create :order
-        user.persist_order_address(order)
-
-        expect( user.bill_address_id ).to eq order.bill_address_id
-        expect( user.ship_address_id ).to eq order.ship_address_id
-        expect( user.bill_address_id ).not_to eq user.ship_address_id
-      end
-
-      context "when automatic_default_address preference is at a default of true" do
-        before do
-          stub_spree_preferences(automatic_default_address: true)
-          expect(user).to receive(:save_in_address_book).with(kind_of(Hash), true)
-          expect(user).to receive(:save_in_address_book).with(kind_of(Hash), false)
-        end
-
-        it "does set the default: true flag" do
-          order = build(:order)
-          user.persist_order_address(order)
-        end
-      end
-
-      context "when automatic_default_address preference is false" do
-        before do
-          stub_spree_preferences(automatic_default_address: false)
-          expect(user).to receive(:save_in_address_book).with(kind_of(Hash), false).twice
-          # and not the optional 2nd argument
-        end
-
-        it "does not set the default: true flag" do
-          order = build(:order)
-          user.persist_order_address(order)
-        end
-      end
-
-      context "when address is nil" do
-        context "when automatic_default_address preference is at a default of true" do
-          before do
-            stub_spree_preferences(automatic_default_address: true)
-            expect(user).to receive(:save_in_address_book).with(kind_of(Hash), true).once
-          end
-
-          it "does not call save_in_address_book on ship address" do
-            order = build(:order)
-            order.ship_address = nil
-
-            user.persist_order_address(order)
-          end
-
-          it "does not call save_in_address_book on bill address" do
-            order = build(:order)
-            order.bill_address = nil
-
-            user.persist_order_address(order)
-          end
-        end
-      end
-
-      context "when automatic_default_address preference is false" do
-        before do
-          stub_spree_preferences(automatic_default_address: false)
-          expect(user).to receive(:save_in_address_book).with(kind_of(Hash), false).once
-        end
-
-        it "does not call save_in_address_book on ship address" do
-          order = build(:order)
-          order.ship_address = nil
-
-          user.persist_order_address(order)
-        end
-
-        it "does not call save_in_address_book on bill address" do
-          order = build(:order)
-          order.bill_address = nil
-
-          user.persist_order_address(order)
-        end
-      end
-    end
-
-    describe "generating a new user with a ship_address at once" do
-      let(:ship_address) { build(:ship_address) }
-      subject { create(:user, ship_address: ship_address) }
-
-      it "stores the ship_address" do
-        expect(subject.ship_address).to eq ship_address
-      end
-
-      it "is also available as default_address" do
-        expect(subject.default_address).to eq ship_address
-      end
-    end
-
-    describe "ship_address=" do
-      let!(:user) { create(:user) }
-      let!(:address) { create(:address) }
-
-      # https://github.com/solidusio/solidus/issues/1241
-      it "resets the association and persists" do
-        # Load (which will cache) the has_one association
-        expect(user.ship_address).to be_nil
-
-        user.update!(ship_address: address)
-        expect(user.ship_address).to eq(address)
-
-        user.reload
-        expect(user.ship_address).to eq(address)
-      end
-    end
-  end
-end

data/spec/models/spree/concerns/user_methods_spec.rb

@@ -1,122 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::UserMethods do
-  let(:test_user) { create :user }
-
-  describe '#has_spree_role?' do
-    subject { test_user.has_spree_role? name }
-
-    let(:role) { Spree::Role.create(name: name) }
-    let(:name) { 'test' }
-
-    context 'with a role' do
-      before { test_user.spree_roles << role }
-      it     { is_expected.to be_truthy }
-    end
-
-    context 'without a role' do
-      it { is_expected.to be_falsy }
-    end
-  end
-
-  describe '#last_incomplete_spree_order' do
-    subject { test_user.last_incomplete_spree_order }
-
-    context 'with an incomplete order' do
-      let(:last_incomplete_order) { create :order, user: test_user }
-
-      before do
-        create(:order, user: test_user, created_at: 1.day.ago)
-        create(:order, user: create(:user))
-        last_incomplete_order
-      end
-
-      it { is_expected.to eq last_incomplete_order }
-    end
-
-    context 'without an incomplete order' do
-      it { is_expected.to be_nil }
-    end
-  end
-
-  describe "deleting user" do
-    context "with no orders" do
-      it "fails validation" do
-        test_user.destroy!
-        expect(test_user).to be_destroyed
-      end
-    end
-
-    context "with an order" do
-      let!(:order) { create(:order, user: test_user) }
-
-      it "fails validation" do
-        expect {
-          test_user.destroy!
-        }.to raise_error(ActiveRecord::DeleteRestrictionError)
-      end
-    end
-  end
-
-  describe '#available_store_credit_total' do
-    subject do
-      test_user.reload.available_store_credit_total(currency: 'USD')
-    end
-
-    context 'when the user does not have any credit' do
-      it { is_expected.to eq(0) }
-    end
-
-    context 'when the user has credits' do
-      let!(:credit_1) { create(:store_credit, user: test_user, amount: 100) }
-      let!(:credit_2) { create(:store_credit, user: test_user, amount: 200) }
-
-      it { is_expected.to eq(100 + 200) }
-
-      context 'when some has been used' do
-        before { credit_1.update!(amount_used: 35) }
-
-        it { is_expected.to eq(100 + 200 - 35) }
-
-        context 'when some has been authorized' do
-          before { credit_1.update!(amount_authorized: 10) }
-
-          it { is_expected.to eq(100 + 200 - 35 - 10) }
-        end
-      end
-
-      context 'when some has been authorized' do
-        before { credit_1.update!(amount_authorized: 10) }
-
-        it { is_expected.to eq(100 + 200 - 10) }
-      end
-
-      context 'with credits of multiple currencies' do
-        let!(:credit_3) { create(:store_credit, user: test_user, amount: 400, currency: 'GBP') }
-        before { test_user.reload }
-
-        it 'separates the currencies' do
-          expect(test_user.available_store_credit_total(currency: 'USD')).to eq(100 + 200)
-          expect(test_user.available_store_credit_total(currency: 'GBP')).to eq(400)
-        end
-      end
-    end
-  end
-
-  describe '#display_available_store_credit_total' do
-    subject do
-      test_user.display_available_store_credit_total(currency: 'USD')
-    end
-
-    context 'without credit' do
-      it { is_expected.to eq(Spree::Money.new(0)) }
-    end
-
-    context 'with credit' do
-      let!(:credit) { create(:store_credit, user: test_user, amount: 100) }
-      it { is_expected.to eq(Spree::Money.new(100)) }
-    end
-  end
-end

data/spec/models/spree/country_spec.rb

@@ -1,154 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::Country, type: :model do
-  describe '.default' do
-    before do
-      create(:country, iso: "DE", id: 1)
-      create(:country, id: 2)
-    end
-
-    subject(:default_country) { described_class.default }
-
-    context 'with the configuration setting an existing legacy default country ID' do
-      before do
-        stub_spree_preferences(default_country_id: 2)
-      end
-
-      subject(:default_country) do
-        Spree::Deprecation.silence { described_class.default }
-      end
-
-      it 'emits a deprecation warning' do
-        expect(Spree::Deprecation).to receive(:warn)
-        default_country
-      end
-
-      it 'is the country with that ID' do
-        expect(default_country).to eq(Spree::Country.find(2))
-      end
-    end
-
-    context 'with the configuration setting a non-existing legacy default country ID' do
-      before do
-        stub_spree_preferences(default_country_id: 0)
-      end
-
-      subject(:default_country) do
-        Spree::Deprecation.silence { described_class.default }
-      end
-
-      it 'loads the country configured by the ISO code' do
-        expect(default_country).to eq(Spree::Country.find(2))
-      end
-    end
-
-    context 'with the configuration setting an existing ISO code' do
-      it 'is a country with the configurations ISO code' do
-        expect(described_class.default).to be_a(Spree::Country)
-        expect(described_class.default.iso).to eq('US')
-      end
-    end
-
-    context 'with the configuration setting an non-existing ISO code' do
-      before { stub_spree_preferences(default_country_iso: "ZZ") }
-
-      it 'raises a Record not Found error' do
-        expect { described_class.default }.to raise_error(ActiveRecord::RecordNotFound)
-      end
-    end
-  end
-
-  describe '.available' do
-    let!(:united_states) { create(:country, iso: 'US') }
-    let!(:canada) { create(:country, iso: 'CA') }
-    let!(:italy) { create(:country, iso: 'IT') }
-    let!(:custom_zone) { create(:zone, name: 'Custom Zone', countries: [united_states, italy]) }
-
-    context 'with a checkout zone defined' do
-      context 'when checkout zone is of type country' do
-        let!(:checkout_zone) { create(:zone, name: 'Checkout Zone', countries: [united_states, canada]) }
-
-        before do
-          stub_spree_preferences(checkout_zone: checkout_zone.name)
-        end
-
-        context 'with no arguments' do
-          it 'returns "Checkout Zone" countries' do
-            expect(described_class.available).to contain_exactly(united_states, canada)
-          end
-        end
-
-        context 'setting nil as restricting zone' do
-          it 'returns all countries' do
-            expect(described_class.available(restrict_to_zone: nil)).to contain_exactly(united_states, canada, italy)
-          end
-        end
-
-        context 'setting "Custom Zone" as restricting zone' do
-          it 'returns "Custom Zone" countries' do
-            expect(described_class.available(restrict_to_zone: 'Custom Zone')).to contain_exactly(united_states, italy)
-          end
-        end
-
-        context 'setting "Checkout Zone" as restricting zone' do
-          it 'returns "Checkout Zone" countries' do
-            expect(described_class.available(restrict_to_zone: 'Checkout Zone')).to contain_exactly(united_states, canada)
-          end
-        end
-      end
-
-      context 'when checkout zone is of type state' do
-        let!(:state) { create(:state, country: united_states) }
-        let!(:checkout_zone) { create(:zone, name: 'Checkout Zone', states: [state]) }
-
-        before do
-          stub_spree_preferences(checkout_zone: checkout_zone.name)
-        end
-
-        context 'with no arguments' do
-          it 'returns all countries' do
-            expect(described_class.available(restrict_to_zone: nil)).to contain_exactly(united_states, canada, italy)
-          end
-        end
-      end
-    end
-
-    context 'with no checkout zone defined' do
-      context 'with no arguments' do
-        it 'returns all countries' do
-          expect(described_class.available).to contain_exactly(united_states, canada, italy)
-        end
-      end
-
-      context 'setting nil as restricting zone' do
-        it 'returns all countries' do
-          expect(described_class.available(restrict_to_zone: nil)).to contain_exactly(united_states, canada, italy)
-        end
-      end
-
-      context 'setting "Custom Zone" as restricting zone' do
-        it 'returns "Custom Zone" countries' do
-          expect(described_class.available(restrict_to_zone: 'Custom Zone')).to contain_exactly(united_states, italy)
-        end
-      end
-    end
-  end
-
-  describe '#prices' do
-    let(:country) { create(:country) }
-    subject { country.prices }
-
-    it { is_expected.to be_a(ActiveRecord::Associations::CollectionProxy) }
-
-    context "if the country has associated prices" do
-      let!(:price_one) { create(:price) }
-      let!(:price_two) { create(:price) }
-      let!(:price_three) { create(:price) }
-      let(:country) { create(:country, prices: [price_one, price_two]) }
-
-      it { is_expected.to contain_exactly(price_one, price_two) }
-    end
-  end
-end