solidus_core 1.0.7 → 1.1.0.beta1

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

@@ -1,132 +0,0 @@
-require 'spec_helper'
-
-describe Spree::PermissionSets::RestrictedTransferManagement do
-  let(:ability) { Spree::Ability.new(user) }
-
-  subject { ability }
-
-  let!(:source_location) { create :stock_location }
-  let!(:destination_location) { create :stock_location }
-
-  # This has the side effect of creating a stock item for each stock location above,
-  # which is what we actually want.
-  let!(:variant) { create :variant }
-
-  let(:source_stock_item) { source_location.stock_items.first }
-  let(:destination_stock_item) { destination_location.stock_items.first }
-
-  let(:transfer_with_source) { create :stock_transfer, source_location: source_location }
-  let(:transfer_with_destination) { create :stock_transfer, source_location: destination_location  }
-  let(:transfer_with_source_and_destination) do
-    create :stock_transfer, source_location: source_location, destination_location: destination_location
-  end
-
-  let(:transfer_amount) { 1 }
-  let(:source_transfer_item) do
-    transfer_with_source.transfer_items.create(variant: variant, expected_quantity: transfer_amount)
-  end
-  let(:destination_transfer_item) do
-    transfer_with_destination.transfer_items.create(variant: variant, expected_quantity: transfer_amount)
-  end
-  let(:source_and_destination_transfer_item) do
-    transfer_with_source_and_destination.transfer_items.create(variant: variant, expected_quantity: transfer_amount)
-  end
-
-  context "when activated" do
-    let(:user) { create :user, stock_locations: stock_locations }
-    let(:stock_locations) {[]}
-
-    before do
-      user.stock_locations = stock_locations
-      # When creating transfer_items for a stock transfer, stock items must have a count on hand
-      # with an amount that would allow a transfer item to pass validations (meaning the count on hand has to be equal
-      # to the expected_quantity for the transfer)
-      variant.stock_items.update_all count_on_hand: transfer_amount
-
-      described_class.new(ability).activate!
-    end
-
-    it { is_expected.to be_able_to(:display, Spree::StockItem) }
-    it { is_expected.to be_able_to(:display, Spree::StockTransfer) }
-    it { is_expected.to be_able_to(:admin, Spree::StockItem) }
-    it { is_expected.to be_able_to(:admin, Spree::StockTransfer) }
-
-    context "when the user is associated with one of the locations" do
-      let(:stock_locations) {[source_location]}
-
-      it { is_expected.to be_able_to(:update, source_stock_item) }
-      it { is_expected.not_to be_able_to(:update, destination_stock_item) }
-
-      it { is_expected.to be_able_to(:transfer, source_location) }
-      it { is_expected.not_to be_able_to(:transfer, destination_location) }
-
-      it { is_expected.to be_able_to(:manage, transfer_with_source) }
-      it { is_expected.not_to be_able_to(:manage, transfer_with_destination) }
-      it { is_expected.not_to be_able_to(:manage, transfer_with_source_and_destination) }
-
-      it { is_expected.to be_able_to(:manage, source_transfer_item) }
-      it { is_expected.not_to be_able_to(:manage, destination_transfer_item) }
-      it { is_expected.not_to be_able_to(:manage, source_and_destination_transfer_item) }
-    end
-
-
-    context "when the user is associated with both locations" do
-      let(:stock_locations) {[source_location, destination_location]}
-
-      it { is_expected.to be_able_to(:update, source_stock_item) }
-      it { is_expected.to be_able_to(:update, destination_stock_item) }
-
-      it { is_expected.to be_able_to(:transfer, source_location) }
-      it { is_expected.to be_able_to(:transfer, destination_location) }
-
-      it { is_expected.to be_able_to(:manage, transfer_with_source) }
-      it { is_expected.to be_able_to(:manage, transfer_with_destination) }
-      it { is_expected.to be_able_to(:manage, transfer_with_source_and_destination) }
-
-      it { is_expected.to be_able_to(:manage, source_transfer_item) }
-      it { is_expected.to be_able_to(:manage, destination_transfer_item) }
-      it { is_expected.to be_able_to(:manage, source_and_destination_transfer_item) }
-    end
-
-    context "when the user is associated with neither location" do
-      let(:stock_locations) {[]}
-
-      it { is_expected.not_to be_able_to(:update, source_stock_item) }
-      it { is_expected.not_to be_able_to(:update, destination_stock_item) }
-
-      it { is_expected.not_to be_able_to(:transfer, source_location) }
-      it { is_expected.not_to be_able_to(:transfer, destination_location) }
-
-      it { is_expected.not_to be_able_to(:manage, transfer_with_source) }
-      it { is_expected.not_to be_able_to(:manage, transfer_with_destination) }
-      it { is_expected.not_to be_able_to(:manage, transfer_with_source_and_destination) }
-
-      it { is_expected.not_to be_able_to(:manage, source_transfer_item) }
-      it { is_expected.not_to be_able_to(:manage, destination_transfer_item) }
-      it { is_expected.not_to be_able_to(:manage, source_and_destination_transfer_item) }
-    end
-  end
-
-  context "when not activated" do
-    let(:user) { create :user }
-
-    it { is_expected.not_to be_able_to(:display, Spree::StockTransfer) }
-    it { is_expected.not_to be_able_to(:admin, Spree::StockItem) }
-    it { is_expected.not_to be_able_to(:admin, Spree::StockTransfer) }
-
-    it { is_expected.not_to be_able_to(:update, source_stock_item) }
-    it { is_expected.not_to be_able_to(:update, destination_stock_item) }
-
-    it { is_expected.not_to be_able_to(:transfer, source_location) }
-    it { is_expected.not_to be_able_to(:transfer, destination_location) }
-
-    it { is_expected.not_to be_able_to(:manage, transfer_with_source) }
-    it { is_expected.not_to be_able_to(:manage, transfer_with_destination) }
-    it { is_expected.not_to be_able_to(:manage, transfer_with_source_and_destination) }
-
-    it { is_expected.not_to be_able_to(:manage, source_transfer_item) }
-    it { is_expected.not_to be_able_to(:manage, destination_transfer_item) }
-    it { is_expected.not_to be_able_to(:manage, source_and_destination_transfer_item) }
-  end
-end
-

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

@@ -1,26 +0,0 @@
-require 'spec_helper'
-
-describe Spree::PermissionSets::StockDisplay 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(:display, Spree::StockItem) }
-    it { is_expected.to be_able_to(:display, Spree::StockTransfer) }
-    it { is_expected.to be_able_to(:admin, Spree::StockItem) }
-    it { is_expected.to be_able_to(:admin, Spree::StockTransfer) }
-  end
-
-  context "when not activated" do
-    it { is_expected.not_to be_able_to(:display, Spree::StockItem) }
-    it { is_expected.not_to be_able_to(:display, Spree::StockTransfer) }
-    it { is_expected.not_to be_able_to(:admin, Spree::StockItem) }
-    it { is_expected.not_to be_able_to(:admin, Spree::StockTransfer) }
-  end
-end
-

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

@@ -1,24 +0,0 @@
-require 'spec_helper'
-
-describe Spree::PermissionSets::StockManagement 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(:manage, Spree::StockItem) }
-    it { is_expected.to be_able_to(:manage, Spree::StockTransfer) }
-    it { is_expected.to be_able_to(:manage, Spree::TransferItem) }
-  end
-
-  context "when not activated" do
-    it { is_expected.not_to be_able_to(:manage, Spree::StockItem) }
-    it { is_expected.not_to be_able_to(:manage, Spree::StockTransfer) }
-    it { is_expected.not_to be_able_to(:manage, Spree::TransferItem) }
-  end
-end
-

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

@@ -1,36 +0,0 @@
-require 'spec_helper'
-
-describe Spree::PermissionSets::UserDisplay 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(:display, Spree.user_class) }
-    it { is_expected.to be_able_to(:admin, Spree.user_class) }
-    it { is_expected.to be_able_to(:edit, 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) }
-    it { is_expected.to be_able_to(:display, Spree::StoreCredit) }
-    it { is_expected.to be_able_to(:admin, 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(:display, Spree.user_class) }
-    it { is_expected.not_to be_able_to(:admin, Spree.user_class) }
-    it { is_expected.not_to be_able_to(:edit, 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(:display, Spree::StoreCredit) }
-    it { is_expected.not_to be_able_to(:admin, Spree::StoreCredit) }
-    it { is_expected.not_to be_able_to(:display, Spree::Role) }
-  end
-end
-

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

@@ -1,28 +0,0 @@
-require 'spec_helper'
-
-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(: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.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(:manage, Spree::StoreCredit) }
-    it { is_expected.not_to be_able_to(:display, Spree::Role) }
-  end
-end
-

data/spec/models/spree/preference_spec.rb

@@ -1,80 +0,0 @@
-require 'spec_helper'
-
-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)
-      p = Spree::Preference.new
-      p.value = value
-      p.key = key
-      p.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,30 +0,0 @@
-require 'spec_helper'
-
-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,294 +0,0 @@
-require 'spec_helper'
-
-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
-
-    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
-
-    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
-
-      it "with ancestor of a hash" do
-        ancestor_of_hash = ActionController::Parameters.new({ key: :value })
-        @a.set_preference(:is_hash, ancestor_of_hash)
-        expect(@a.preferences[:is_hash]).to eql({"key" => :value})
-      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
-        def self.up
-          create_table :pref_tests do |t|
-            t.string :col
-            t.text :preferences
-          end
-        end
-
-        def self.down
-          drop_table :pref_tests
-        end
-      end
-
-      @migration_verbosity = ActiveRecord::Migration.verbose
-      ActiveRecord::Migration.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.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