solidus_product_bundle 1.0.0

data/spec/features/checkout_spec.rb

@@ -0,0 +1,249 @@
+require 'spec_helper'
+
+describe "Checkout", type: :feature do
+  let!(:country) do
+    create(:country, name: "United States", states_required: true)
+  end
+  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.push 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"
+      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 eql(spree.order_path(Spree::Order.last))
+      page.should have_content(variant.product.name)
+    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
+
+  context "when a part allows User to select any variant", js: true do
+    it "marks non-deferred parts as out of stock" do
+      rock = create(:product_in_stock, name: "Rock",
+                                       can_be_part: true)
+      stick = create(:product, name: "Stick",
+                               can_be_part: true)
+
+      stick.stock_items.first.update_attribute(:backorderable, false)
+
+      bundle = create(:product, name: "Bundle")
+
+      create(:assemblies_part, assembly_id: bundle.id,
+                               part_id: rock.master.id)
+      create(:assemblies_part, assembly_id: bundle.id,
+                               part_id: stick.master.id)
+      bundle.reload
+
+      visit spree.root_path
+      click_link bundle.name
+
+      within("#products") do
+        expect(page).to have_content("Out of Stock")
+      end
+    end
+
+    it "marks non-deferred parts as backorderable" do
+      rock = create(:product_in_stock, name: "Rock",
+                                       can_be_part: true)
+      stick = create(:product, name: "Stick",
+                               can_be_part: true)
+
+      stick.stock_items.first.update_attribute(:backorderable, true)
+
+      bundle = create(:product, name: "Bundle")
+
+      create(:assemblies_part, assembly_id: bundle.id,
+                               part_id: rock.master.id)
+      create(:assemblies_part, assembly_id: bundle.id,
+                               part_id: stick.master.id)
+
+      bundle.reload
+
+      visit spree.root_path
+      click_link bundle.name
+
+      within("#products") do
+        expect(page).to have_content("Backorderable")
+      end
+    end
+
+    it "does not allow selection of variants that are out of stock" do
+      red_option = create(:option_value, presentation: "Red")
+      blue_option = create(:option_value, presentation: "Blue")
+      green_option = create(:option_value, presentation: "Green")
+
+      option_type = create(:option_type,
+                           presentation: "Color",
+                           name: "color",
+                           option_values: [
+                             red_option,
+                             blue_option,
+                             green_option
+                           ])
+
+      shirt = create(:product_in_stock,
+                     name: "Shirt",
+                     option_types: [option_type],
+                     can_be_part: true)
+
+      red = create(:variant_in_stock,
+                   product: shirt,
+                   sku: "PART-RED",
+                   option_values: [red_option])
+      blue = create(:variant,
+                    product: shirt,
+                    sku: "PART-BLUE",
+                    option_values: [blue_option])
+      green = create(:variant,
+                     product: shirt,
+                     sku: "PART-GREEN",
+                     option_values: [green_option])
+
+      blue.stock_items.first.update_attribute(:backorderable, true)
+      green.stock_items.first.update_attribute(:backorderable, false)
+
+      bundle = create(:product, name: "Bundle")
+
+      create(:assemblies_part, assembly_id: bundle.id,
+                               part_id: shirt.master.id,
+                               variant_selection_deferred: true)
+      bundle.reload
+
+      visit spree.root_path
+      click_link bundle.name
+
+      first_selectable = bundle.assemblies_parts.first.id
+
+      within("#options_selected_variants_#{first_selectable}") do
+        expect(page).to have_css("option[value='#{red.id}']")
+        expect(page).to have_css("option[value='#{blue.id}']")
+        expect(page).to(
+          have_css("option[value='#{green.id}'][disabled='disabled']")
+        )
+      end
+    end
+
+    it "shows the part the User selected at all stages of checkout" do
+      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])
+
+      shirt = create(:product_in_stock,
+                     name: "Shirt",
+                     option_types: [option_type],
+                     can_be_part: true)
+
+      create(:variant_in_stock,
+             product: shirt,
+             sku: "PART-RED",
+             option_values: [red_option])
+      create(:variant_in_stock,
+             product: shirt,
+             sku: "PART-BLUE",
+             option_values: [blue_option])
+
+      bundle = create(:product, name: "Bundle")
+
+      create(:assemblies_part,
+             assembly_id: bundle.id,
+             part_id: shirt.master.id,
+             variant_selection_deferred: true)
+      bundle.reload
+
+      visit spree.root_path
+      click_link bundle.name
+
+      select "Color: Blue", from: "Variant"
+      click_button "add-to-cart-button"
+
+      click_button "Checkout"
+
+      fill_in "order_email", with: "ryan@spreecommerce.com"
+      fill_in_address
+
+      click_button "Save and Continue"
+      expect(current_path).to eql(spree.checkout_state_path("delivery"))
+      expect(page).to have_content(shirt.name)
+      expect(page).to have_content("Color: Blue")
+
+      click_button "Save and Continue"
+      expect(current_path).to eql(spree.checkout_state_path("payment"))
+
+      click_button "Save and Continue"
+      expect(current_path).to eql(spree.order_path(Spree::Order.last))
+      expect(page).to have_content(shirt.name)
+      expect(page).to have_content("Color: Blue")
+    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/features/updating_items_in_cart_spec.rb

@@ -0,0 +1,199 @@
+require "spec_helper"
+
+describe "Updating items in the cart", type: :feature do
+  context "when updating a bundle's quantity" do
+    context "when none of the bundle items are packs or have options" do
+      specify "the quantities are multiplied by the bundle's new quantity" do
+        bundle = create(:product_in_stock, name: "Bundle", sku: "BUNDLE")
+
+        keychain = create(:product_in_stock, name: "Keychain",
+                                             sku: "KEYCHAIN",
+                                             can_be_part: true)
+        shirt = create(:product_in_stock, name: "Shirt",
+                                          sku: "SHIRT",
+                                          can_be_part: true)
+
+        add_part_to_bundle(bundle, keychain.master)
+        add_part_to_bundle(bundle, shirt.master)
+
+        visit spree.product_path(bundle)
+
+        click_button "add-to-cart-button"
+
+        within("#cart-detail") do
+          find("input").set 2
+        end
+
+        click_button "update-button"
+
+        within("#cart-detail tbody tr:first-child") do
+          expect(page).to have_content(bundle.name)
+          expect(page).to have_css("input[value='2']")
+          expect(page).to have_content("(2) Keychain (KEYCHAIN)")
+          expect(page).to have_content("(2) Shirt (SHIRT)")
+        end
+      end
+    end
+
+    context "when one of the variants is a pack" do
+      specify "the pack quantity is multiplied by the bundle's new quantity" do
+        bundle = create(:product_in_stock, name: "Bundle", sku: "BUNDLE")
+
+        keychain = create(:product_in_stock, name: "Keychain",
+                                             sku: "KEYCHAIN",
+                                             can_be_part: true)
+
+        _shirt, shirts_by_size = create_bundle_product_with_options(
+          name: "Shirt",
+          sku: "SHIRT",
+          option_type: "Size",
+          option_values: ["Small"]
+        )
+
+        add_part_to_bundle(bundle, keychain.master, count: 2)
+        add_part_to_bundle(bundle, shirts_by_size["small"])
+
+        visit spree.product_path(bundle)
+
+        click_button "add-to-cart-button"
+
+        within("#cart-detail") do
+          find("input").set 2
+        end
+
+        click_button "update-button"
+
+        within("#cart-detail tbody tr:first-child") do
+          expect(page).to have_content(bundle.name)
+          expect(page).to have_css("input[value='2']")
+          expect(page).to have_content("(4) Keychain (KEYCHAIN)")
+          expect(page).to have_content("(2) Shirt (Size: Small) (SHIRT-SMALL)")
+        end
+      end
+    end
+
+    context "when a bundle items has a variant (that is not user-selectable)" do
+      specify "the variant quantity is multiplied by the new bundle quantity" do
+        bundle = create(:product_in_stock, name: "Bundle", sku: "BUNDLE")
+
+        keychain = create(:product_in_stock, name: "Keychain",
+                                             sku: "KEYCHAIN",
+                                             can_be_part: true)
+
+        _shirt, shirts_by_size = create_bundle_product_with_options(
+          name: "Shirt",
+          sku: "SHIRT",
+          option_type: "Size",
+          option_values: ["Small"]
+        )
+
+        add_part_to_bundle(bundle, keychain.master)
+        add_part_to_bundle(bundle, shirts_by_size["small"])
+
+        visit spree.product_path(bundle)
+
+        click_button "add-to-cart-button"
+
+        within("#cart-detail") do
+          find("input").set 2
+        end
+
+        click_button "update-button"
+
+        within("#cart-detail tbody tr:first-child") do
+          expect(page).to have_content(bundle.name)
+          expect(page).to have_css("input[value='2']")
+          expect(page).to have_content("(2) Keychain (KEYCHAIN)")
+          expect(page).to have_content("(2) Shirt (Size: Small) (SHIRT-SMALL)")
+        end
+      end
+    end
+
+    context "when one of the bundle items has a user-selectable variant" do
+      specify "the variant quantity is multiplied by the new bundle quantity" do
+        bundle = create(:product_in_stock, name: "Bundle", sku: "BUNDLE")
+
+        keychain = create(:product_in_stock, name: "Keychain",
+                                             sku: "KEYCHAIN",
+                                             can_be_part: true)
+
+        shirt, _shirts_by_size = create_bundle_product_with_options(
+          name: "Shirt",
+          sku: "SHIRT",
+          option_type: "Size",
+          option_values: ["Small", "Medium"]
+        )
+
+        add_part_to_bundle(bundle, keychain.master, count: 1)
+        add_part_to_bundle(
+          bundle,
+          shirt.master,
+          variant_selection_deferred: true
+        )
+
+        visit spree.product_path(bundle)
+
+        select "Size: Medium", from: "Variant"
+
+        click_button "add-to-cart-button"
+
+        within("#cart-detail") do
+          find("input").set 2
+        end
+
+        click_button "update-button"
+
+        within("#cart-detail tbody tr:first-child") do
+          expect(page).to have_content(bundle.name)
+          expect(page).to have_css("input[value='2']")
+          expect(page).to have_content("(2) Keychain (KEYCHAIN)")
+          expect(page).to(
+            have_content("(2) Shirt (Size: Medium) (SHIRT-MEDIUM)")
+          )
+        end
+      end
+    end
+  end
+
+  def create_bundle_product_with_options(args)
+    option_type_presentation = args.fetch(:option_type)
+    option_value_presentations = args.fetch(:option_values)
+    option_values = option_value_presentations.map do |presentation|
+      create(:option_value, presentation: presentation)
+    end
+    option_type = create(:option_type,
+      presentation: option_type_presentation,
+      name: option_type_presentation.downcase,
+      option_values: option_values)
+    product_attributes = args.slice(:name, :sku).merge(
+      option_types: [option_type],
+      can_be_part: true
+    )
+    product = create(:product, product_attributes)
+
+    variants = variants_by_option(product, option_values)
+
+    [product, variants]
+  end
+
+  def variants_by_option(product, option_values)
+    option_values.each_with_object({}) do |value, hash|
+      hash[value.presentation.downcase] = create(
+        :variant_in_stock,
+        product: product,
+        sku: "#{product.sku}-#{value.presentation.upcase}",
+        option_values: [value]
+      )
+    end
+  end
+
+  def add_part_to_bundle(bundle, variant, options = {})
+    attributes = options.reverse_merge(
+      assembly_id: bundle.id,
+      part_id: variant.id,
+    )
+    create(:assemblies_part, attributes).tap do |_part|
+      bundle.reload
+    end
+  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/assign_part_to_bundle_form_spec.rb

@@ -0,0 +1,51 @@
+require "spec_helper"
+
+module Spree
+  describe AssignPartToBundleForm do
+    describe "#submit" do
+      context "when given a quantity < 1" do
+        it "is invalid" do
+          product = build(:product)
+          part_options = { count: -1 }
+
+          command = AssignPartToBundleForm.new(product, part_options)
+
+          expect(command).to be_invalid
+        end
+      end
+
+      context "when given options for an existing assembly" do
+        it "updates attributes on the existing assignment" do
+          bundle = create(:product)
+          part = create(:product, can_be_part: true)
+          assignment = AssembliesPart.create(
+            assembly_id: bundle.id,
+            count: 1,
+            part_id: part.id
+          )
+
+          part_options = { count: 2, id: assignment.id }
+
+          command = AssignPartToBundleForm.new(bundle, part_options)
+          command.submit
+          assignment.reload
+
+          expect(assignment.count).to be(2)
+        end
+      end
+
+      context "when given options for an assembly that does not exist" do
+        it "creates a new assembly part assignment with the provided options" do
+          bundle = create(:product)
+          part = create(:product, can_be_part: true)
+
+          part_options = { count: 2, variant_id: part.id }
+
+          command = AssignPartToBundleForm.new(bundle, part_options)
+
+          expect { command.submit }.to change { AssembliesPart.count }.by(1)
+        end
+      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,88 @@
+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
+          expect { order.contents.add(variant, 10) }.to(
+            raise_error ActiveRecord::RecordInvalid
+          )
+        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
+
+    context "removing line items" do
+      it "removes part line items" do
+        line_item = create(:line_item)
+        create(:part_line_item, line_item: line_item)
+
+        line_item.destroy
+
+        expect(Spree::PartLineItem.count).to eq 0
+      end
+    end
+  end
+end