solidus_core 2.10.1 → 2.11.2

data/spec/models/spree/wallet_payment_source_spec.rb

@@ -1,77 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::WalletPaymentSource, type: :model do
-  subject { Spree::WalletPaymentSource }
-
-  describe "validation" do
-    let(:user) { create(:user) }
-
-    context 'with a non-PaymentSource model' do
-      with_model 'NonPaymentSource', scope: :all do
-        model do
-          # We have to set this up or else `inverse_of` prevents us from testing our code
-          has_many :wallet_payment_sources, class_name: 'Spree::WalletPaymentSource', as: :payment_source, inverse_of: :payment_source
-        end
-      end
-
-      let(:payment_source) { NonPaymentSource.create! }
-
-      it "errors when `payment_source` is not a `Spree::PaymentSource`" do
-        wallet_payment_source = Spree::WalletPaymentSource.new(
-          payment_source: payment_source,
-          user: user
-        )
-
-        expect(wallet_payment_source).not_to be_valid
-        expect(wallet_payment_source.errors.messages).to eq(
-          { payment_source: ["is not a valid payment source"] }
-        )
-      end
-    end
-
-    it "is invalid if `payment_source` is already in the user's wallet" do
-      credit_card = create(:credit_card, user: user)
-      Spree::WalletPaymentSource.create(
-        payment_source: credit_card,
-        user: user
-      )
-      wallet_payment_source = subject.new(
-        payment_source: credit_card,
-        user: user
-      )
-      expect(wallet_payment_source).not_to be_valid
-      expect(wallet_payment_source.errors.messages).to eq(
-        { user_id: ["already has this payment source in their wallet"] }
-      )
-    end
-
-    it "is invalid when `payment_source` is not owned by the user" do
-      wallet_payment_source = subject.new(
-        payment_source: create(:credit_card),
-        user: user
-      )
-      expect(wallet_payment_source).not_to be_valid
-      expect(wallet_payment_source.errors.messages).to eq(
-        { payment_source: ["does not belong to the user associated with the order"] }
-      )
-    end
-
-    it "is valid with a `credit_card` as `payment_source`" do
-      valid_attrs = {
-        payment_source: create(:credit_card, user: user),
-        user: user
-      }
-      expect(subject.new(valid_attrs)).to be_valid
-    end
-
-    it "is valid with `store_credit` as `payment_source`" do
-      valid_attrs = {
-        payment_source: create(:store_credit, user: user),
-        user: user
-      }
-      expect(subject.new(valid_attrs)).to be_valid
-    end
-  end
-end

data/spec/models/spree/wallet_spec.rb

@@ -1,155 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::Wallet, type: :model do
-  let(:user) { create(:user) }
-  let(:credit_card) { create(:credit_card, user_id: user.id) }
-  let(:store_credit) { create(:store_credit, user_id: user.id) }
-  subject(:wallet) { Spree::Wallet.new(user) }
-
-  describe "#add" do
-    context "with valid payment source" do
-      it "creates a wallet_payment_source for this user's wallet" do
-        expect { subject.add(credit_card) }.to change(Spree::WalletPaymentSource, :count).by(1)
-      end
-
-      it "only creates the payment source once" do
-        subject.add(credit_card)
-        expect { subject.add(credit_card) }.to_not change(Spree::WalletPaymentSource, :count)
-      end
-    end
-  end
-
-  describe "#remove" do
-    context "with payment_source not in the wallet" do
-      it "will raise a RecordNotFound exception" do
-        expect { subject.remove(credit_card) }.to raise_error(ActiveRecord::RecordNotFound)
-      end
-    end
-
-    context "with the payment_source in the wallet" do
-      before { subject.add(credit_card) }
-      it "will remove the payment source from the wallet" do
-        expect { subject.remove(credit_card) }.to change(Spree::WalletPaymentSource, :count).by(-1)
-      end
-    end
-  end
-
-  describe "#wallet_payment_sources" do
-    context "with no payment sources" do
-      it "returns an empty Array" do
-        expect(subject.wallet_payment_sources).to eql []
-      end
-    end
-
-    context "with payment sources" do
-      let!(:wallet_credit_card) { subject.add(credit_card) }
-      let!(:wallet_store_credit) { subject.add(store_credit) }
-
-      it "returns all the payment sources" do
-        expect(subject.wallet_payment_sources).to include(wallet_credit_card, wallet_store_credit)
-      end
-    end
-  end
-
-  describe "#find" do
-    context "with no payment sources in the wallet" do
-      it "returns nil" do
-        expect(subject.find(1)).to be_nil
-      end
-    end
-
-    context "with payment sources in the wallet" do
-      let(:wallet_credit_card) { subject.add(credit_card) }
-
-      it "finds the wallet payment source by id" do
-        expect(subject.find(wallet_credit_card.id)).to eql wallet_credit_card
-      end
-    end
-  end
-
-  describe "#default_wallet_payment_source=" do
-    context "with no current default" do
-      let!(:wallet_credit_card) { subject.add(credit_card) }
-
-      it "marks the passed in payment source as default" do
-        expect { subject.default_wallet_payment_source = wallet_credit_card }.to(
-          change(subject, :default_wallet_payment_source).
-            from(nil).
-            to(wallet_credit_card)
-        )
-      end
-
-      context "assigning nil" do
-        it "remains unset" do
-          expect(subject.default_wallet_payment_source).to be_nil
-          subject.default_wallet_payment_source = nil
-          expect(subject.default_wallet_payment_source).to be_nil
-        end
-      end
-    end
-
-    context "with a default" do
-      let!(:wallet_credit_card) { subject.add(credit_card) }
-
-      before { subject.default_wallet_payment_source = wallet_credit_card }
-
-      context "assigning a new default" do
-        let!(:wallet_store_credit) { subject.add(store_credit) }
-
-        it "sets the new payment source as the default" do
-          expect {
-            subject.default_wallet_payment_source = wallet_store_credit
-          }.to change{ subject.default_wallet_payment_source }.from(wallet_credit_card).to(wallet_store_credit)
-        end
-      end
-
-      context "assigning same default" do
-        it "does not change the default payment source" do
-          expect {
-            subject.default_wallet_payment_source = wallet_credit_card
-          }.not_to change{ subject.default_wallet_payment_source }
-        end
-      end
-
-      context "assigning nil" do
-        it "clears the default payment source" do
-          expect {
-            subject.default_wallet_payment_source = nil
-          }.to change{ subject.default_wallet_payment_source }.to nil
-        end
-      end
-    end
-
-    context 'with a wallet payment source that does not belong to the wallet' do
-      let(:other_wallet_credit_card) { other_wallet.add(other_credit_card) }
-      let(:other_wallet) { Spree::Wallet.new(other_user) }
-      let(:other_credit_card) { create(:credit_card, user_id: other_user.id) }
-      let(:other_user) { create(:user) }
-
-      it 'raises an error' do
-        expect {
-          wallet.default_wallet_payment_source = other_wallet_credit_card
-        }.to raise_error(Spree::Wallet::Unauthorized)
-      end
-    end
-  end
-
-  describe "#default_wallet_payment_source" do
-    context "with no default payment source present" do
-      it "will return nil" do
-        expect(subject.default_wallet_payment_source).to be_nil
-      end
-    end
-
-    context "with a default payment source" do
-      let!(:wallet_credit_card) { subject.add(credit_card) }
-      before { subject.default_wallet_payment_source = wallet_credit_card }
-
-      it "will return the wallet payment source" do
-        expect(subject.default_wallet_payment_source).to eql wallet_credit_card
-      end
-    end
-  end
-end

data/spec/models/spree/zone_spec.rb

@@ -1,248 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::Zone, type: :model do
-  describe 'for_address' do
-    let(:new_york_address) { create(:address, state_code: "NY") }
-    let(:alabama_address) { create(:address) }
-    let(:canada_address) { create(:address, country_iso_code: "CA") }
-
-    let!(:new_york_zone) { create(:zone, states: [new_york_address.state]) }
-    let!(:alabama_zone) { create(:zone, states: [alabama_address.state]) }
-    let!(:united_states_zone) { create(:zone, countries: [new_york_address.country]) }
-    let!(:canada_zone) { create(:zone, countries: [canada_address.country]) }
-    let!(:north_america_zone) { create(:zone, countries: [canada_address.country, new_york_address.country]) }
-    subject { Spree::Zone.for_address(address) }
-
-    context 'when there is no address' do
-      let(:address) { nil }
-      it 'returns an empty relation' do
-        expect(subject).to eq([])
-      end
-    end
-
-    context 'for an address in New York' do
-      let(:address) { new_york_address }
-
-      it 'matches the New York zone' do
-        expect(subject).to include(new_york_zone)
-      end
-
-      it 'matches the United States zone' do
-        expect(subject).to include(united_states_zone)
-      end
-
-      it 'does not match the Alabama zone' do
-        expect(subject).not_to include(alabama_zone)
-      end
-
-      it 'does not match the Canadian zone' do
-        expect(subject).not_to include(canada_zone)
-      end
-
-      it 'matches the North America zone' do
-        expect(subject).to include(north_america_zone)
-      end
-    end
-  end
-
-  context "#country_list" do
-    let(:state) { create(:state) }
-    let(:country) { state.country }
-
-    context "when zone consists of countries" do
-      let(:country_zone) { create(:zone, name: 'CountryZone') }
-
-      before { country_zone.members.create(zoneable: country) }
-
-      it 'should return a list of countries' do
-        Spree::Deprecation.silence do
-          expect(country_zone.country_list).to eq([country])
-        end
-      end
-    end
-
-    context "when zone consists of states" do
-      let(:state_zone) { create(:zone, name: 'StateZone') }
-
-      before { state_zone.members.create(zoneable: state) }
-
-      it 'should return a list of countries' do
-        Spree::Deprecation.silence do
-          expect(state_zone.country_list).to eq([state.country])
-        end
-      end
-    end
-  end
-
-  context "#include?" do
-    let(:state) { create(:state) }
-    let(:country) { state.country }
-    let(:address) { create(:address, state: state) }
-
-    context "when zone is country type" do
-      let(:country_zone) { create(:zone, name: 'CountryZone') }
-      before { country_zone.members.create(zoneable: country) }
-
-      it "should be true" do
-        expect(country_zone.include?(address)).to be true
-      end
-    end
-
-    context "when zone is state type" do
-      let(:state_zone) { create(:zone, name: 'StateZone') }
-      before { state_zone.members.create(zoneable: state) }
-
-      it "should be true" do
-        expect(state_zone.include?(address)).to be true
-      end
-    end
-  end
-
-  context "#save" do
-    context "when a zone member country is added to an existing zone consisting of state members" do
-      it "should remove existing state members" do
-        zone = create(:zone, name: 'foo', zone_members: [])
-        state = create(:state)
-        country = create(:country)
-        zone.members.create(zoneable: state)
-        country_member = zone.members.create(zoneable: country)
-        zone.save
-        expect(zone.reload.members).to eq([country_member])
-      end
-    end
-  end
-
-  context "#kind" do
-    context "when the zone consists of country zone members" do
-      before do
-        @zone = create(:zone, name: 'country', zone_members: [])
-        @zone.members.create(zoneable: create(:country))
-      end
-      it "should return the kind of zone member" do
-        expect(@zone.kind).to eq("country")
-      end
-    end
-
-    context "when the zone consists of state zone members" do
-      before do
-        @zone = create(:zone, name: 'state', zone_members: [])
-        @zone.members.create(zoneable: create(:state))
-      end
-      it "should return the kind of zone member" do
-        expect(@zone.kind).to eq("state")
-      end
-    end
-  end
-
-  context "state and country associations" do
-    let!(:country) { create(:country) }
-
-    context "has countries associated" do
-      let!(:zone) do
-        create(:zone, countries: [country])
-      end
-
-      it "can access associated countries" do
-        expect(zone.countries).to eq([country])
-      end
-    end
-
-    context "has states associated" do
-      let!(:state) { create(:state, country: country) }
-      let!(:zone) do
-        create(:zone, states: [state])
-      end
-
-      it "can access associated states" do
-        expect(zone.states).to eq([state])
-      end
-    end
-  end
-
-  context ".with_shared_members" do
-    let!(:country)  { create(:country) }
-    let!(:country2) { create(:country, name: 'OtherCountry') }
-    let!(:country3) { create(:country, name: 'TaxCountry') }
-
-    subject(:zones_with_shared_members) { Spree::Zone.with_shared_members(zone) }
-
-    context 'when passing a zone with no members' do
-      let!(:zone) { create :zone }
-
-      it 'will return an empty set' do
-        expect(subject).to eq([])
-      end
-    end
-
-    context 'when passing nil' do
-      let!(:zone) { nil }
-
-      it 'will return an empty set' do
-        expect(subject).to eq([])
-      end
-    end
-
-    context "finding potential matches for a country zone" do
-      let!(:zone) do
-        create(:zone).tap do |z|
-          z.members.create(zoneable: country)
-          z.members.create(zoneable: country2)
-          z.save!
-        end
-      end
-
-      let!(:zone2) do
-        create(:zone).tap { |z| z.members.create(zoneable: country) && z.save! }
-      end
-
-      let!(:zone3) do
-        create(:zone).tap { |z| z.members.create(zoneable: country3) && z.save! }
-      end
-
-      it "will find all zones with countries covered by the passed in zone" do
-        expect(zones_with_shared_members).to include(zone, zone2)
-      end
-
-      it "will not return zones with countries not covered in the passed in zone" do
-        expect(zones_with_shared_members).not_to include(zone3)
-      end
-
-      it "only returns each zone once" do
-        expect(zones_with_shared_members.select { |z| z == zone }.size).to be 1
-      end
-    end
-
-    context "finding potential matches for a state zone" do
-      let!(:state)  { create(:state, country: country) }
-      let!(:state2) { create(:state, country: country2, name: 'OtherState') }
-      let!(:state3) { create(:state, country: country2, name: 'State') }
-      let!(:zone) do
-        create(:zone).tap do |z|
-          z.members.create(zoneable: state)
-          z.members.create(zoneable: state2)
-          z.save!
-        end
-      end
-      let!(:zone2) do
-        create(:zone).tap { |z| z.members.create(zoneable: state) && z.save! }
-      end
-      let!(:zone3) do
-        create(:zone).tap { |z| z.members.create(zoneable: state2) && z.save! }
-      end
-
-      it "will find all zones which share states covered by passed in zone" do
-        expect(zones_with_shared_members).to include(zone, zone2)
-      end
-
-      it "will find zones that share countries with any states of the passed in zone" do
-        expect(zones_with_shared_members).to include(zone3)
-      end
-
-      it "only returns each zone once" do
-        expect(zones_with_shared_members.select { |z| z == zone }.size).to be 1
-      end
-    end
-  end
-end