solidus_product_assembly 1.0.0 → 1.1.0

data/spec/models/spree/line_item_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 module Spree
@@ -53,8 +55,8 @@ module Spree
       end
 
       it "verifies inventory units via OrderInventoryAssembly" do
-        OrderInventoryAssembly.should_receive(:new).with(line_item).and_return(inventory)
-        inventory.should_receive(:verify).with(line_item.target_shipment)
+        expect(OrderInventoryAssembly).to receive(:new).with(line_item).and_return(inventory)
+        expect(inventory).to receive(:verify).with(line_item.target_shipment)
         line_item.quantity = 2
         line_item.save
       end
@@ -62,8 +64,8 @@ module Spree
 
     context "updates regular line item" do
       it "verifies inventory units via OrderInventory" do
-        OrderInventory.should_receive(:new).with(line_item.order, line_item).and_return(inventory)
-        inventory.should_receive(:verify).with(line_item.target_shipment)
+        expect(OrderInventory).to receive(:new).with(line_item.order, line_item).and_return(inventory)
+        expect(inventory).to receive(:verify).with(line_item.target_shipment)
         line_item.quantity = 2
         line_item.save
       end

data/spec/models/spree/order_contents_spec.rb

@@ -1,7 +1,11 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 module Spree
   describe OrderContents do
+    subject { described_class.new(order) }
+
     let!(:store) { create :store }
     let(:order) { Order.create }
 
@@ -10,8 +14,6 @@ module Spree
 
     let(:bundle) { create(:product) }
 
-    subject { OrderContents.new(order) }
-
     before { bundle.parts.push [guitar, bass] }
 
     context "same variant within bundle and as regular product" do
@@ -30,9 +32,8 @@ module Spree
         end
 
         it "destroys accurate number of inventory units" do
-          expect {
-            subject.remove(guitar, 3)
-          }.to change { InventoryUnit.count }.by(-3)
+          expect { subject.remove(guitar, 3) }.
+          to change(InventoryUnit, :count).by(-3)
         end
       end
     end

data/spec/models/spree/order_inventory_assembly_spec.rb

@@ -1,7 +1,11 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 module Spree
   describe OrderInventoryAssembly do
+    subject { described_class.new(line_item) }
+
     let(:order) { create(:order_with_line_items) }
     let(:line_item) { order.line_items.first }
     let(:bundle) { line_item.product }
@@ -11,13 +15,11 @@ module Spree
       bundle.parts << [parts]
       bundle.set_part_count(parts.first, 3)
 
-      line_item.update_attributes!(quantity: 3)
+      line_item.update!(quantity: 3)
       order.reload.create_proposed_shipments
-      order.finalize! 
+      order.finalize!
     end
 
-    subject { OrderInventoryAssembly.new(line_item) }
-
     context "inventory units count" do
       it "calculates the proper value for the bundle" do
         expected_units_count = line_item.quantity * bundle.assemblies_parts.to_a.sum(&:count)
@@ -34,7 +36,7 @@ module Spree
         it "inserts new inventory units for every bundle part" do
           expected_units_count = original_units_count + bundle.assemblies_parts.to_a.sum(&:count)
           subject.verify
-          expect(OrderInventoryAssembly.new(line_item.reload).inventory_units.count).to eql(expected_units_count)
+          expect(described_class.new(line_item.reload).inventory_units.count).to eql(expected_units_count)
         end
       end
 
@@ -46,7 +48,7 @@ module Spree
           subject.verify
 
           # needs to reload so that inventory units are fetched from updates order.shipments
-          updated_units_count = OrderInventoryAssembly.new(line_item.reload).inventory_units.count
+          updated_units_count = described_class.new(line_item.reload).inventory_units.count
           expect(updated_units_count).to eql(expected_units_count)
         end
       end

data/spec/models/spree/order_inventory_spec.rb

@@ -1,12 +1,14 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 module Spree
   describe OrderInventory do
+    subject { described_class.new(order, order.line_items.first) }
+
     let!(:store) { create :store }
     let(:order) { Order.create }
 
-    subject { OrderInventory.new(order, order.line_items.first) }
-
     context "same variant within bundle and as regular product" do
       let(:contents) { OrderContents.new(order) }
       let(:guitar) { create(:variant) }
@@ -22,7 +24,9 @@ module Spree
       let!(:shipment) { order.create_proposed_shipments.first }
 
       context "completed order" do
-        before { order.touch :completed_at }
+        before do
+          order.touch :completed_at
+        end
 
         it "removes only units associated with provided line item" do
           expect {

data/spec/models/spree/product_spec.rb

@@ -1,35 +1,36 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Spree::Product do
-  before(:each) do
-    @product = FactoryGirl.create(:product, :name => "Foo Bar")
-    @master_variant = Spree::Variant.where(is_master: true).find_by_product_id(@product.id)
+  before do
+    @product = FactoryBot.create(:product, name: "Foo Bar")
+    @master_variant = Spree::Variant.where(is_master: true).find_by(product_id: @product.id)
   end
-    
+
   describe "Spree::Product Assembly" do
-    before(:each) do
+    before do
       @product = create(:product)
-      @part1 = create(:product, :can_be_part => true)
-      @part2 = create(:product, :can_be_part => true)
+      @part1 = create(:product, can_be_part: true)
+      @part2 = create(:product, can_be_part: true)
       @product.add_part @part1.master, 1
       @product.add_part @part2.master, 4
     end
-    
+
     it "is an assembly" do
-      @product.should be_assembly
+      expect(@product).to be_assembly
     end
-    
 
     it "cannot be part" do
-      @product.should be_assembly
+      expect(@product).to be_assembly
       @product.can_be_part = true
-      @product.valid?
-      @product.errors[:can_be_part].should == ["assembly can't be part"]
+      expect(@product).not_to be_valid
+      expect(@product.errors[:can_be_part]).to eq ["assembly can't be part"]
     end
 
     it 'changing part qty changes count on_hand' do
       @product.set_part_count(@part2.master, 2)
-      @product.count_of(@part2.master).should == 2
+      expect(@product.count_of(@part2.master)).to eq 2
     end
   end
 end

data/spec/models/spree/shipment_spec.rb

@@ -1,8 +1,11 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 module Spree
   describe Shipment do
     context "order has one product assembly" do
+      let!(:store) { create(:store) }
       let(:order) { Order.create }
       let(:bundle) { create(:variant) }
       let!(:parts) { (1..2).map { create(:variant) } }
@@ -11,7 +14,9 @@ module Spree
       let!(:line_item) { order.contents.add(bundle, 1) }
       let!(:shipment) { order.create_proposed_shipments.first }
 
-      before { order.update_column :state, 'complete' }
+      before do
+         order.update_column :state, 'complete'
+      end
 
       it "shipment item cost equals line item amount" do
         expect(shipment.item_cost).to eq line_item.amount
@@ -25,19 +30,21 @@ module Spree
 
       context "default" do
         let(:expected_variants) { order.variants - [bundle_variant] + bundle.parts }
+        before {shipments.first.save }
 
         it "separates variant purchased individually from the bundle one" do
-          expect(shipments.count).to eql 1
-          shipments.first.manifest.map(&:variant).sort.should == expected_variants.sort
+          expect(shipments.count).to be 1
+          expect(shipments.first.manifest.map(&:variant)).to match_array expected_variants
         end
       end
 
       context "line items manifest" do
         let(:expected_variants) { order.variants }
+        before { shipments.first.save }
 
         it "groups units by line_item only" do
-          expect(shipments.count).to eql 1
-          shipments.first.line_item_manifest.map(&:variant).sort.should == expected_variants.sort
+          expect(shipments.count).to be 1
+          expect(shipments.first.line_item_manifest.map(&:variant)).to match_array expected_variants
         end
       end
 
@@ -46,7 +53,7 @@ module Spree
         let(:shipment) { order.shipments.first }
 
         it "searches for line item if inventory unit doesn't have one" do
-          shipment.manifest.last.line_item.should_not be_blank
+          expect(shipment.manifest.last.line_item).not_to be_blank
         end
       end
     end
@@ -55,7 +62,7 @@ module Spree
       let(:line_item) { create(:line_item) }
       let(:variant) { line_item.variant }
       let(:order) { line_item.order }
-      let(:shipment) { create(:shipment) }
+      let(:shipment) { create(:shipment, order: order) }
 
       it "assigns variant, order and line_item" do
         unit = shipment.set_up_inventory('on_hand', variant, order, line_item)
@@ -74,9 +81,9 @@ module Spree
       let(:assembly_shirts) do
         5.times.map {
           create(:inventory_unit,
-                 variant: shirt,
-                 line_item: assembly_line_item,
-                 state: :on_hand)
+            variant: shirt,
+            line_item: assembly_line_item,
+            state: :on_hand)
         }
       end
 
@@ -85,9 +92,9 @@ module Spree
       let(:standalone_shirts) do
         2.times.map {
           create(:inventory_unit,
-                 variant: shirt,
-                 line_item: standalone_line_item,
-                 state: :on_hand)
+            variant: shirt,
+            line_item: standalone_line_item,
+            state: :on_hand)
         }
       end
 

data/spec/models/spree/stock/availability_validator_spec.rb

@@ -1,67 +1,56 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 module Spree
   module Stock
-    describe AvailabilityValidator, :type => :model do
+    describe AvailabilityValidator, type: :model do
       context "line item has no parts" do
-        let!(:line_item) { create(:line_item, quantity: 5) }
-        let!(:product) { line_item.product }
-
         subject { described_class.new }
 
-        it 'should be valid when supply is sufficient' do
-          Stock::Quantifier.any_instance.stub(can_supply?: true)
-          expect(line_item).not_to receive(:errors)
-          subject.validate(line_item)
-        end
-
-        it 'should be invalid when supply is insufficent' do
-          Stock::Quantifier.any_instance.stub(can_supply?: false)
-          expect(line_item.errors).to receive(:[]).exactly(1).times.with(:quantity).and_return([])
-          subject.validate(line_item)
-        end
+        let!(:line_item) { create(:line_item, quantity: 5) }
+        let!(:product) { line_item.product }
 
-        it 'should consider existing inventory_units sufficient' do
-          Stock::Quantifier.stub(can_supply?: false)
-          line_item.inventory_units.stub(where: [double] * 5)
-          expect(line_item).not_to receive(:errors)
+        it 'delegates to the original Solidus implementation' do
+          expect(subject).to receive(:is_valid?).with(line_item)
           subject.validate(line_item)
         end
       end
 
       context "line item has parts" do
+        subject { described_class.new }
+
         let!(:order) { create(:order_with_line_items) }
         let(:line_item) { order.line_items.first }
         let(:product) { line_item.product }
         let(:variant) { line_item.variant }
         let(:parts) { (1..2).map { create(:variant) } }
-        before { product.parts << parts }
 
-        subject { described_class.new }
+        before { product.parts << parts }
 
-        it 'should be valid when supply of all parts is sufficient' do
-          Stock::Quantifier.any_instance.stub(can_supply?: true)
+        it 'is valid when supply of all parts is sufficient' do
+          allow_any_instance_of(Stock::Quantifier).to receive(:can_supply?).and_return(true)
           expect(line_item).not_to receive(:errors)
           subject.validate(line_item)
         end
 
-        it 'should be invalid when supplies of all parts are insufficent' do
-          Stock::Quantifier.any_instance.stub(can_supply?: false)
+        it 'is invalid when supplies of all parts are insufficent' do
+          allow_any_instance_of(Stock::Quantifier).to receive(:can_supply?).and_return(false)
           expect(line_item.errors).to receive(:[]).exactly(line_item.parts.size).times.with(:quantity).and_return([])
           subject.validate(line_item)
         end
 
-        it 'should be invalid when supply of 1 part is insufficient' do
-          Stock::Quantifier.any_instance.stub(can_supply?: false)
-          inventory_units = [double(variant: line_item.parts.first)] * 5
-          line_item.parts.first.stub(inventory_units: inventory_units)
-          expect(line_item.inventory_units).to receive(:where).and_return(inventory_units, [])
-          expect(line_item.errors).to receive(:[]).exactly(1).times.with(:quantity).and_return([])
+        it 'is invalid when supply of 1 part is insufficient' do
+          allow_any_instance_of(Stock::Quantifier).to receive(:can_supply?).and_return(false)
+          create_list(:inventory_unit, 5, line_item: line_item, variant: line_item.parts.first, order: order, shipment: order.shipments.first)
+          expect(line_item.errors).to receive(:[]).once.with(:quantity).and_return([])
           subject.validate(line_item)
         end
 
-        it 'should be valid when supply of each part is sufficient' do
-          line_item.parts.each { |part| part.stub(inventory_units: [double(variant: part)] * 5) }
+        it 'is valid when supply of each part is sufficient' do
+          line_item.parts.each do |part|
+            allow(part).to receive(:inventory_units).and_return([double(variant: part)] * 5)
+          end
           expect(line_item).not_to receive(:errors)
           subject.validate(line_item)
         end

data/spec/models/spree/stock/coordinator_spec.rb

@@ -1,15 +1,23 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 # Spree::Stock::Coordinator was refactored in Solidus to hide keep private
 # information about packages, we have to be sneaky to reach inside
 def inventory_units(coordinator)
-  coordinator.shipments.flat_map { |s| s.inventory_units }
+  coordinator.shipments.flat_map(&:inventory_units)
 end
 
 module Spree
   module Stock
-    describe Coordinator do
-      subject { Coordinator.new(order) }
+    coordinator_class =
+      if Spree.solidus_gem_version < Gem::Version.new('2.4.x')
+        Coordinator
+      else
+        SimpleCoordinator
+      end
+    describe coordinator_class do
+      subject { described_class.new(order) }
 
       context "order shares variant as individual and within bundle" do
         include_context "product is ordered as individual and within a bundle"

data/spec/models/spree/stock/inventory_unit_builder_spec.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 module Spree
   module Stock
-    describe InventoryUnitBuilder, :type => :model do
-      subject { InventoryUnitBuilder.new(order) }
-      
+    describe InventoryUnitBuilder, type: :model do
+      subject { described_class.new(order) }
+
       context "order shares variant as individual and within bundle" do
         include_context "product is ordered as individual and within a bundle" do
           let(:bundle_item_quantity) { order.find_line_item_by_variant(bundle_variant).quantity }
@@ -24,10 +26,6 @@ module Spree
             it "builds the inventory units as pending" do
               expect(subject.units.map(&:pending).uniq).to eq [true]
             end
-
-            it "associates the inventory units to the order" do
-              expect(subject.units.map(&:order).uniq).to eq [order]
-            end
           end
         end
       end

data/spec/models/spree/variant_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 module Spree
@@ -20,7 +22,7 @@ module Spree
 
       context "variant no assembly" do
         it "returns both products" do
-          variant.assemblies_for([mug, tshirt]).should be_empty
+          expect(variant.assemblies_for([mug, tshirt])).to be_empty
         end
       end
     end

data/spec/spec_helper.rb

@@ -1,57 +1,28 @@
-require 'simplecov'
-SimpleCov.start 'rails'
+# frozen_string_literal: true
 
-ENV["RAILS_ENV"] = "test"
+# Configure Rails Environment
+ENV['RAILS_ENV'] ||= 'test'
 
-require File.expand_path("../dummy/config/environment.rb",  __FILE__)
+# Run Coverage report
+require 'solidus_dev_support/rspec/coverage'
 
-require 'rspec/rails'
-require 'ffaker'
-require 'database_cleaner'
+require File.expand_path('dummy/config/environment.rb', __dir__)
 
-require 'capybara/rspec'
-require 'capybara/rails'
-require 'capybara/poltergeist'
-Capybara.javascript_driver = :poltergeist
+# Requires factories and other useful helpers defined in spree_core.
+require 'solidus_dev_support/rspec/feature_helper'
 
-Dir[File.join(File.dirname(__FILE__), "support/**/*.rb")].each {|f| require f }
+# This will load Solidus Core factories right before the ones defined in
+# lib/extension_name/testing_support/factories/*_factory.rb or
+# lib/extension_name/testing_support/factories.rb
+SolidusDevSupport::TestingSupport::Factories.load_for(SolidusProductAssembly::Engine)
 
-require 'spree/testing_support/factories'
-require 'spree/testing_support/url_helpers'
-require 'spree/testing_support/authorization_helpers'
-require 'spree/testing_support/capybara_ext'
-
-# ActiveRecord::Base.logger = Logger.new(STDOUT)
+# Requires supporting ruby files with custom matchers and macros, etc,
+# in spec/support/ and its subdirectories.
+Dir[File.join(File.dirname(__FILE__), 'support/**/*.rb')].each { |f| require f }
 
 RSpec.configure do |config|
-  config.mock_with :rspec
+  config.infer_spec_type_from_file_location!
   config.use_transactional_fixtures = false
-
-  config.before :suite do
-    Capybara.match = :prefer_exact
-    DatabaseCleaner.clean_with :truncation
-  end
-
-  config.before(:each) do
-    Rails.cache.clear
-
-    if RSpec.current_example.metadata[:js]
-      DatabaseCleaner.strategy = :truncation
-    else
-      DatabaseCleaner.strategy = :transaction
-    end
-
-    DatabaseCleaner.start
-  end
-
-  config.after(:each) do
-    # Ensure js requests finish processing before advancing to the next test
-    wait_for_ajax if RSpec.current_example.metadata[:js]
-
-    DatabaseCleaner.clean
-  end
-
-  config.include FactoryGirl::Syntax::Methods
-  config.include Spree::TestingSupport::UrlHelpers
-  config.example_status_persistence_file_path = "./spec/examples.txt"
 end
+
+Capybara.javascript_driver = (ENV['CAPYBARA_DRIVER'] || :selenium_headless).to_sym

data/spec/support/shared_contexts/order_with_bundle.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 shared_context "product is ordered as individual and within a bundle" do
   let(:order) { create(:order_with_line_items) }
   let(:parts) { (1..3).map { create(:variant) } }