solidus_core 2.10.1 → 2.11.2

data/spec/models/spree/preferences/scoped_store_spec.rb

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::Preferences::ScopedStore, type: :model do
-  let(:scoped_store){ described_class.new(prefix, suffix) }
-  subject{ scoped_store }
-  let(:prefix){ nil }
-  let(:suffix){ nil }
-
-  describe '#store' do
-    subject{ scoped_store.store }
-    it "uses the global preferences instance" do
-      is_expected.to be Spree::Preferences::Store.instance
-    end
-  end
-
-  context 'stubbed store' do
-    let(:store){ double(:store) }
-    before do
-      allow(scoped_store).to receive(:store).and_return(store)
-    end
-
-    context "with a prefix" do
-      let(:prefix){ 'my_class' }
-
-      it "can fetch" do
-        expect(store).to receive(:fetch).with('my_class/attr')
-        scoped_store.fetch('attr'){ 'default' }
-      end
-
-      it "can assign" do
-        expect(store).to receive(:[]=).with('my_class/attr', 'val')
-        scoped_store['attr'] = 'val'
-      end
-
-      it "can delete" do
-        expect(store).to receive(:delete).with('my_class/attr')
-        scoped_store.delete('attr')
-      end
-
-      context "and suffix" do
-        let(:suffix){ 123 }
-
-        it "can fetch" do
-          expect(store).to receive(:fetch).with('my_class/attr/123')
-          scoped_store.fetch('attr'){ 'default' }
-        end
-
-        it "can assign" do
-          expect(store).to receive(:[]=).with('my_class/attr/123', 'val')
-          scoped_store['attr'] = 'val'
-        end
-
-        it "can delete" do
-          expect(store).to receive(:delete).with('my_class/attr/123')
-          scoped_store.delete('attr')
-        end
-      end
-    end
-  end
-end

data/spec/models/spree/preferences/static_model_preferences_spec.rb

@@ -1,79 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-module Spree
-  RSpec.describe Preferences::StaticModelPreferences do
-    let(:preference_class) do
-      Class.new do
-        include Preferences::Preferable
-        preference :color, :string
-      end
-    end
-    let(:other_class){ Class.new }
-    let(:definitions){ subject.for_class(preference_class) }
-
-    it "is empty by default" do
-      expect(definitions).to be_empty
-    end
-
-    it "can store preferences" do
-      subject.add(preference_class, 'my_definition', {})
-      # just testing that it was added here
-      expect(definitions).to have_key('my_definition')
-    end
-
-    it "errors assigning invalid preferences" do
-      expect {
-        subject.add(preference_class, 'my_definition', { ice_cream: 'chocolate' })
-      }.to raise_error(/\APreference :ice_cream is not defined/)
-    end
-
-    context "with stored definitions" do
-      before do
-        subject.add(preference_class, 'light', { color: 'white' })
-        subject.add(preference_class, 'dark', { color: 'black' })
-        subject.add(preference_class, 'no_preference', {})
-      end
-
-      describe "complete definition" do
-        let(:definition){ definitions['dark'] }
-        it "can fetch value" do
-          expect(definition.fetch(:color)).to eq 'black'
-        end
-
-        it "can be converted to hash" do
-          expect(definition.to_hash).to eq({ color: 'black' })
-        end
-
-        it "ignores assignment" do
-          definition[:color] = 'maroon'
-          expect(definition.fetch(:color)).to eq 'black'
-          expect(definition.to_hash).to eq({ color: 'black' })
-        end
-      end
-
-      describe "empty definition" do
-        let(:definition){ definitions['no_preference'] }
-
-        it "uses fallback value" do
-          expect(definition.fetch(:color){ 'red' }).to eq 'red'
-        end
-
-        it "can be converted to hash" do
-          expect(definition.to_hash).to eq({})
-        end
-
-        it "ignores assignment" do
-          definition[:color] = 'maroon'
-          expect(definition.fetch(:color){ 'red' }).to eq 'red'
-          expect(definition.to_hash).to eq({})
-        end
-      end
-
-      it "is still empty for other classes" do
-        expect(subject.for_class(other_class)).to be_empty
-      end
-    end
-  end
-end

data/spec/models/spree/preferences/statically_configurable_spec.rb

@@ -1,67 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-require 'spree/preferences/statically_configurable'
-
-module Spree
-  RSpec.describe Preferences::StaticallyConfigurable do
-    let(:superklass) do
-      # Same interface activerecord's serialization would provide
-      Class.new do
-        attr_accessor :preferences
-        def initialize
-          @preferences = { color: 'blue' }
-        end
-
-        def [](key)
-          return @preferences if key == :preferences
-        end
-      end
-    end
-    let(:klass) do
-      Class.new(superklass) do
-        include Preferences::Preferable
-        include Preferences::StaticallyConfigurable
-
-        preference :color, :string
-
-        attr_accessor :preference_source
-      end
-    end
-
-    subject do
-      klass.new.tap do |item|
-        item.preference_source = preference_source
-      end
-    end
-
-    before do
-      Spree::Config.static_model_preferences.add(klass, 'credentials', color: 'red')
-    end
-
-    describe "available_preference_sources" do
-      it "should contain the defined preference sets" do
-        expect(klass.available_preference_sources).to eq ['credentials']
-      end
-    end
-
-    context "with no preference_source" do
-      let(:preference_source) { nil }
-      it "uses the persisted preference" do
-        expect(subject.preferred_color).to eq "blue"
-      end
-    end
-
-    context "with preference_source set" do
-      let(:preference_source) { 'credentials' }
-      it "uses the statically configured preference" do
-        expect(subject.preferred_color).to eq "red"
-      end
-
-      it "ignores assignment" do
-        subject.preferences = { color: 'orange' }
-        expect(subject.preferred_color).to eq "red"
-      end
-    end
-  end
-end

data/spec/models/spree/preferences/store_spec.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::Preferences::Store, type: :model do
-  before :each do
-    @store = Spree::Preferences::StoreInstance.new
-  end
-
-  it "sets and gets a key" do
-    @store.set :test, 1
-    expect(@store.exist?(:test)).to be true
-    expect(@store.get(:test)).to eq 1
-  end
-
-  it "can set and get false values when cache return nil" do
-    @store.set :test, false
-    expect(@store.get(:test)).to be false
-  end
-
-  it "will return db value when cache is emtpy and cache the db value" do
-    preference = Spree::Preference.where(key: 'test').first_or_initialize
-    preference.value = '123'
-    preference.save
-
-    Rails.cache.clear
-    expect(@store.get(:test)).to eq '123'
-    expect(Rails.cache.read(:test)).to eq '123'
-  end
-
-  it "should return and cache fallback value when supplied" do
-    Rails.cache.clear
-    expect(@store.get(:test){ false }).to be false
-    expect(Rails.cache.read(:test)).to be false
-  end
-
-  it "should return nil when key can't be found and fallback value is not supplied" do
-    expect(@store.get(:random_key){ nil }).to be_nil
-  end
-end

data/spec/models/spree/price_spec.rb

@@ -1,150 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::Price, type: :model do
-  describe 'searchable columns' do
-    subject { described_class.whitelisted_ransackable_attributes }
-    it 'allows searching by variant_id' do
-      expect(subject).to include("variant_id")
-    end
-  end
-
-  describe 'validations' do
-    let(:variant) { stub_model Spree::Variant }
-    subject { Spree::Price.new variant: variant, amount: amount }
-
-    context 'when the amount is nil' do
-      let(:amount) { nil }
-      it { is_expected.to be_valid }
-    end
-
-    context 'when the amount is less than 0' do
-      let(:amount) { -1 }
-
-      it 'has 1 error on amount' do
-        subject.valid?
-        expect(subject.errors[:amount].size).to eq(1)
-      end
-      it 'populates errors' do
-        subject.valid?
-        expect(subject.errors.messages[:amount].first).to eq 'must be greater than or equal to 0'
-      end
-    end
-
-    context 'when the amount is greater than maximum amount' do
-      let(:amount) { Spree::Price::MAXIMUM_AMOUNT + 1 }
-
-      it 'has 1 error on amount' do
-        subject.valid?
-        expect(subject.errors[:amount].size).to eq(1)
-      end
-      it 'populates errors' do
-        subject.valid?
-        expect(subject.errors.messages[:amount].first).to eq "must be less than or equal to #{Spree::Price::MAXIMUM_AMOUNT}"
-      end
-    end
-
-    context 'when the amount is between 0 and the maximum amount' do
-      let(:amount) { Spree::Price::MAXIMUM_AMOUNT }
-      it { is_expected.to be_valid }
-    end
-
-    context '#country_iso' do
-      subject(:price) { build(:price, country_iso: country_iso) }
-
-      context 'when country iso is nil' do
-        let(:country_iso) { nil }
-
-        it { is_expected.to be_valid }
-      end
-
-      context 'when country iso is an empty string' do
-        let(:country_iso) { "" }
-
-        it { is_expected.to be_valid }
-      end
-
-      context 'when country iso is a country code' do
-        let!(:country) { create(:country, iso: "DE") }
-        let(:country_iso) { "DE" }
-
-        it { is_expected.to be_valid }
-      end
-
-      context 'when country iso is not a country code' do
-        let(:country_iso) { "ZZ" }
-
-        it { is_expected.not_to be_valid }
-      end
-    end
-
-    describe "country_iso=" do
-      let(:price) { Spree::Price.new(country_iso: "de") }
-
-      it "assigns nil if passed nil" do
-        price.country_iso = nil
-        expect(price.country_iso).to be_nil
-      end
-    end
-
-    describe '#country' do
-      let!(:country) { create(:country, iso: "DE") }
-      let(:price) { create(:price, country_iso: "DE") }
-
-      it 'returns the country object' do
-        expect(price.country).to eq(country)
-      end
-    end
-  end
-
-  describe "#currency" do
-    let(:variant) { stub_model Spree::Variant }
-    subject { Spree::Price.new variant: variant, amount: 10, currency: currency }
-
-    describe "validation" do
-      context "with an invalid currency" do
-        let(:currency) { "XYZ" }
-
-        it { is_expected.to be_invalid }
-
-        it "has an understandable error message" do
-          subject.valid?
-          expect(subject.errors.messages[:currency].first).to eq("is not a valid currency code")
-        end
-      end
-
-      context "with a valid currency" do
-        let(:currency) { "USD" }
-
-        it { is_expected.to be_valid }
-      end
-    end
-  end
-
-  describe 'scopes' do
-    describe '.for_any_country' do
-      let(:country) { create(:country) }
-      let!(:fallback_price) { create(:price, country_iso: nil) }
-      let!(:country_price) { create(:price, country: country) }
-
-      subject { described_class.for_any_country }
-
-      it { is_expected.to include(fallback_price) }
-    end
-  end
-
-  describe 'net_amount' do
-    let(:country) { create(:country, iso: "DE") }
-    let(:zone) { create(:zone, countries: [country]) }
-    let!(:tax_rate) { create(:tax_rate, included_in_price: true, zone: zone, tax_categories: [variant.tax_category]) }
-
-    let(:variant) { create(:product).master }
-
-    let(:price) { variant.prices.create(amount: 20, country: country) }
-
-    subject { price.net_amount }
-
-    it { is_expected.to eq(BigDecimal(20) / 1.1) }
-  end
-end

data/spec/models/spree/product/scopes_spec.rb

@@ -1,164 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe "Product scopes", type: :model do
-  let!(:product) { create(:product) }
-
-  context "A product assigned to parent and child taxons" do
-    before do
-      @taxonomy = create(:taxonomy)
-      @root_taxon = @taxonomy.root
-
-      @parent_taxon = create(:taxon, name: 'Parent', taxonomy_id: @taxonomy.id, parent: @root_taxon)
-      @child_taxon = create(:taxon, name: 'Child 1', taxonomy_id: @taxonomy.id, parent: @parent_taxon)
-      @parent_taxon.reload # Need to reload for descendents to show up
-
-      product.taxons << @parent_taxon
-      product.taxons << @child_taxon
-    end
-
-    it "calling Product.in_taxon returns products in child taxons" do
-      product.taxons -= [@child_taxon]
-      expect(product.taxons.count).to eq(1)
-
-      expect(Spree::Product.in_taxon(@parent_taxon)).to include(product)
-    end
-
-    it "calling Product.in_taxon should not return duplicate records" do
-      expect(Spree::Product.in_taxon(@parent_taxon).to_a.size).to eq(1)
-    end
-
-    context 'orders products based on their ordering within the classifications' do
-      let(:other_taxon) { create(:taxon, products: [product]) }
-      let!(:product_2) { create(:product, taxons: [@child_taxon, other_taxon]) }
-
-      it 'by initial ordering' do
-        expect(Spree::Product.in_taxon(@child_taxon)).to eq([product, product_2])
-        expect(Spree::Product.in_taxon(other_taxon)).to eq([product, product_2])
-      end
-
-      it 'after ordering changed' do
-        [@child_taxon, other_taxon].each do |taxon|
-          Spree::Classification.find_by(taxon: taxon, product: product).insert_at(2)
-          expect(Spree::Product.in_taxon(taxon)).to eq([product_2, product])
-        end
-      end
-    end
-  end
-
-  context "property scopes" do
-    let(:name) { "A proper tee" }
-    let(:value) { "A proper value" }
-    let!(:property) { create(:property, name: name) }
-
-    before do
-      product.properties << property
-      product.product_properties.find_by(property: property).update_column(:value, value)
-    end
-
-    context "with_property" do
-      let(:with_property) { Spree::Product.method(:with_property) }
-      it "finds by a property's name" do
-        expect(with_property.call(name).count).to eq(1)
-      end
-
-      it "doesn't find any properties with an unknown name" do
-        expect(with_property.call("fake").count).to eq(0)
-      end
-
-      it "finds by a property" do
-        expect(with_property.call(property).count).to eq(1)
-      end
-
-      it "finds by an id" do
-        expect(with_property.call(property.id).count).to eq(1)
-      end
-
-      it "cannot find a property with an unknown id" do
-        expect(with_property.call(0).count).to eq(0)
-      end
-    end
-
-    context "with_property_value" do
-      let(:with_property_value) { Spree::Product.method(:with_property_value) }
-      it "finds by a property's name" do
-        expect(with_property_value.call(name, value).count).to eq(1)
-      end
-
-      it "cannot find by an unknown property's name" do
-        expect(with_property_value.call("fake", value).count).to eq(0)
-      end
-
-      it "cannot find with a name by an incorrect value" do
-        expect(with_property_value.call(name, "fake").count).to eq(0)
-      end
-
-      it "finds by a property" do
-        expect(with_property_value.call(property, value).count).to eq(1)
-      end
-
-      it "cannot find with a property by an incorrect value" do
-        expect(with_property_value.call(property, "fake").count).to eq(0)
-      end
-
-      it "finds by an id with a value" do
-        expect(with_property_value.call(property.id, value).count).to eq(1)
-      end
-
-      it "cannot find with an invalid id" do
-        expect(with_property_value.call(0, value).count).to eq(0)
-      end
-
-      it "cannot find with an invalid value" do
-        expect(with_property_value.call(property.id, "fake").count).to eq(0)
-      end
-    end
-  end
-
-  describe '.available' do
-    context "a product with past available_on" do
-      let!(:product) { create(:product, available_on: 1.day.ago) }
-
-      it "includes the product" do
-        expect(Spree::Product.available).to match_array([product])
-      end
-
-      context "with no master price" do
-        before { product.master.prices.delete_all }
-
-        it "doesn't include the product" do
-          expect(Spree::Product.available).to match_array([])
-        end
-      end
-
-      context "with soft-deleted master price" do
-        before { product.master.prices.discard_all }
-
-        it "doesn't include the product" do
-          expect(Spree::Product.available).to match_array([])
-        end
-      end
-
-      context "with multiple prices" do
-        let!(:second_price) { create(:price, variant: product.master) }
-
-        it "includes the product only once" do
-          expect(Spree::Product.available).to match_array([product])
-        end
-
-        it "has a count of 1" do
-          expect(Spree::Product.available.count).to eq(1)
-        end
-      end
-    end
-
-    context "a product with future available_on" do
-      let!(:product) { create(:product, available_on: 1.day.from_now) }
-
-      it "doesn't include the product" do
-        expect(Spree::Product.available).to match_array([])
-      end
-    end
-  end
-end