solidus_reserved_stock 0.0.1

data/db/migrate/20160309025334_modify_stock_item_unique_index.rb

@@ -0,0 +1,14 @@
+# We need to be able to reserve the same variant for more than one user.
+# This relaxes the uniqueness constraint introduced in Solidus 1.2 for
+# supporting databases.
+class ModifyStockItemUniqueIndex < ActiveRecord::Migration
+  def change
+    return unless connection.adapter_name =~ /postgres|sqlite/i
+    remove_index "spree_stock_items", ["variant_id", "stock_location_id"]
+    add_index "spree_stock_items",
+              ["variant_id", "stock_location_id", "user_id"],
+              where: "deleted_at is null",
+              unique: true,
+              name: "index_spree_stock_items_on_variant_stock_location_and_user"
+  end
+end

data/lib/generators/solidus_reserved_stock/install/install_generator.rb

@@ -0,0 +1,22 @@
+module SolidusReservedStock
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      class_option :auto_run_migrations, type: :boolean, default: true
+
+      def add_migrations
+        run "bin/rake solidus_reserved_stock:install:migrations"
+      end
+
+      def run_migrations
+        if options[:auto_run_migrations] ||
+          ["", "y", "Y"].include?(
+            ask("Would you like to run the migrations now? [Y/n]")
+          )
+          run "bin/rake db:migrate"
+        else
+          puts "Skiping rake db:migrate, don't forget to run it!"
+        end
+      end
+    end
+  end
+end

data/lib/solidus_reserved_stock/ability_initializer.rb

@@ -0,0 +1,5 @@
+class AbilityInitializer < Rails::Railtie
+  initializer "solidus_reserved_stock.configure_rails_initialization" do
+    Spree::Ability.register_ability(Spree::StockReservationAbility)
+  end
+end

data/lib/solidus_reserved_stock/engine.rb

@@ -0,0 +1,15 @@
+module SolidusReservedStock
+  class Engine < ::Rails::Engine
+    engine_name "solidus_reserved_stock"
+    config.autoload_paths += %W(#{config.root}/lib)
+
+    def self.activate
+      Dir.glob(File.join(File.dirname(__FILE__), "../../app/**/*_decorator*.rb")) do |c|
+        Rails.configuration.cache_classes ? require(c) : load(c)
+      end
+    end
+
+    config.to_prepare(&method(:activate).to_proc)
+
+  end
+end

data/lib/solidus_reserved_stock/version.rb

@@ -0,0 +1,18 @@
+module SolidusReservedStock
+  module_function
+
+  # Returns the version of the currently loaded SolidusReservedStock as a
+  # <tt>Gem::Version</tt>.
+  def version
+    Gem::Version.new VERSION::STRING
+  end
+
+  module VERSION
+    MAJOR = 0
+    MINOR = 0
+    TINY  = 1
+    PRE   = nil
+
+    STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
+  end
+end

data/lib/solidus_reserved_stock.rb

@@ -0,0 +1,7 @@
+require "solidus_core"
+require "solidus_reserved_stock/engine"
+require "solidus_reserved_stock/version"
+require "solidus_reserved_stock/ability_initializer"
+
+module SolidusReservedStock
+end

data/lib/tasks/solidus_reserved_stock_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :solidus_reserved_stock do
+#   # Task goes here
+# end

data/solidus_reserved_stock.gemspec

@@ -0,0 +1,56 @@
+# coding: utf-8
+lib = File.expand_path("../lib/", __FILE__)
+$LOAD_PATH.unshift lib unless $LOAD_PATH.include?(lib)
+
+require "solidus_reserved_stock/version"
+
+Gem::Specification.new do |s|
+  s.platform    = Gem::Platform::RUBY
+  s.name        = "solidus_reserved_stock"
+  s.version     = SolidusReservedStock.version
+  s.homepage    = "https://github.com/resolve/solidus_reserved_stock"
+  s.license     = "MIT"
+  s.summary     = <<-HEREDOC
+Allows stock to be reserved for a given user, so it can't be purchased by other
+users.
+                  HEREDOC
+  s.description = <<-HEREDOC
+Allow stock to be reserved for a given user, so it can't be purchased by other
+users.
+When a customer reserves stock, it's moved from its normal stock location to a
+special reserved stock location. When a customer checks out, their reserved
+items will be used first to fulfill their order.
+Reserved stock can be restored to its original stock location at any time, and
+can be stored with an expiry date for the reservation.
+                  HEREDOC
+
+  s.author      = "Isaac Freeman"
+  s.email       = "isaac@resolvedigital.co.nz"
+
+  s.files        = `git ls-files`.split("\n")
+  s.test_files   = `git ls-files -- spec/*`.split("\n")
+  s.require_path = "lib"
+  s.requirements << "none"
+
+  s.has_rdoc = false
+
+  s.add_runtime_dependency "solidus_core", "~> 1.2"
+  s.add_runtime_dependency "solidus_api", "~> 1.2"
+  s.add_runtime_dependency "solidus_backend", "~> 1.2"
+  s.add_runtime_dependency "deface", "~> 1.0"
+
+  s.add_development_dependency "byebug", "~> 8.2"
+  s.add_development_dependency "capybara", "~> 2.4"
+  s.add_development_dependency "coffee-rails", "~> 4.0"
+  s.add_development_dependency "database_cleaner", "~> 1.3"
+  s.add_development_dependency "factory_girl_rails", "~> 4.6"
+  s.add_development_dependency "ffaker", "~> 1.32"
+  s.add_development_dependency "poltergeist", "~> 1.5"
+  s.add_development_dependency "pry-rails", "~> 0.3"
+  s.add_development_dependency "rubocop", "~> 0.37"
+  s.add_development_dependency "rspec-rails", "~> 3.1"
+  s.add_development_dependency "rspec-activemodel-mocks", "~> 1.0"
+  s.add_development_dependency "sass-rails", "~> 5.0"
+  s.add_development_dependency "simplecov", "~> 0.9"
+  s.add_development_dependency "guard-rspec", "~> 4.6"
+end

data/spec/controllers/spree/api/stock_locations_controller_spec.rb

@@ -0,0 +1,24 @@
+require "spec_helper"
+
+module Spree
+  describe Api::StockLocationsController, type: :controller do
+    render_views
+
+    let!(:stock_location) { create(:stock_location) }
+
+    before do
+      stub_authentication!
+    end
+
+    context "as an admin" do
+      sign_in_as_admin!
+
+      describe "#index" do
+        it "includes the reserved_items attribute" do
+          api_get :index
+          expect(json_response["stock_locations"].first).to have_attributes([:reserved_items])
+        end
+      end
+    end
+  end
+end

data/spec/controllers/spree/api/v1/reserved_stock_items_controller_spec.rb

@@ -0,0 +1,196 @@
+require "spec_helper"
+
+module Spree
+  describe Api::V1::ReservedStockItemsController, type: :controller do
+    render_views
+
+    let(:user) { create(:user) }
+    let(:original_stock_location) { create(:stock_location) }
+    let(:variant) { create(:variant) }
+    let(:reserved_stock_location) { Spree::StockLocation.reserved_items_location }
+    let(:reserved_stock_item) do
+      create(
+        :reserved_stock_item,
+        variant: variant,
+        stock_location: reserved_stock_location,
+        original_stock_location: original_stock_location,
+        user: user,
+        expires_at: 1.day.from_now,
+        backorderable: false
+      )
+    end
+    let(:expired_reserved_stock_item) do
+      create(
+        :reserved_stock_item,
+        variant: variant,
+        stock_location: reserved_stock_location,
+        original_stock_location: original_stock_location,
+        user: user,
+        expires_at: 1.day.ago,
+        backorderable: false
+      )
+    end
+    let(:reserved_stock_item_attributes) {
+      [
+        :id,
+        :count_on_hand,
+        :expires_at,
+        :original_stock_location_id,
+        :stock_location_id,
+        :user_id,
+        :variant_id,
+        :variant
+      ]
+    }
+
+    before do
+      stub_authentication!
+    end
+
+    context "as a normal user" do
+      it "cannot list reserved items" do
+        api_get :index
+        assert_unauthorized!
+      end
+      it "cannot reserve stock" do
+        api_post :reserve,
+        variant: variant, original_stock_location: original_stock_location, user: user, quantity: 4
+        assert_unauthorized!
+      end
+      it "cannot restock" do
+        api_post :restock, variant: variant, user: user, quantity: 4
+        assert_unauthorized!
+      end
+      it "cannot restock expired" do
+        api_post :restock_expired
+        assert_unauthorized!
+      end
+    end
+
+    context "as an admin" do
+      sign_in_as_admin!
+
+      describe "#index" do
+        it "can list reserved stock items" do
+          reserved_stock_item
+          api_get :index
+          expect(response).to be_success
+          expect(json_response['reserved_stock_items'].first).to have_attributes(reserved_stock_item_attributes)
+          expect(json_response['reserved_stock_items'].first['variant']['sku']).to match variant.sku
+        end
+        it "can list reserved stock items for a given user" do
+          reserved_stock_item
+          api_get :index, user_id: user.id
+          expect(response).to be_success
+          expect(json_response['reserved_stock_items'].first).to have_attributes(reserved_stock_item_attributes)
+          expect(json_response['reserved_stock_items'].first['variant']['sku']).to match variant.sku
+        end
+      end
+
+      describe "#reserve" do
+        context "request that will succeed" do
+          before do
+            stock_item = original_stock_location.stock_item_or_create(variant)
+            stock_item.adjust_count_on_hand(10)
+          end
+          it "reserves a quantity of stock for a given variant" do
+            expiry_date = 1.week.from_now
+            api_post :reserve,
+                     variant_id: variant.id,
+                     original_stock_location_id: original_stock_location.id,
+                     user_id: user.id,
+                     quantity: 4,
+                     expires_at: expiry_date
+            expect(response.status).to eq 201
+            expect(json_response[:count_on_hand]).to eq 4
+            expect(json_response[:expires_at]).to eq expiry_date.iso8601(3)
+          end
+          it "can find variants by sku" do
+            api_post :reserve,
+                     sku: variant.sku,
+                     original_stock_location_id: original_stock_location.id,
+                     user_id: user.id,
+                     quantity: 4
+            expect(response.status).to eq 201
+          end
+        end
+        context "can't find variant" do
+          it "returns an approprate error" do
+            api_post :reserve,
+                     sku: "florb",
+                     original_stock_location_id: original_stock_location.id,
+                     user_id: user.id,
+                     quantity: 4
+            expect(response.status).to eq 422
+          end
+        end
+        context "can't find original stock location" do
+          it "returns an approprate error" do
+            api_post :reserve,
+                     sku: variant.sku,
+                     original_stock_location_id: 1000,
+                     user_id: user.id,
+                     quantity: 4
+            expect(response.status).to eq 422
+          end
+        end
+        context "can't find user" do
+          it "returns an approprate error" do
+            api_post :reserve,
+                     sku: variant.sku,
+                     original_stock_location_id: original_stock_location.id,
+                     user_id: 1000,
+                     quantity: 4
+            expect(response.status).to eq 422
+          end
+        end
+        context "quantity unavailable" do
+          it "returns an approprate error" do
+            api_post :reserve,
+                     sku: variant.sku,
+                     original_stock_location_id: original_stock_location.id,
+                     user_id: user.id,
+                     quantity: 10000
+            expect(response.status).to eq 422
+          end
+        end
+        context "parameters are missing" do
+          it "returns JSON API formatted errors" do
+            api_post :reserve
+            expect(response.status).to eq 422
+            body = JSON.parse response.body
+          end
+        end
+      end
+
+      describe "#restock" do
+        before :each do
+          reserved_stock_item
+        end
+        it "restores all stock if no quantity given" do
+          api_post :restock, variant_id: variant.id, user_id: user.id
+          expect(response.status).to eq 201
+          expect(json_response[:count_on_hand]).to eq 0
+        end
+        it "restores some stock if quantity given" do
+          api_post :restock, variant_id: variant.id, user_id: user.id, quantity: 4
+          expect(response.status).to eq 201
+          expect(json_response[:count_on_hand]).to eq 6
+        end
+        it "returns an appropriate error message on failure" do
+          api_post :restock, variant: "flarn"
+          expect(response.status).to eq 422
+          # TODO: test for a reasonable error message
+        end
+      end
+
+      describe "#restock_expired" do
+        it "restores expired reservations" do
+          expired_reserved_stock_item
+          api_post :restock_expired
+          expect(response.status).to eq 204
+        end
+      end
+    end
+  end
+end

data/spec/controllers/spree/api/v1/validators/reserve_stock_params_validator_spec.rb

@@ -0,0 +1,41 @@
+require "spec_helper"
+
+module Spree
+  describe Spree::Api::V1::Validators::ReserveStockParamsValidator do
+    subject { Spree::Api::V1::Validators::ReserveStockParamsValidator }
+    let(:valid_parameters) {
+      {
+        variant_id: 1,
+        original_stock_location_id: 1,
+        user_id: 1,
+        quantity: 1,
+        expires_at: 1.day.from_now
+      }
+    }
+
+    it "fails validation when there's no variant_id or sku parameter" do
+      validator = subject.new(valid_parameters.except :variant_id)
+      expect(validator.validate).to be false
+      expect(validator.errors).to eq [{ status: 422, detail: "Parameters must include either 'variant_id' or 'sku'"}]
+    end
+
+    it "fails validation when there's no original_stock_location_id parameter" do
+      validator = subject.new(valid_parameters.except :original_stock_location_id)
+      expect(validator.validate).to be false
+      expect(validator.errors).to eq [{ status: 422, detail: "Parameters must include 'original_stock_location_id'"}]
+    end
+
+    it "fails validation when there's no user_id parameter" do
+      validator = subject.new(valid_parameters.except :user_id)
+      expect(validator.validate).to be false
+      expect(validator.errors).to eq [{ status: 422, detail: "Parameters must include 'user_id'"}]
+    end
+
+    it "fails validation when there's no quantity parameter" do
+      validator = subject.new(valid_parameters.except :quantity)
+      expect(validator.validate).to be false
+      expect(validator.errors).to eq [{ status: 422, detail: "Parameters must include 'quantity'"}]
+    end
+
+  end
+end

data/spec/controllers/spree/api/variants_controller_spec.rb

@@ -0,0 +1,62 @@
+require "spec_helper"
+
+module Spree
+  describe Api::VariantsController, type: :controller do
+    render_views
+
+    let(:variant) { create(:variant) }
+    let(:user) { create(:user) }
+    let(:other_user) { create(:user) }
+    let(:original_stock_location) { create(:stock_location) }
+
+    before do
+      stub_authentication!
+      stock_item = original_stock_location.stock_item_or_create(variant)
+      stock_item.adjust_count_on_hand(10)
+      Spree::Stock::Reserver.new.reserve(
+        variant,
+        original_stock_location,
+        user,
+        4
+      )
+    end
+
+    context "as an admin" do
+      sign_in_as_admin!
+
+      describe "#show" do
+        context "total_on_hand" do
+          context "when given user" do
+            it "returns total that includes reserved stock" do
+              api_get :show, id: variant.id, user_id: user.id
+              expect(json_response[:total_on_hand]).to eq 10
+            end
+          end
+          context "when given no user" do
+            it "returns total that includes reserved stock" do
+              api_get :show, id: variant.id
+              expect(json_response[:total_on_hand]).to eq 6
+            end
+          end
+          context "when given a different user" do
+            it "returns total that includes reserved stock" do
+              api_get :show, id: variant.id, user_id: other_user.id
+              expect(json_response[:total_on_hand]).to eq 6
+            end
+          end
+        end
+        context "stock_items" do
+          context "when given user" do
+            it "returns total that includes reserved stock"
+          end
+          context "when given no user" do
+            it "returns total that includes reserved stock"
+          end
+          context "when given a different user" do
+            it "returns total that includes reserved stock"
+          end
+        end
+      end
+    end
+  end
+end

data/spec/factories/reserved_stock_item_factory.rb

@@ -0,0 +1,8 @@
+FactoryGirl.define do
+  factory :reserved_stock_item, class: Spree::ReservedStockItem do
+    backorderable true
+    stock_location
+    variant { FactoryGirl.create(:variant) }
+    after(:create) { |object| object.adjust_count_on_hand(10) }
+  end
+end

data/spec/models/spree/reserved_stock_item_spec.rb

@@ -0,0 +1,101 @@
+require "spec_helper"
+
+# Specs ReservedStockItem subclass to StockItem
+describe Spree::ReservedStockItem, type: :model do
+  let(:reserved_stock_location) do
+    create(
+      :stock_location,
+      reserved_items: true,
+      propagate_all_variants: false,
+      backorderable_default: false
+    )
+  end
+  let(:user) { create(:user) }
+  let(:variant) { FactoryGirl.create(:variant) }
+  subject do
+    create(
+      :reserved_stock_item,
+      variant: variant,
+      stock_location: reserved_stock_location,
+      user: user,
+      backorderable: false
+    )
+  end
+
+  context "validation" do
+    context "stock location" do
+      it "can be valid" do
+        expect(subject).to be_valid
+      end
+      it "is invalid if backorderable" do
+        reserved_stock_item = build(
+          :reserved_stock_item,
+          variant: FactoryGirl.create(:variant),
+          stock_location: reserved_stock_location,
+          user: user,
+          backorderable: true
+        )
+        expect(reserved_stock_item).to be_invalid
+      end
+      it "is invalid if its stock_location is not for reserved_items" do
+        invalid_base_stock_location = create(
+          :stock_location,
+          reserved_items: false,
+          propagate_all_variants: false
+        )
+        reserved_stock_item = build(
+          :reserved_stock_item,
+          stock_location: invalid_base_stock_location,
+          backorderable: false
+        )
+        expect(reserved_stock_item).to be_invalid
+      end
+    end
+    context "user" do
+      it "is invalid without a user" do
+        reserved_stock_item = build(
+          :reserved_stock_item,
+          stock_location: reserved_stock_location,
+          user: nil,
+          backorderable: false
+        )
+        expect(reserved_stock_item).to be_invalid
+      end
+      it "is invalid if variant and user are not unique" do
+        reserved_stock_item = build(
+          :reserved_stock_item,
+          stock_location: reserved_stock_location,
+          variant: subject.variant,
+          user: subject.user,
+          backorderable: false
+        )
+        expect(reserved_stock_item).to be_invalid
+      end
+      it "is valid if variant is not unique, but user is" do
+        different_user = create(:user)
+        reserved_stock_item = build(
+          :reserved_stock_item,
+          stock_location: reserved_stock_location,
+          variant: subject.variant,
+          user: different_user,
+          backorderable: false
+        )
+        expect(reserved_stock_item).to be_valid
+      end
+    end
+  end
+  context "DB constraints" do
+    it "can save two items with same variant but different user" do
+      different_user = create(:user)
+      reserved_stock_item = build(
+        :reserved_stock_item,
+        stock_location: reserved_stock_location,
+        variant: subject.variant,
+        user: different_user,
+        backorderable: false
+      )
+      reserved_stock_item.save
+      expect(Spree::ReservedStockItem.count).to eq 2
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+require "spec_helper"
+
+describe Spree::Stock::Coordinator, type: :model do
+  # Force setting up a normal stock lcoation before we create variant,
+  # otherwise we get too many stock locations
+  let!(:normal_stock_location) { create(:stock_location) }
+  let(:variant) { create(:variant) }
+  let(:user) { create(:user) }
+  let(:other_user) { create(:user) }
+  let(:reserved_stock_location) { Spree::StockLocation.reserved_items_location }
+  let(:normal_stock_item) do
+    normal_stock_location.stock_item(variant)
+  end
+  let(:reserved_stock_item_for_user) do
+    create(
+      :reserved_stock_item,
+      backorderable: false,
+      original_stock_location: normal_stock_location,
+      stock_location: reserved_stock_location,
+      user: user,
+      variant: variant
+    )
+  end
+  let(:reserved_stock_item_for_other_user) do
+    create(
+      :reserved_stock_item,
+      backorderable: false,
+      original_stock_location: normal_stock_location,
+      stock_location: reserved_stock_location,
+      user: other_user,
+      variant: variant
+    )
+  end
+  let(:order) { Spree::Order.new(user: user) }
+  subject { Spree::Stock::Coordinator.new(order) }
+
+  context "#packages" do
+    it "uses items reserved for the user first" do
+      reserved_stock_item_for_user.set_count_on_hand(5)
+      normal_stock_item.set_count_on_hand(5)
+      Spree::OrderContents.new(order).add(variant, 2)
+      packages = subject.packages
+      expect(packages.count).to eq 1
+      expect(packages.first.stock_location).to eq reserved_stock_location
+      expect(packages.first.contents.count).to eq 2
+    end
+    it "uses non-reserved items if there aren't enough reserved items" do
+      reserved_stock_item_for_user.set_count_on_hand(5)
+      normal_stock_item.set_count_on_hand(5)
+      Spree::OrderContents.new(order).add(variant, 7)
+      packages = subject.packages
+      expect(packages.count).to eq 2
+      expect(packages.first.stock_location).to eq reserved_stock_location
+      expect(packages.first.contents.count).to eq 5
+      expect(packages.second.stock_location).to eq normal_stock_location
+      expect(packages.second.contents.count).to eq 2
+    end
+    it "doesn't use items reserved by a different user" do
+      reserved_stock_item_for_other_user.set_count_on_hand(5)
+      normal_stock_item.set_count_on_hand(5)
+      Spree::OrderContents.new(order).add(variant, 2)
+      packages = subject.packages
+      expect(packages.count).to eq 1
+      expect(packages.first.stock_location).to eq normal_stock_location
+      expect(packages.first.contents.count).to eq 2
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+require "spec_helper"
+
+module Spree
+  module Stock
+    describe Prioritizer, type: :model do
+      let(:original_stock_location) { create(:stock_location) }
+      let(:reserved_stock_location) { Spree::StockLocation.reserved_items_location }
+      let(:variant) { build(:variant) }
+
+      it "sorts packages from reserved stock location first" do
+        regular_package = Package.new(original_stock_location)
+        regular_inventory_unit = mock_model(InventoryUnit, variant: variant)
+        regular_package.add regular_inventory_unit
+
+        reserved_package = Package.new(reserved_stock_location)
+        reserved_inventory_unit = mock_model(InventoryUnit, variant: variant)
+        reserved_package.add reserved_inventory_unit
+
+        inventory_units = [regular_inventory_unit, reserved_inventory_unit]
+        packages = [regular_package, reserved_package]
+        prioritizer = Prioritizer.new(inventory_units, packages)
+        packages = prioritizer.prioritized_packages
+
+        expect(packages.first).to eq reserved_package
+        expect(packages.second).to eq regular_package
+      end
+    end
+  end
+end