solidus_core 2.10.0 → 2.11.0

data/spec/models/spree/permission_sets/user_management_spec.rb

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::PermissionSets::UserManagement do
-  let(:ability) { DummyAbility.new }
-
-  subject { ability }
-
-  context "when activated" do
-    before do
-      described_class.new(ability).activate!
-    end
-
-    it { is_expected.to be_able_to(:admin, Spree.user_class) }
-    it { is_expected.to be_able_to(:display, Spree.user_class) }
-    it { is_expected.to be_able_to(:create, Spree.user_class) }
-    it { is_expected.to be_able_to(:update, Spree.user_class) }
-    it { is_expected.to be_able_to(:save_in_address_book, Spree.user_class) }
-    it { is_expected.to be_able_to(:remove_from_address_book, Spree.user_class) }
-    it { is_expected.to be_able_to(:addresses, Spree.user_class) }
-    it { is_expected.to be_able_to(:orders, Spree.user_class) }
-    it { is_expected.to be_able_to(:items, Spree.user_class) }
-
-    context 'when the user does not have a role' do
-      let(:user) { create(:user) }
-      it { is_expected.to be_able_to(:update_email, user) }
-      it { is_expected.to be_able_to(:update_password, user) }
-    end
-
-    context 'when the user has a role' do
-      let(:user) { create(:user, spree_roles: [create(:role)]) }
-      it { is_expected.not_to be_able_to(:update_email, user) }
-      it { is_expected.not_to be_able_to(:update_password, user) }
-    end
-
-    it { is_expected.not_to be_able_to(:delete, Spree.user_class) }
-    it { is_expected.not_to be_able_to(:destroy, Spree.user_class) }
-
-    it { is_expected.to be_able_to(:manage, Spree::StoreCredit) }
-    it { is_expected.to be_able_to(:display, Spree::Role) }
-  end
-
-  context "when not activated" do
-    it { is_expected.not_to be_able_to(:manage, Spree.user_class) }
-    it { is_expected.not_to be_able_to(:delete, Spree.user_class) }
-    it { is_expected.not_to be_able_to(:destroy, Spree.user_class) }
-    it { is_expected.not_to be_able_to(:update, Spree.user_class) }
-    it { is_expected.not_to be_able_to(:save_in_address_book, Spree.user_class) }
-    it { is_expected.not_to be_able_to(:remove_from_address_book, Spree.user_class) }
-    it { is_expected.not_to be_able_to(:addresses, Spree.user_class) }
-    it { is_expected.not_to be_able_to(:orders, Spree.user_class) }
-    it { is_expected.not_to be_able_to(:items, Spree.user_class) }
-    it { is_expected.not_to be_able_to(:destroy, Spree.user_class) }
-    it { is_expected.not_to be_able_to(:manage, Spree::StoreCredit) }
-    it { is_expected.not_to be_able_to(:display, Spree::Role) }
-  end
-end

data/spec/models/spree/preference_spec.rb

@@ -1,79 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::Preference, type: :model do
-  it "should require a key" do
-    @preference = Spree::Preference.new
-    @preference.key = :test
-    @preference.value = true
-    expect(@preference).to be_valid
-  end
-
-  describe "type coversion for values" do
-    def round_trip_preference(key, value)
-      element = Spree::Preference.new
-      element.value = value
-      element.key = key
-      element.save
-
-      Spree::Preference.find_by(key: key)
-    end
-
-    it ":boolean" do
-      value = true
-      key = "boolean_key"
-      pref = round_trip_preference(key, value)
-      expect(pref.value).to eq value
-    end
-
-    it "false :boolean" do
-      value = false
-      key = "boolean_key"
-      pref = round_trip_preference(key, value)
-      expect(pref.value).to eq value
-    end
-
-    it ":integer" do
-      value = 10
-      key = "integer_key"
-      pref = round_trip_preference(key, value)
-      expect(pref.value).to eq value
-    end
-
-    it ":decimal" do
-      value = 1.5
-      key = "decimal_key"
-      pref = round_trip_preference(key, value)
-      expect(pref.value).to eq value
-    end
-
-    it ":string" do
-      value = "This is a string"
-      key = "string_key"
-      pref = round_trip_preference(key, value)
-      expect(pref.value).to eq value
-    end
-
-    it ":text" do
-      value = "This is a string stored as text"
-      key = "text_key"
-      pref = round_trip_preference(key, value)
-      expect(pref.value).to eq value
-    end
-
-    it ":password" do
-      value = "This is a password"
-      key = "password_key"
-      pref = round_trip_preference(key, value)
-      expect(pref.value).to eq value
-    end
-
-    it ":any" do
-      value = [1, 2]
-      key = "any_key"
-      pref = round_trip_preference(key, value)
-      expect(pref.value).to eq value
-    end
-  end
-end

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

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::Preferences::Configuration, type: :model do
-  before :all do
-    class AppConfig < Spree::Preferences::Configuration
-      preference :color, :string, default: :blue
-    end
-    @config = AppConfig.new
-  end
-
-  it "has named methods to access preferences" do
-    @config.color = 'orange'
-    expect(@config.color).to eq 'orange'
-  end
-
-  it "uses [ ] to access preferences" do
-    @config[:color] = 'red'
-    expect(@config[:color]).to eq 'red'
-  end
-
-  it "uses set/get to access preferences" do
-    @config.set(color: 'green')
-    expect(@config.get(:color)).to eq 'green'
-  end
-end

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

@@ -1,334 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::Preferences::Preferable, type: :model do
-  before :all do
-    class A
-      include Spree::Preferences::Preferable
-      attr_reader :id
-
-      def initialize
-        @id = rand(999)
-      end
-
-      def preferences
-        @preferences ||= default_preferences
-      end
-
-      preference :color, :string, default: 'green'
-    end
-
-    class B < A
-      preference :flavor, :string
-    end
-  end
-
-  before :each do
-    @a = A.new
-    @b = B.new
-  end
-
-  describe "preference definitions" do
-    it "parent should not see child definitions" do
-      expect(@a.has_preference?(:color)).to be true
-      expect(@a.has_preference?(:flavor)).not_to be true
-    end
-
-    it "child should have parent and own definitions" do
-      expect(@b.has_preference?(:color)).to be true
-      expect(@b.has_preference?(:flavor)).to be true
-    end
-
-    it "instances have defaults" do
-      expect(@a.preferred_color).to eq 'green'
-      expect(@b.preferred_color).to eq 'green'
-      expect(@b.preferred_flavor).to be_nil
-    end
-
-    it "can be asked if it has a preference definition" do
-      expect(@a.has_preference?(:color)).to be true
-      expect(@a.has_preference?(:bad)).to be false
-    end
-
-    it "can be asked and raises" do
-      expect {
-        @a.has_preference! :flavor
-      }.to raise_error(NoMethodError, "flavor preference not defined")
-    end
-
-    it "has a type" do
-      expect(@a.preferred_color_type).to eq :string
-      expect(@a.preference_type(:color)).to eq :string
-    end
-
-    it "has a default" do
-      expect(@a.preferred_color_default).to eq 'green'
-      expect(@a.preference_default(:color)).to eq 'green'
-    end
-
-    it "raises if not defined" do
-      expect {
-        @a.get_preference :flavor
-      }.to raise_error(NoMethodError, "flavor preference not defined")
-    end
-  end
-
-  describe "preference access" do
-    it "handles ghost methods for preferences" do
-      @a.preferred_color = 'blue'
-      expect(@a.preferred_color).to eq 'blue'
-    end
-
-    it "parent and child instances have their own prefs" do
-      @a.preferred_color = 'red'
-      @b.preferred_color = 'blue'
-
-      expect(@a.preferred_color).to eq 'red'
-      expect(@b.preferred_color).to eq 'blue'
-    end
-
-    it "raises when preference not defined" do
-      expect {
-        @a.set_preference(:bad, :bone)
-      }.to raise_exception(NoMethodError, "bad preference not defined")
-    end
-
-    it "builds a hash of preferences" do
-      @b.preferred_flavor = :strawberry
-      expect(@b.preferences[:flavor]).to eq 'strawberry'
-      expect(@b.preferences[:color]).to eq 'green' # default from A
-    end
-
-    it "builds a hash of preference defaults" do
-      expect(@b.default_preferences).to eq({
-        flavor: nil,
-        color: 'green'
-      })
-    end
-
-    describe '#admin_form_preference_names' do
-      subject do
-        ComplexPreferableClass.new.admin_form_preference_names
-      end
-
-      before do
-        class ComplexPreferableClass
-          include Spree::Preferences::Preferable
-          preference :name, :string
-          preference :password, :password
-          preference :mapping, :hash
-          preference :recipients, :array
-        end
-      end
-
-      it "returns an array of preference names excluding preferences not presentable as form field" do
-        is_expected.to contain_exactly(:name, :password)
-      end
-
-      context 'with overwritten allowed_admin_form_preference_types class method' do
-        subject do
-          ComplexOverwrittenPreferableClass.new.admin_form_preference_names
-        end
-
-        before do
-          class ComplexOverwrittenPreferableClass
-            include Spree::Preferences::Preferable
-            preference :name, :string
-            preference :password, :password
-            preference :mapping, :hash
-            preference :recipients, :array
-
-            def self.allowed_admin_form_preference_types
-              %i(string password hash array)
-            end
-          end
-        end
-
-        it 'returns these types instead' do
-          is_expected.to contain_exactly(:name, :password, :mapping, :recipients)
-        end
-      end
-    end
-
-    context "converts integer preferences to integer values" do
-      before do
-        A.preference :is_integer, :integer
-      end
-
-      it "with strings" do
-        @a.set_preference(:is_integer, '3')
-        expect(@a.preferences[:is_integer]).to eq(3)
-
-        @a.set_preference(:is_integer, '')
-        expect(@a.preferences[:is_integer]).to eq(0)
-      end
-
-      it 'does not convert if value is nil' do
-        @a.set_preference(:is_integer, nil)
-        expect(@a.preferences[:is_integer]).to be_nil
-      end
-    end
-
-    context "converts decimal preferences to BigDecimal values" do
-      before do
-        A.preference :if_decimal, :decimal
-      end
-
-      it "returns a BigDecimal" do
-        @a.set_preference(:if_decimal, 3.3)
-        expect(@a.preferences[:if_decimal].class).to eq(BigDecimal)
-      end
-
-      it "with strings" do
-        @a.set_preference(:if_decimal, '3.3')
-        expect(@a.preferences[:if_decimal]).to eq(3.3)
-
-        @a.set_preference(:if_decimal, '')
-        expect(@a.preferences[:if_decimal]).to eq(0.0)
-      end
-    end
-
-    context "converts boolean preferences to boolean values" do
-      before do
-        A.preference :is_boolean, :boolean, default: true
-      end
-
-      it "with strings" do
-        @a.set_preference(:is_boolean, '0')
-        expect(@a.preferences[:is_boolean]).to be false
-        @a.set_preference(:is_boolean, 'f')
-        expect(@a.preferences[:is_boolean]).to be false
-        @a.set_preference(:is_boolean, 't')
-        expect(@a.preferences[:is_boolean]).to be true
-      end
-
-      it "with integers" do
-        @a.set_preference(:is_boolean, 0)
-        expect(@a.preferences[:is_boolean]).to be false
-        @a.set_preference(:is_boolean, 1)
-        expect(@a.preferences[:is_boolean]).to be true
-      end
-
-      it "with an empty string" do
-        @a.set_preference(:is_boolean, '')
-        expect(@a.preferences[:is_boolean]).to be false
-      end
-
-      it "with an empty hash" do
-        @a.set_preference(:is_boolean, [])
-        expect(@a.preferences[:is_boolean]).to be false
-      end
-    end
-
-    context "converts array preferences to array values" do
-      before do
-        A.preference :is_array, :array, default: []
-      end
-
-      it "with arrays" do
-        @a.set_preference(:is_array, [])
-        expect(@a.preferences[:is_array]).to eq []
-      end
-    end
-
-    context "converts hash preferences to hash values" do
-      before do
-        A.preference :is_hash, :hash, default: {}
-      end
-
-      it "with hash" do
-        @a.set_preference(:is_hash, {})
-        expect(@a.preferences[:is_hash]).to be_is_a(Hash)
-      end
-
-      it "with hash and keys are integers" do
-        @a.set_preference(:is_hash, { 1 => 2, 3 => 4 })
-        expect(@a.preferences[:is_hash]).to eql({ 1 => 2, 3 => 4 })
-      end
-    end
-
-    context "converts any preferences to any values" do
-      before do
-        A.preference :product_ids, :any, default: []
-        A.preference :product_attributes, :any, default: {}
-      end
-
-      it "with array" do
-        expect(@a.preferences[:product_ids]).to eq([])
-        @a.set_preference(:product_ids, [1, 2])
-        expect(@a.preferences[:product_ids]).to eq([1, 2])
-      end
-
-      it "with hash" do
-        expect(@a.preferences[:product_attributes]).to eq({})
-        @a.set_preference(:product_attributes, { id: 1, name: 2 })
-        expect(@a.preferences[:product_attributes]).to eq({ id: 1, name: 2 })
-      end
-    end
-  end
-
-  describe "persisted preferables" do
-    before(:all) do
-      class CreatePrefTest < ActiveRecord::Migration[4.2]
-        def self.up
-          create_table :pref_tests do |item|
-            item.string :col
-            item.text :preferences
-          end
-        end
-
-        def self.down
-          drop_table :pref_tests
-        end
-      end
-
-      @migration_verbosity = ActiveRecord::Migration[4.2].verbose
-      ActiveRecord::Migration[4.2].verbose = false
-      CreatePrefTest.migrate(:up)
-
-      class PrefTest < Spree::Base
-        preference :pref_test_pref, :string, default: 'abc'
-        preference :pref_test_any, :any, default: []
-      end
-    end
-
-    after(:all) do
-      CreatePrefTest.migrate(:down)
-      ActiveRecord::Migration[4.2].verbose = @migration_verbosity
-    end
-
-    before(:each) do
-      @pt = PrefTest.create
-    end
-
-    describe "pending preferences for new activerecord objects" do
-      it "saves preferences after record is saved" do
-        pr = PrefTest.new
-        pr.set_preference(:pref_test_pref, 'XXX')
-        expect(pr.get_preference(:pref_test_pref)).to eq('XXX')
-        pr.save!
-        expect(pr.get_preference(:pref_test_pref)).to eq('XXX')
-      end
-
-      it "saves preferences for serialized object" do
-        pr = PrefTest.new
-        pr.set_preference(:pref_test_any, [1, 2])
-        expect(pr.get_preference(:pref_test_any)).to eq([1, 2])
-        pr.save!
-        expect(pr.get_preference(:pref_test_any)).to eq([1, 2])
-      end
-    end
-
-    it "clear preferences when record is deleted" do
-      @pt.save!
-      @pt.preferred_pref_test_pref = 'lmn'
-      @pt.save!
-      @pt.destroy
-      @pt1 = PrefTest.new(col: 'aaaa')
-      @pt1.id = @pt.id
-      @pt1.save!
-      expect(@pt1.get_preference(:pref_test_pref)).to eq('abc')
-    end
-  end
-end

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