solidus_core 1.0.2 → 1.0.3

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

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+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{ is_expected.to be Spree::Preferences::Store.instance }
+  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

@@ -0,0 +1,78 @@
+require 'spec_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

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+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
+      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 |o|
+        o.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

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+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

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe Spree::Price, :type => :model do
+  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' do
+        expect(subject.error_on(: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 999,999.99' do
+      let(:amount) { 1_000_000 }
+
+      it 'has 1 error_on' do
+        expect(subject.error_on(: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 999999.99'
+      end
+    end
+
+    context 'when the amount is between 0 and 999,999.99' do
+      let(:amount) { 100 }
+      it { is_expected.to be_valid }
+    end
+  end
+end

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

@@ -0,0 +1,148 @@
+require 'spec_helper'
+
+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.count).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.(name).count).to eq(1)
+      end
+
+      it "doesn't find any properties with an unknown name" do
+        expect(with_property.("fake").count).to eq(0)
+      end
+
+      it "finds by a property" do
+        expect(with_property.(property).count).to eq(1)
+      end
+
+      it "finds by an id" do
+        expect(with_property.(property.id).count).to eq(1)
+      end
+
+      it "cannot find a property with an unknown id" do
+        expect(with_property.(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.(name, value).count).to eq(1)
+      end
+
+      it "cannot find by an unknown property's name" do
+        expect(with_property_value.("fake", value).count).to eq(0)
+      end
+
+      it "cannot find with a name by an incorrect value" do
+        expect(with_property_value.(name, "fake").count).to eq(0)
+      end
+
+      it "finds by a property" do
+        expect(with_property_value.(property, value).count).to eq(1)
+      end
+
+      it "cannot find with a property by an incorrect value" do
+        expect(with_property_value.(property, "fake").count).to eq(0)
+      end
+
+      it "finds by an id with a value" do
+        expect(with_property_value.(property.id, value).count).to eq(1)
+      end
+
+      it "cannot find with an invalid id" do
+        expect(with_property_value.(0, value).count).to eq(0)
+      end
+
+      it "cannot find with an invalid value" do
+        expect(with_property_value.(property.id, "fake").count).to eq(0)
+      end
+    end
+  end
+
+  context '#add_simple_scopes' do
+    let(:simple_scopes) { [:ascend_by_updated_at, :descend_by_name] }
+
+    before do
+      Spree::Product.add_simple_scopes(simple_scopes)
+    end
+
+    context 'define scope' do
+      context 'ascend_by_updated_at' do
+        context 'on class' do
+          it { expect(Spree::Product.ascend_by_updated_at.to_sql).to eq Spree::Product.order("#{Spree::Product.quoted_table_name}.updated_at ASC").to_sql }
+        end
+
+        context 'on ActiveRecord::Relation' do
+          it { expect(Spree::Product.limit(2).ascend_by_updated_at.to_sql).to eq Spree::Product.limit(2).order("#{Spree::Product.quoted_table_name}.updated_at ASC").to_sql }
+          it { expect(Spree::Product.limit(2).ascend_by_updated_at.to_sql).to eq Spree::Product.ascend_by_updated_at.limit(2).to_sql }
+        end
+      end
+
+      context 'descend_by_name' do
+        context 'on class' do
+          it { expect(Spree::Product.descend_by_name.to_sql).to eq Spree::Product.order("#{Spree::Product.quoted_table_name}.name DESC").to_sql }
+        end
+
+        context 'on ActiveRecord::Relation' do
+          it { expect(Spree::Product.limit(2).descend_by_name.to_sql).to eq Spree::Product.limit(2).order("#{Spree::Product.quoted_table_name}.name DESC").to_sql }
+          it { expect(Spree::Product.limit(2).descend_by_name.to_sql).to eq Spree::Product.descend_by_name.limit(2).to_sql }
+        end
+      end
+    end
+  end
+end

data/spec/models/spree/product_duplicator_spec.rb

@@ -0,0 +1,103 @@
+require 'spec_helper'
+
+module Spree
+
+  describe Spree::ProductDuplicator, :type => :model do
+
+    let(:product) { create(:product, properties: [create(:property, name: "MyProperty")])}
+    let!(:duplicator) { Spree::ProductDuplicator.new(product)}
+
+    let(:image) { File.open(File.expand_path('../../../fixtures/thinking-cat.jpg', __FILE__)) }
+    let(:params) { {:viewable_id => product.master.id, :viewable_type => 'Spree::Variant', :attachment => image, :alt => "position 1", :position => 1} }
+
+    before do
+      Spree::Image.create(params)
+    end
+
+    it "will duplicate the product" do
+      expect{duplicator.duplicate}.to change{Spree::Product.count}.by(1)
+    end
+
+    context 'when image duplication enabled' do
+
+      it "will duplicate the product images" do
+        expect{duplicator.duplicate}.to change{Spree::Image.count}.by(1)
+      end
+
+    end
+
+    context 'when image duplication disabled' do
+
+      let!(:duplicator) { Spree::ProductDuplicator.new(product, false) }
+
+      it "will not duplicate the product images" do
+        expect{duplicator.duplicate}.to change{Spree::Image.count}.by(0)
+      end
+
+    end
+
+    context 'image duplication default' do
+
+      context 'when default is set to true' do
+
+        it 'clones images if no flag passed to initializer' do
+          expect{duplicator.duplicate}.to change{Spree::Image.count}.by(1)
+        end
+
+      end
+
+      context 'when default is set to false' do
+
+        before do
+          ProductDuplicator.clone_images_default = false
+        end
+
+        after do
+          ProductDuplicator.clone_images_default = true
+        end
+
+        it 'does not clone images if no flag passed to initializer' do
+          expect{ProductDuplicator.new(product).duplicate}.to change{Spree::Image.count}.by(0)
+        end
+
+      end
+
+    end
+
+    context "product attributes" do
+      let!(:new_product) {duplicator.duplicate}
+
+      it "will set an unique name" do
+        expect(new_product.name).to eql "COPY OF #{product.name}"
+      end
+
+      it "will set an unique sku" do
+        expect(new_product.sku).to include "COPY OF SKU"
+      end
+
+      it "copied the properties" do
+        expect(new_product.product_properties.count).to be 1
+        expect(new_product.product_properties.first.property.name).to eql "MyProperty"
+      end
+    end
+
+    context "with variants" do
+      let(:option_type) { create(:option_type, name: "MyOptionType")}
+      let(:option_value1) { create(:option_value, name: "OptionValue1", option_type: option_type)}
+      let(:option_value2) { create(:option_value, name: "OptionValue2", option_type: option_type)}
+
+      let!(:variant1) { create(:variant, product: product, option_values: [option_value1]) }
+      let!(:variant2) { create(:variant, product: product, option_values: [option_value2]) }
+
+      it  "will duplciate the variants" do
+        # will change the count by 3, since there will be a master variant as well
+        expect{duplicator.duplicate}.to change{Spree::Variant.count}.by(3)
+      end
+
+      it "will not duplicate the option values" do
+        expect{duplicator.duplicate}.to change{Spree::OptionValue.count}.by(0)
+      end
+
+    end
+  end
+end