solidus_product_bundle 1.0.0

data/spec/models/spree/order_contents_spec.rb

@@ -0,0 +1,82 @@
+require "spec_helper"
+
+describe Spree::OrderContents do
+  describe "#add_to_line_item" do
+    context "given a variant which is an assembly" do
+      it "creates a PartLineItem for each part of the assembly" do
+        order = create(:order)
+        assembly = create(:product)
+        pieces = create_list(:product, 2)
+        pieces.each do |piece|
+          create(:assemblies_part, assembly: assembly, part: piece.master)
+        end
+
+        contents = described_class.new(order)
+
+        line_item = contents.add_to_line_item_with_parts(assembly.master, 1)
+
+        part_line_items = line_item.part_line_items
+
+        expect(part_line_items[0].line_item_id).to eq line_item.id
+        expect(part_line_items[0].variant_id).to eq pieces[0].master.id
+        expect(part_line_items[0].quantity).to eq 1
+        expect(part_line_items[1].line_item_id).to eq line_item.id
+        expect(part_line_items[1].variant_id).to eq pieces[1].master.id
+        expect(part_line_items[1].quantity).to eq 1
+      end
+    end
+
+    context "given parts of an assembly" do
+      it "creates a PartLineItem for each part" do
+        order = create(:order)
+        assembly = create(:product)
+
+        red_option = create(:option_value, presentation: "Red")
+        blue_option = create(:option_value, presentation: "Blue")
+
+        option_type = create(:option_type,
+                             presentation: "Color",
+                             name: "color",
+                             option_values: [
+                               red_option,
+                               blue_option
+                             ])
+
+        keychain = create(:product_in_stock)
+
+        shirt = create(:product_in_stock,
+                       option_types: [option_type],
+                       can_be_part: true)
+
+        create(:variant_in_stock, product: shirt, option_values: [red_option])
+        create(:variant_in_stock, product: shirt, option_values: [blue_option])
+
+        create(:assemblies_part,
+               assembly_id: assembly.id,
+               part_id: keychain.master.id)
+        create(:assemblies_part,
+               assembly_id: assembly.id,
+               part_id: shirt.master.id,
+               variant_selection_deferred: true)
+        assembly.reload
+
+        contents = Spree::OrderContents.new(order)
+
+        line_item = contents.add_to_line_item_with_parts(assembly.master, 1, {
+          "selected_variants" => {
+            "#{assembly.assemblies_parts.last.id}" => "#{shirt.variants.last.id}"
+          }
+        })
+
+        part_line_items = line_item.part_line_items
+
+        expect(part_line_items[0].line_item_id).to eq line_item.id
+        expect(part_line_items[0].variant_id).to eq keychain.master.id
+        expect(part_line_items[0].quantity).to eq 1
+        expect(part_line_items[1].line_item_id).to eq line_item.id
+        expect(part_line_items[1].variant_id).to eq shirt.variants.last.id
+        expect(part_line_items[1].quantity).to eq 1
+      end
+    end
+  end
+end

data/spec/models/spree/order_inventory_assembly_spec.rb

@@ -0,0 +1,321 @@
+require 'spec_helper'
+
+module Spree
+  describe OrderInventoryAssembly do
+    describe "#verify" do
+      context "when line item involves variants that are not user-selectable" do
+        context "when a shipment is provided" do
+          context "when the bundle is created" do
+            it "produces inventory units for each item in the bundle" do
+              shipment, line_item, variants = create_line_item_for_bundle(
+                parts: [{ count: 1 }, { count: 1 }, { count: 3 }]
+              )
+              inventory = OrderInventoryAssembly.new(line_item)
+              inventory.verify(shipment)
+
+              expect(inventory.inventory_units.count).to eq 5
+
+              expect(shipment.inventory_units_for(variants[0]).count).to eq 1
+              expect(shipment.inventory_units_for(variants[1]).count).to eq 1
+              expect(shipment.inventory_units_for(variants[2]).count).to eq 3
+            end
+          end
+
+          context "when the bundle quantity is increased" do
+            it "adds [difference in quantity] sets of inventory units" do
+              shipment, line_item, variants = create_line_item_for_bundle(
+                parts: [{ count: 1 }, { count: 1 }, { count: 3 }]
+              )
+              inventory = OrderInventoryAssembly.new(line_item)
+              inventory.verify(shipment)
+
+              expect(inventory.inventory_units.count).to eq 5
+
+              expect(shipment.inventory_units_for(variants[0]).count).to eq 1
+              expect(shipment.inventory_units_for(variants[1]).count).to eq 1
+              expect(shipment.inventory_units_for(variants[2]).count).to eq 3
+
+              line_item.update_column(:quantity, 2)
+              inventory.verify(shipment)
+
+              expect(inventory.inventory_units.count).to eq 10
+
+              expect(shipment.inventory_units_for(variants[0]).count).to eq 2
+              expect(shipment.inventory_units_for(variants[1]).count).to eq 2
+              expect(shipment.inventory_units_for(variants[2]).count).to eq 6
+            end
+          end
+
+          context "when the bundle quantity is decreased" do
+            it "removes [difference in quantity] sets of inventory units" do
+              shipment, line_item, variants = create_line_item_for_bundle(
+                line_item_quantity: 2,
+                parts: [{ count: 1 }, { count: 1 }, { count: 3 }]
+              )
+              inventory = OrderInventoryAssembly.new(line_item)
+              inventory.verify(shipment)
+
+              expect(inventory.inventory_units.count).to eq 10
+
+              expect(shipment.inventory_units_for(variants[0]).count).to eq 2
+              expect(shipment.inventory_units_for(variants[1]).count).to eq 2
+              expect(shipment.inventory_units_for(variants[2]).count).to eq 6
+
+              line_item.update_column(:quantity, 1)
+              inventory.verify(shipment)
+
+              expect(inventory.inventory_units.count).to eq 5
+
+              expect(shipment.inventory_units_for(variants[0]).count).to eq 1
+              expect(shipment.inventory_units_for(variants[1]).count).to eq 1
+              expect(shipment.inventory_units_for(variants[2]).count).to eq 3
+            end
+          end
+        end
+
+        context "when a shipment is not provided" do
+          context "when the bundle is created" do
+            it "produces inventory units for each item in the bundle" do
+              shipment, line_item, variants = create_line_item_for_bundle(
+                parts: [{ count: 1 }, { count: 1 }, { count: 3 }]
+              )
+              inventory = OrderInventoryAssembly.new(line_item)
+              inventory.verify
+
+              expect(inventory.inventory_units.count).to eq 5
+
+              expect(shipment.inventory_units_for(variants[0]).count).to eq 1
+              expect(shipment.inventory_units_for(variants[1]).count).to eq 1
+              expect(shipment.inventory_units_for(variants[2]).count).to eq 3
+            end
+          end
+
+          context "when the bundle quantity is increased" do
+            it "adds [difference in quantity] sets of inventory units" do
+              shipment, line_item, variants = create_line_item_for_bundle(
+                parts: [{ count: 1 }, { count: 1 }, { count: 3 }]
+              )
+              inventory = OrderInventoryAssembly.new(line_item)
+              inventory.verify
+
+              expect(inventory.inventory_units.count).to eq 5
+
+              expect(shipment.inventory_units_for(variants[0]).count).to eq 1
+              expect(shipment.inventory_units_for(variants[1]).count).to eq 1
+              expect(shipment.inventory_units_for(variants[2]).count).to eq 3
+
+              line_item.update_column(:quantity, 2)
+              inventory.verify
+
+              expect(inventory.inventory_units.count).to eq 10
+
+              expect(shipment.inventory_units_for(variants[0]).count).to eq 2
+              expect(shipment.inventory_units_for(variants[1]).count).to eq 2
+              expect(shipment.inventory_units_for(variants[2]).count).to eq 6
+            end
+          end
+
+          context "when the bundle quantity is decreased" do
+            it "removes [difference in quantity] sets of inventory units" do
+              shipment, line_item, variants = create_line_item_for_bundle(
+                line_item_quantity: 2,
+                parts: [{ count: 1 }, { count: 1 }, { count: 3 }]
+              )
+              inventory = OrderInventoryAssembly.new(line_item)
+              inventory.verify
+
+              expect(inventory.inventory_units.count).to eq 10
+
+              expect(shipment.inventory_units_for(variants[0]).count).to eq 2
+              expect(shipment.inventory_units_for(variants[1]).count).to eq 2
+              expect(shipment.inventory_units_for(variants[2]).count).to eq 6
+
+              line_item.update_column(:quantity, 1)
+              inventory.verify
+
+              expect(inventory.inventory_units.count).to eq 5
+
+              expect(shipment.inventory_units_for(variants[0]).count).to eq 1
+              expect(shipment.inventory_units_for(variants[1]).count).to eq 1
+              expect(shipment.inventory_units_for(variants[2]).count).to eq 3
+            end
+
+            context "when the bundle has shipped and unshipped shipments" do
+              it "removes the items from only the unshipped shipments" do
+                unshipped_shipment,
+                line_item,
+                variants = create_line_item_for_bundle(
+                  line_item_quantity: 2,
+                  parts: [{ count: 1 }, { count: 1 }, { count: 3 }]
+                )
+                shipped_shipment = create(:shipment, state: 'shipped')
+                InventoryUnit.all[0..2].each do |unit|
+                  unit.update_attribute(:shipment_id, shipped_shipment.id)
+                end
+
+                inventory = OrderInventoryAssembly.new(line_item)
+
+                line_item.update_column(:quantity, 1)
+                inventory.verify
+
+                expect(inventory.inventory_units.count).to eq 6
+
+                unshipped_units = unshipped_shipment.inventory_units
+                expect(unshipped_units.count).to eq 3
+                unshipped_units.each do |unit|
+                  expect(unit.variant).to eq variants[2]
+                end
+
+                shipped_units = shipped_shipment.inventory_units
+                expect(shipped_units.count).to eq 3
+                shipped_units[0..1].each do |unit|
+                  expect(unit.variant).to eq variants[0]
+                end
+                expect(shipped_units[2].variant).to eq variants[1]
+              end
+            end
+          end
+        end
+      end
+
+      context "when line item involves user-selectable variants" do
+        context "when a shipment is provided" do
+          context "when the bundle is created" do
+            it "produces inventory units for each item in the bundle" do
+              shipment, line_item, variants = create_line_item_for_bundle(
+                parts: [
+                  { count: 1 },
+                  { count: 1 },
+                  { count: 3, variant_selection_deferred: true }
+                ]
+              )
+
+              inventory = OrderInventoryAssembly.new(line_item)
+              inventory.verify(shipment)
+
+              expect(shipment.inventory_units_for(variants[0]).count).to eq 1
+              expect(shipment.inventory_units_for(variants[1]).count).to eq 1
+              expect(shipment.inventory_units_for(variants[2]).count).to eq 3
+            end
+          end
+
+          context "when the bundle quantity is increased" do
+            it "adds [difference in quantity] sets of inventory units" do
+              shipment, line_item, variants = create_line_item_for_bundle(
+                parts: [
+                  { count: 1 },
+                  { count: 1 },
+                  { count: 3, variant_selection_deferred: true }
+                ]
+              )
+
+              inventory = OrderInventoryAssembly.new(line_item)
+              inventory.verify(shipment)
+
+              expect(shipment.inventory_units_for(variants[0]).count).to eq 1
+              expect(shipment.inventory_units_for(variants[1]).count).to eq 1
+              expect(shipment.inventory_units_for(variants[2]).count).to eq 3
+
+              line_item.update_column(:quantity, 2)
+              inventory.verify(shipment)
+
+              expect(shipment.inventory_units_for(variants[0]).count).to eq 2
+              expect(shipment.inventory_units_for(variants[1]).count).to eq 2
+              expect(shipment.inventory_units_for(variants[2]).count).to eq 6
+            end
+          end
+
+          context "when the bundle quantity is decreased" do
+            it "removes [difference in quantity] sets of inventory units" do
+              shipment, line_item, variants = create_line_item_for_bundle(
+                line_item_quantity: 2,
+                parts: [
+                  { count: 1 },
+                  { count: 1 },
+                  { count: 3, variant_selection_deferred: true }
+                ]
+              )
+
+              inventory = OrderInventoryAssembly.new(line_item)
+              inventory.verify(shipment)
+
+              expect(shipment.inventory_units_for(variants[0]).count).to eq 2
+              expect(shipment.inventory_units_for(variants[1]).count).to eq 2
+              expect(shipment.inventory_units_for(variants[2]).count).to eq 6
+
+              line_item.update_column(:quantity, 1)
+              inventory.verify(shipment)
+
+              expect(shipment.inventory_units_for(variants[0]).count).to eq 1
+              expect(shipment.inventory_units_for(variants[1]).count).to eq 1
+              expect(shipment.inventory_units_for(variants[2]).count).to eq 3
+            end
+          end
+        end
+      end
+    end
+
+    def create_line_item_for_bundle(args)
+      parts = args.fetch(:parts)
+      line_item_quantity = args.fetch(:line_item_quantity, 1)
+      order = create(:order, completed_at: Time.now)
+      shipment = create(:shipment, order: order)
+      bundle = create(:product, name: "Bundle")
+
+      red_option = create(:option_value, presentation: "Red")
+      blue_option = create(:option_value, presentation: "Blue")
+
+      option_type = create(:option_type, presentation: "Color",
+                                         name: "color",
+                                         option_values: [
+                                           red_option,
+                                           blue_option
+                                         ])
+
+      variants = []
+      selected_variants = {}
+      parts.each do |part|
+        product_properties = { can_be_part: true }
+        if part[:variant_selection_deferred]
+          product_properties[:option_types] = [option_type]
+        end
+
+        product = create(:product_in_stock, product_properties)
+
+        assemblies_part_attributes = { assembly: bundle }.merge(part)
+
+        if part[:variant_selection_deferred]
+          create(:variant_in_stock, product: product,
+                                    option_values: [red_option])
+          variants << create(:variant_in_stock, product: product,
+                                                option_values: [blue_option])
+        else
+          variants << product.master
+        end
+
+        assemblies_part_attributes[:part] = product.master
+        create(:assemblies_part, assemblies_part_attributes)
+
+        if part[:variant_selection_deferred]
+          selected_variants = {
+            "selected_variants" => {
+              "#{bundle.assemblies_parts.last.id}" => "#{variants.last.id}"
+            }
+          }
+        end
+      end
+
+      bundle.reload
+
+      contents = Spree::OrderContents.new(order)
+      line_item = contents.add_to_line_item_with_parts(
+        bundle.master,
+        line_item_quantity,
+        selected_variants
+      )
+      line_item.reload
+
+      [shipment, line_item, variants]
+    end
+  end
+end

data/spec/models/spree/order_inventory_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+module Spree
+  describe OrderInventory do
+    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,40 @@
+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)
+
+      create(:assemblies_part,
+        assembly: @product,
+        part: @part1.master,
+        count: 1
+      )
+      create(:assemblies_part,
+        assembly: @product,
+        part: @part2.master,
+        count: 4
+      )
+      @product.reload
+    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
+  end
+end

data/spec/models/spree/shipment_spec.rb

@@ -0,0 +1,113 @@
+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' }
+
+
+      xit "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

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

@@ -0,0 +1,71 @@
+require 'spec_helper'
+
+module Spree
+  module Stock
+    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
+
+        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)
+          subject.validate(line_item)
+        end
+      end
+
+      context "line item has parts" 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(:parts) { (1..2).map { create(:variant) } }
+        before { product.parts << parts }
+
+        subject { described_class.new }
+
+        it 'should be valid when supply of all parts 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 supplies of all parts are insufficent' do
+          Stock::Quantifier.any_instance.stub(can_supply?: 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([])
+          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) }
+          expect(line_item).not_to receive(:errors)
+          subject.validate(line_item)
+        end
+      end
+    end
+  end
+end