solidus_core_devise_token_auth 2.8.0.alpha.0

data/spec/models/spree/price_spec.rb

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

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

data/spec/models/spree/product_duplicator_spec.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+module Spree
+  RSpec.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', __dir__)) }
+    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

data/spec/models/spree/product_filter_spec.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+require 'spree/core/product_filters'
+
+RSpec.describe 'product filters', type: :model do
+  # Regression test for https://github.com/spree/spree/issues/1709
+  context 'finds products filtered by brand' do
+    let(:product) { create(:product) }
+    before do
+      Spree::Property.create!(name: "brand", presentation: "brand")
+      product.set_property("brand", "Nike")
+    end
+
+    it "does not attempt to call value method on Arel::Table" do
+      Spree::Core::ProductFilters.brand_filter
+    end
+
+    it "can find products in the 'Nike' brand" do
+      expect(Spree::Product.brand_any("Nike")).to include(product)
+    end
+    it "sorts products without brand specified" do
+      product.set_property("brand", "Nike")
+      create(:product).set_property("brand", nil)
+      Spree::Core::ProductFilters.brand_filter[:labels]
+    end
+  end
+end

data/spec/models/spree/product_property_spec.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe Spree::ProductProperty, type: :model do
+  context "touching" do
+    let(:product_property) { create(:product_property) }
+    let(:product) { product_property.product }
+
+    before do
+      product.update_columns(updated_at: 1.day.ago)
+    end
+
+    subject { product_property.touch }
+
+    it "touches the product" do
+      expect { subject }.to change { product.reload.updated_at }
+    end
+  end
+end