solidus_core_devise_token_auth 2.8.0.alpha.0

data/spec/models/spree/wallet_payment_source_spec.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe Spree::WalletPaymentSource, type: :model do
+  subject { Spree::WalletPaymentSource }
+
+  describe "validation" do
+    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: create(:user)
+        )
+
+        expect(wallet_payment_source).not_to be_valid
+        expect(wallet_payment_source.errors.messages).to eq(
+          { payment_source: ["has to be a Spree::PaymentSource"] }
+        )
+      end
+    end
+
+    it "is valid with a `credit_card` as `payment_source`" do
+      valid_attrs = {
+        payment_source: create(:credit_card),
+        user: create(: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: create(:user)
+      }
+      expect(subject.new(valid_attrs)).to be_valid
+    end
+  end
+end

data/spec/models/spree/wallet_spec.rb

@@ -0,0 +1,155 @@
+# 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(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

@@ -0,0 +1,248 @@
+# 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

data/spec/rails_helper.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+ENV["RAILS_ENV"] ||= 'test'
+
+require 'spree/testing_support/dummy_app'
+DummyApp.setup(
+  gem_root: File.expand_path('..', __dir__),
+  lib_name: 'solidus_core'
+)
+
+require 'rspec/rails'
+require 'rspec-activemodel-mocks'
+require 'database_cleaner'
+
+Dir["./spec/support/**/*.rb"].sort.each { |f| require f }
+
+require 'spree/testing_support/factories'
+require 'spree/testing_support/preferences'
+require 'cancan/matchers'
+
+ActiveJob::Base.queue_adapter = :test
+
+RSpec.configure do |config|
+  config.fixture_path = File.join(__dir__, "fixtures")
+
+  config.infer_spec_type_from_file_location!
+
+  # If you're not using ActiveRecord, or you'd prefer not to run each of your
+  # examples within a transaction, comment the following line or assign false
+  # instead of true.
+  config.use_transactional_fixtures = true
+
+  config.before :suite do
+    DatabaseCleaner.clean_with :truncation
+  end
+
+  config.before :each do
+    Rails.cache.clear
+  end
+
+  config.include ActiveJob::TestHelper
+  config.include FactoryBot::Syntax::Methods
+end

data/spec/shared_examples/calculator_shared_examples.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+RSpec.shared_examples_for 'a calculator with a description' do
+  describe ".description" do
+    subject { described_class.description }
+    it "has a description" do
+      expect(subject.size).to be > 0
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+if ENV["COVERAGE"]
+  require 'simplecov'
+  SimpleCov.start('rails')
+end
+
+require 'rspec/core'
+
+require 'spree/testing_support/preferences'
+require 'spree/config'
+require 'with_model'
+
+RSpec.configure do |config|
+  config.disable_monkey_patching!
+  config.color = true
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+  config.mock_with :rspec do |c|
+    c.syntax = :expect
+  end
+
+  config.before :each do
+    reset_spree_preferences
+  end
+
+  config.include Spree::TestingSupport::Preferences
+  config.extend WithModel
+
+  config.filter_run focus: true
+  config.run_all_when_everything_filtered = true
+
+  config.example_status_persistence_file_path = "./spec/examples.txt"
+
+  config.order = :random
+
+  Kernel.srand config.seed
+end

data/spec/support/big_decimal.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class BigDecimal
+  def inspect
+    "#<BigDecimal: #{self}>"
+  end
+end

data/spec/support/concerns/default_price.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+RSpec.shared_examples_for "default_price" do
+  let(:model)        { described_class }
+  subject(:instance) { FactoryBot.build(model.name.demodulize.downcase.to_sym) }
+
+  describe '.has_one :default_price' do
+    let(:default_price_association) { model.reflect_on_association(:default_price) }
+
+    it 'should be a has one association' do
+      expect(default_price_association.macro).to eql :has_one
+    end
+
+    it 'should have a dependent destroy' do
+      expect(default_price_association.options[:dependent]).to eql :destroy
+    end
+
+    it 'should have the class name of Spree::Price' do
+      expect(default_price_association.options[:class_name]).to eql 'Spree::Price'
+    end
+  end
+
+  describe '#default_price' do
+    subject { instance.default_price }
+
+    describe '#class' do
+      subject { super().class }
+      it { is_expected.to eql Spree::Price }
+    end
+  end
+
+  describe '#has_default_price?' do
+    subject { super().has_default_price? }
+    it { is_expected.to be_truthy }
+  end
+end

data/spec/support/concerns/payment_source.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+RSpec.shared_examples "a payment source" do
+  subject(:payment_source) { described_class.new }
+
+  describe 'attributes' do
+    it { is_expected.to respond_to(:imported) }
+    it { is_expected.to respond_to(:name) }
+  end
+
+  describe "#associations" do
+    it { is_expected.to respond_to(:payments) }
+    it { is_expected.to respond_to(:user) }
+  end
+
+  describe "#can_capture?" do
+    it "should be true if payment is pending" do
+      payment = mock_model(Spree::Payment, pending?: true, created_at: Time.current)
+      expect(payment_source.can_capture?(payment)).to be true
+    end
+
+    it "should be true if payment is checkout" do
+      payment = mock_model(Spree::Payment, pending?: false, checkout?: true, created_at: Time.current)
+      expect(payment_source.can_capture?(payment)).to be true
+    end
+  end
+
+  describe "#can_void?" do
+    it "should be true if payment is not void" do
+      payment = mock_model(Spree::Payment, failed?: false, void?: false)
+      expect(payment_source.can_void?(payment)).to be true
+    end
+  end
+
+  describe "#can_credit?" do
+    it "should be false if payment is not completed" do
+      payment = mock_model(Spree::Payment, completed?: false)
+      expect(payment_source.can_credit?(payment)).to be false
+    end
+
+    it "should be false when credit_allowed is zero" do
+      payment = mock_model(Spree::Payment, completed?: true, credit_allowed: 0, order: mock_model(Spree::Order, payment_state: 'credit_owed'))
+      expect(payment_source.can_credit?(payment)).to be false
+    end
+  end
+
+  describe "#first_name" do
+    before do
+      payment_source.name = "Ludwig van Beethoven"
+    end
+
+    it "extracts the first name" do
+      expect(payment_source.first_name).to eq "Ludwig"
+    end
+  end
+
+  describe "#last_name" do
+    before do
+      payment_source.name = "Ludwig van Beethoven"
+    end
+
+    it "extracts the last name" do
+      expect(payment_source.last_name).to eq "van Beethoven"
+    end
+  end
+end

data/spec/support/concerns/working_factories.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+RSpec.shared_examples_for 'a working factory' do
+  it "builds successfully" do
+    expect(build(factory)).to be_a(factory_class)
+  end
+
+  it "creates successfully" do
+    expect(create(factory)).to be_a(factory_class)
+  end
+
+  it "is creates a valid record" do
+    expect(create(factory)).to be_valid
+  end
+end

data/spec/support/dummy_ability.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require 'cancan'
+
+class DummyAbility
+  include CanCan::Ability
+end