solidus_core_devise_token_auth 2.8.0.alpha.0

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

@@ -0,0 +1,358 @@
+# 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 { |a| a[: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 { |a| a[: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_address2 = user.user_addresses.all_historical.find_by(address_id: address2.id)
+            expect(user_address2.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
+          Spree::Config.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
+          Spree::Config.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
+            Spree::Config.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
+          Spree::Config.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

@@ -0,0 +1,121 @@
+# 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.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_attributes!(amount_used: 35) }
+
+        it { is_expected.to eq(100 + 200 - 35) }
+
+        context 'when some has been authorized' do
+          before { credit_1.update_attributes!(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_attributes!(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') }
+
+        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

@@ -0,0 +1,78 @@
+# 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
+        Spree::Config[: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
+        Spree::Config[: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 { Spree::Config[: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 '#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