solidus_product_assembly 1.0.0

data/spec/features/checkout_spec.rb

@@ -0,0 +1,92 @@
+require 'spec_helper'
+
+describe "Checkout", type: :feature do
+  let!(:store) { create :store, default: true }
+  let!(:country) { create(:country, :name => "United States", :states_required => true) }
+  let!(:state) { create(:state, :name => "Ohio", :country => country) }
+  let!(:shipping_method) { create(:shipping_method) }
+  let!(:stock_location) { create(:stock_location) }
+  let!(:payment_method) { create(:check_payment_method) }
+  let!(:zone) { create(:zone) }
+
+  let(:product) { create(:product, :name => "RoR Mug") }
+  let(:variant) { create(:variant) }
+
+  stub_authorization!
+
+  before { product.parts << variant << create(:variant) }
+
+  shared_context "purchases product with part included" do
+    before do
+      add_product_to_cart
+      click_button "Checkout"
+
+      fill_in "order_email", :with => "ryan@spreecommerce.com"
+      click_button "Continue"
+      fill_in_address
+
+      click_button "Save and Continue"
+      expect(current_path).to eql(spree.checkout_state_path("delivery"))
+      page.should have_content(variant.product.name)
+
+      click_button "Save and Continue"
+      expect(current_path).to eql(spree.checkout_state_path("payment"))
+
+      click_button "Save and Continue"
+      expect(current_path).to eq spree.checkout_state_path('confirm')
+      page.should have_content(variant.product.name)
+
+      click_button "Place Order"
+      page.should have_content('Your order has been processed successfully')
+    end
+  end
+
+  context "backend order shipments UI", js: true do
+
+    context "ordering only the product assembly" do
+      include_context "purchases product with part included"
+
+      it "views parts bundled as well" do
+        visit spree.admin_orders_path
+        click_on Spree::Order.last.number
+
+        page.should have_content(variant.product.name)
+      end
+    end
+
+    context "ordering assembly and the part as individual sale" do
+      before do
+        visit spree.root_path
+        click_link variant.product.name
+        click_button "add-to-cart-button"
+      end
+      include_context "purchases product with part included"
+
+      it "views parts bundled and not" do
+        visit spree.admin_orders_path
+        click_on Spree::Order.last.number
+
+        page.should have_content(variant.product.name)
+      end
+    end
+
+  end
+
+
+  def fill_in_address
+    address = "order_bill_address_attributes"
+    fill_in "#{address}_firstname", :with => "Ryan"
+    fill_in "#{address}_lastname", :with => "Bigg"
+    fill_in "#{address}_address1", :with => "143 Swan Street"
+    fill_in "#{address}_city", :with => "Richmond"
+    select "Ohio", :from => "#{address}_state_id"
+    fill_in "#{address}_zipcode", :with => "12345"
+    fill_in "#{address}_phone", :with => "(555) 555-5555"
+  end
+
+  def add_product_to_cart
+    visit spree.root_path
+    click_link product.name
+    click_button "add-to-cart-button"
+  end
+end

data/spec/models/spree/assemblies_part_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+module Spree
+  describe AssembliesPart do
+    let(:product) { create(:product) }
+    let(:variant) { create(:variant) }
+
+    before do
+      product.parts.push variant
+    end
+
+    context "get" do
+      it "brings part by product and variant id" do
+        subject.class.get(product.id, variant.id).part.should == variant
+      end
+    end
+  end
+end

data/spec/models/spree/inventory_unit_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+module Spree
+  describe InventoryUnit do
+    let!(:order) { create(:order_with_line_items) }
+    let(:line_item) { order.line_items.first }
+    let(:product) { line_item.product }
+
+    subject { InventoryUnit.create(line_item: line_item, variant: line_item.variant, order: order) }
+
+    context 'if the unit is not part of an assembly' do      
+      it 'it will return the percentage of a line item' do
+        expect(subject.percentage_of_line_item).to eql(BigDecimal.new(1))
+      end
+    end
+
+    context 'if part of an assembly' do
+      let(:parts) { (1..2).map { create(:variant) } }
+
+      before do
+        product.parts << parts
+        order.create_proposed_shipments
+        order.finalize!
+      end
+
+      it 'it will return the percentage of a line item' do
+        subject.line_item = line_item
+      	expect(subject.percentage_of_line_item).to eql(BigDecimal.new(0.5, 2))
+      end
+    end
+  end
+end

data/spec/models/spree/line_item_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+module Spree
+  describe LineItem do
+    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(:inventory) { double('order_inventory') }
+
+    context "bundle parts stock" do
+      let(:parts) { (1..2).map { create(:variant) } }
+
+      before { product.parts << parts }
+
+      context "one of them not in stock" do
+        before do
+          part = product.parts.first
+          part.stock_items.update_all backorderable: false
+
+          expect(part).not_to be_in_stock
+        end
+
+        it "doesn't save line item quantity" do
+          order.contents.add(variant, 10)
+          expect { order.contents.advance }.to raise_error Spree::Order::InsufficientStock
+        end
+      end
+
+      context "in stock" do
+        before do
+          parts.each do |part|
+            part.stock_items.first.set_count_on_hand(10)
+          end
+          expect(parts[0]).to be_in_stock
+          expect(parts[1]).to be_in_stock
+        end
+
+        it "saves line item quantity" do
+          line_item = order.contents.add(variant, 10)
+          expect(line_item).to be_valid
+        end
+      end
+    end
+
+    context "updates bundle product line item" do
+      let(:parts) { (1..2).map { create(:variant) } }
+
+      before do
+        product.parts << parts
+        order.create_proposed_shipments
+        order.finalize!
+      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)
+        line_item.quantity = 2
+        line_item.save
+      end
+    end
+
+    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)
+        line_item.quantity = 2
+        line_item.save
+      end
+    end
+  end
+end

data/spec/models/spree/order_contents_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+module Spree
+  describe OrderContents do
+    let!(:store) { create :store }
+    let(:order) { Order.create }
+
+    let(:guitar) { create(:variant) }
+    let(:bass) { create(:variant) }
+
+    let(:bundle) { create(:product) }
+
+    subject { OrderContents.new(order) }
+
+    before { bundle.parts.push [guitar, bass] }
+
+    context "same variant within bundle and as regular product" do
+      let!(:guitar_item) { subject.add(guitar, 3) }
+      let!(:bundle_item) { subject.add(bundle.master, 5) }
+
+      it "destroys the variant as regular product only" do
+        subject.remove(guitar, 3)
+        expect(order.reload.line_items.to_a).to eq [bundle_item]
+      end
+
+      context "completed order" do
+        before do
+          order.create_proposed_shipments
+          order.touch :completed_at
+        end
+
+        it "destroys accurate number of inventory units" do
+          expect {
+            subject.remove(guitar, 3)
+          }.to change { InventoryUnit.count }.by(-3)
+        end
+      end
+    end
+  end
+end

data/spec/models/spree/order_inventory_assembly_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+module Spree
+  describe OrderInventoryAssembly do
+    let(:order) { create(:order_with_line_items) }
+    let(:line_item) { order.line_items.first }
+    let(:bundle) { line_item.product }
+    let(:parts) { (1..3).map { create(:variant) } }
+
+    before do
+      bundle.parts << [parts]
+      bundle.set_part_count(parts.first, 3)
+
+      line_item.update_attributes!(quantity: 3)
+      order.reload.create_proposed_shipments
+      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)
+        expect(subject.inventory_units.count).to eql(expected_units_count)
+      end
+    end
+
+    context "verify line item units" do
+      let!(:original_units_count) { subject.inventory_units.count }
+
+      context "quantity increases" do
+        before { subject.line_item.quantity += 1 }
+
+        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)
+        end
+      end
+
+      context "quantity decreases" do
+        before { subject.line_item.quantity -= 1 }
+
+        it "remove inventory units for every bundle part" do
+          expected_units_count = original_units_count - bundle.assemblies_parts.to_a.sum(&:count)
+          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
+          expect(updated_units_count).to eql(expected_units_count)
+        end
+      end
+    end
+  end
+end

data/spec/models/spree/order_inventory_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+module Spree
+  describe OrderInventory do
+    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) }
+      let(:bass) { create(:variant) }
+
+      let(:bundle) { create(:product) }
+
+      before { bundle.parts.push [guitar, bass] }
+
+      let!(:bundle_item) { contents.add(bundle.master, 5) }
+      let!(:guitar_item) { contents.add(guitar, 3) }
+
+      let!(:shipment) { order.create_proposed_shipments.first }
+
+      context "completed order" do
+        before { order.touch :completed_at }
+
+        it "removes only units associated with provided line item" do
+          expect {
+            subject.send(:remove_from_shipment, shipment, 5)
+          }.not_to change { bundle_item.inventory_units.count }
+        end
+      end
+    end
+  end
+end

data/spec/models/spree/product_spec.rb

@@ -0,0 +1,35 @@
+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)
+  end
+    
+  describe "Spree::Product Assembly" do
+    before(:each) do
+      @product = create(:product)
+      @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
+    end
+    
+
+    it "cannot be part" do
+      @product.should be_assembly
+      @product.can_be_part = true
+      @product.valid?
+      @product.errors[:can_be_part].should == ["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
+    end
+  end
+end

data/spec/models/spree/shipment_spec.rb

@@ -0,0 +1,112 @@
+require 'spec_helper'
+
+module Spree
+  describe Shipment do
+    context "order has one product assembly" do
+      let(:order) { Order.create }
+      let(:bundle) { create(:variant) }
+      let!(:parts) { (1..2).map { create(:variant) } }
+      let!(:bundle_parts) { bundle.product.parts << parts }
+
+      let!(:line_item) { order.contents.add(bundle, 1) }
+      let!(:shipment) { order.create_proposed_shipments.first }
+
+      before { order.update_column :state, 'complete' }
+
+      it "shipment item cost equals line item amount" do
+        expect(shipment.item_cost).to eq line_item.amount
+      end
+    end
+
+    context "manifests" do
+      include_context "product is ordered as individual and within a bundle"
+
+      let(:shipments) { order.create_proposed_shipments }
+
+      context "default" do
+        let(:expected_variants) { order.variants - [bundle_variant] + bundle.parts }
+
+        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
+        end
+      end
+
+      context "line items manifest" do
+        let(:expected_variants) { order.variants }
+
+        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
+        end
+      end
+
+      context "units are not associated with a line item" do
+        let(:order) { create(:shipped_order) }
+        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
+        end
+      end
+    end
+
+    context "set up new inventory units" do
+      let(:line_item) { create(:line_item) }
+      let(:variant) { line_item.variant }
+      let(:order) { line_item.order }
+      let(:shipment) { create(:shipment) }
+
+      it "assigns variant, order and line_item" do
+        unit = shipment.set_up_inventory('on_hand', variant, order, line_item)
+
+        expect(unit.line_item).to eq line_item
+        expect(unit.variant).to eq variant
+        expect(unit.order).to eq order
+        expect(unit.state).to eq 'on_hand'
+      end
+    end
+
+    context "unit states for variant sold as part of an assembly and separately" do
+      let(:assembly_line_item) { create(:line_item) }
+      let(:shirt) { create(:variant) }
+
+      let(:assembly_shirts) do
+        5.times.map {
+          create(:inventory_unit,
+                 variant: shirt,
+                 line_item: assembly_line_item,
+                 state: :on_hand)
+        }
+      end
+
+      let(:standalone_line_item) { create(:line_item, variant: shirt) }
+
+      let(:standalone_shirts) do
+        2.times.map {
+          create(:inventory_unit,
+                 variant: shirt,
+                 line_item: standalone_line_item,
+                 state: :on_hand)
+        }
+      end
+
+      let(:shipment) { create(:shipment) }
+
+      before do
+        shipment.inventory_units << assembly_shirts
+        shipment.inventory_units << standalone_shirts
+      end
+
+      it "set states numbers properly for all items" do
+        shipment.manifest.each do |item|
+          if item.line_item.id == standalone_line_item.id
+            expect(item.states["on_hand"]).to eq standalone_shirts.count
+          else
+            expect(item.states["on_hand"]).to eq assembly_shirts.count
+          end
+        end
+      end
+    end
+  end
+end