Virtual Inventory Location

describe KitsInventoryLocation do
  before(:each) do
    variant = create(:variant)
    kit_1 = build(:try_on_kit, state: 'shipped')
    kit_1.save validate: false
    kit_1.add_stock(variant, 1)
    kit_1.placements.create(variant_id: variant.id)

    kit_2 = build(:try_on_kit, state: 'shipped')
    kit_2.save validate: false
    kit_2.add_stock(variant, 1)
    kit_2.placements.create(variant_id: variant.id)
  end

  describe '#total_count_on_hand' do
    it 'returns a count of all the products in shipped kits' do
      kits_location = KitsInventoryLocation.new
      expect(kits_location.total_count_on_hand).to eq(2)
    end
  end

  describe '#inventory_items' do
    it 'returns an instance of MockInventoryItemCollection' do
      kits_location = KitsInventoryLocation.new

      expect(kits_location.inventory_items)
        .to be_kind_of(MockInventoryItemCollection)
    end
  end
end

class KitsLocation
  attr_accessor :kits

  def initialize
    self.kits = WidgetKit.shipped
  end

  def name
    'All Try-on Kits'
  end

  def to_param
    'kits_location'
  end

  def total_count_on_hand
    kits.reduce(0) { |a, e| a + e.total_count_on_hand }
  end

  def inventory_items
    @inventory_items ||= MockInventoryItemCollection.new(group_by_variants)
  end

  private

  def group_by_variants
    @group_by_variants ||= kits.flat_map(&:placements).group_by(&:variant)
  end
end

class Admin::InventoryLocationsController < Admin::BaseController
  helper_method :inventory_location, :inventory_locations

  def index; end

  def show; end

  private

  def kits_location
    @kits_location = KitsLocation.new
  end

  def inventory_location
    @inventory_location ||= if params[:id] == 'kits_location'
      kits_location
    else
      InventoryLocation.find(params[:id])
    end
  end

  def inventory_items
    @inventory_items ||= inventory_location.inventory_items.active_items
  end

  def inventory_locations
    @inventory_locations ||=
      InventoryLocation.includes(:inventory_items).all.to_a << kits_location
  end
end

describe MockInventoryItemCollection do
  describe '#initialize' do
    let(:variant) { create(:variant) }
    let(:placement) { create(:kit).placements.create(variant_id: variant.id) }
    let(:valid_argument) { { variant => [placement] } }

    it 'expects a hash of kits grouped by variants' do
      expect { MockInventoryItemCollection.new(nil) }
        .to raise_error(ArgumentError)

      expect { MockInventoryItemCollection.new(valid_argument) }
        .to_not raise_error
    end

    it 'assigns an array of MockInventoryItems to @active_items' do
      collection = MockInventoryItemCollection.new(valid_argument)
      expect(collection.active_items).to be_a(Array)
      expect(
        collection.active_items.all? do |item|
          item.is_a?(MockInventoryItemCollection::MockInventoryItem)
        end
      ).to eq(true)
    end

    it 'sets the properties on the MockInventoryItems' do
      item = MockInventoryItemCollection.new(valid_argument).active_items.first
      expect(item.variant).to eq(variant)
      expect(item.count_on_hand_less_backorders).to eq(1)
    end
  end
end

class MockInventoryItemCollection
  MockInventoryItem = Struct.new(:variant, :count_on_hand_less_backorders)
  attr_accessor :active_items

  def initialize(group)
    fail ArgumentError unless valid_argument(group)
    self.active_items = group.map { |k, v| MockInventoryItem.new(k, v.length) }
  end

  private

  def valid_argument(arg)
    return false unless arg.try(:is_a?, Hash)
    return false unless arg.keys.first.is_a? Product::Variant
    return false unless arg.values.first.is_a? Array
    arg.values.first[0].is_a? Kit::Placement
  end
end