openfoodnetwork/spec/controllers/admin/variant_overrides_controller_spec.rb

# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Admin::VariantOverridesController do
  describe "index" do
    context "not logged in" do
      it "redirects to login" do
        get :index
        expect(response).to redirect_to(
          root_path(anchor: "/login", after_login: admin_inventory_path)
        )
      end
    end

    context "where I manage the variant override hub", feature: :inventory do
      let(:hub) { create(:distributor_enterprise) }

      before do
        allow(controller).to receive(:spree_current_user) { hub.owner }
      end

      it "succeeds" do
        get :index
        expect(response).to have_http_status :ok
      end
    end
  end

  describe "bulk_update", feature: :inventory do
    context "json" do
      let(:format) { :json }

      let(:hub) { create(:distributor_enterprise) }
      let(:variant) { create(:variant) }
      let!(:inventory_item) {
        create(:inventory_item, enterprise: hub, variant:, visible: true)
      }
      let!(:variant_override) { create(:variant_override, hub:, variant:) }
      let(:variant_override_params) {
        [{ id: variant_override.id, price: 123.45, count_on_hand: 321, sku: "MySKU",
           on_demand: false }]
      }

      context "where I don't manage the variant override hub" do
        before do
          user = create(:user)
          user.owned_enterprises << create(:enterprise)
          allow(controller).to receive(:spree_current_user) { user }
        end

        it "redirects to unauthorized" do
          put :bulk_update, as: format, params: { variant_overrides: variant_override_params }
          expect(response).to redirect_to unauthorized_path
        end
      end

      context "where I manage the variant override hub" do
        before do
          allow(controller).to receive(:spree_current_user) { hub.owner }
        end

        context "but the producer has not granted VO permission" do
          it "redirects to unauthorized" do
            put :bulk_update, as: format, params: { variant_overrides: variant_override_params }
            expect(response).to redirect_to unauthorized_path
          end

          it 'only authorizes the updated variant overrides' do
            other_variant_override = create(:variant_override, hub:, variant: create(:variant))
            expect(controller).not_to receive(:authorize!).with(:update, other_variant_override)

            put :bulk_update, as: format, params: { variant_overrides: variant_override_params }
          end
        end

        context "and the producer has granted VO permission" do
          before do
            create(:enterprise_relationship, parent: variant.supplier, child: hub,
                                             permissions_list: [:create_variant_overrides])
          end

          it "loads data" do
            put :bulk_update, as: format, params: { variant_overrides: variant_override_params }
            expect(assigns[:hubs]).to eq [hub]
            expect(assigns[:producers]).to eq [variant.supplier]
            expect(assigns[:hub_permissions]).to eq({ hub.id => [variant.supplier.id] })
            expect(assigns[:inventory_items]).to eq [inventory_item]
          end

          it "allows me to update the variant override" do
            put :bulk_update, as: format, params: { variant_overrides: variant_override_params }

            variant_override.reload
            expect(variant_override.price).to eq 123.45
            expect(variant_override.count_on_hand).to eq 321
            expect(variant_override.sku).to eq "MySKU"
            expect(variant_override.on_demand).to eq false
          end

          context "where params for a variant override are blank" do
            let(:variant_override_params) {
              [{ id: variant_override.id, price: "", count_on_hand: "", default_stock: nil,
                 resettable: nil, sku: nil, on_demand: nil }]
            }

            it "destroys the variant override" do
              put :bulk_update, as: format, params: { variant_overrides: variant_override_params }
              expect(VariantOverride.find_by(id: variant_override.id)).to be_nil
            end
          end

          context "and there is a variant override for a deleted variant" do
            let(:deleted_variant) { create(:variant) }
            let!(:variant_override_of_deleted_variant) {
              create(:variant_override, hub:, variant: deleted_variant)
            }

            before { deleted_variant.update_attribute :deleted_at, Time.zone.now }

            it "allows to update other variant overrides" do
              put :bulk_update, as: format, params: { variant_overrides: variant_override_params }

              expect(response).not_to redirect_to unauthorized_path
              variant_override.reload
              expect(variant_override.price).to eq 123.45
            end
          end
        end
      end
    end
  end

  describe "bulk_reset", feature: :inventory do
    context "json" do
      let(:format) { :json }

      let(:hub) { create(:distributor_enterprise) }
      let(:producer) { create(:supplier_enterprise) }
      let(:product) { create(:product) }
      let(:variant1) { create(:variant, product:, supplier: producer) }
      let(:variant2) { create(:variant, product:, supplier: producer) }
      let!(:variant_override1) {
        create(:variant_override, hub:, variant: variant1, count_on_hand: 5, default_stock: 7,
                                  resettable: true)
      }
      let!(:variant_override2) {
        create(:variant_override, hub:, variant: variant2, count_on_hand: 2, default_stock: 1,
                                  resettable: false)
      }

      let(:params) { { format:, hub_id: hub.id } }

      context "where I don't manage the variant override hub" do
        before do
          user = create(:user)
          user.owned_enterprises << create(:enterprise)
          allow(controller).to receive(:spree_current_user) { user }
        end

        it "redirects to unauthorized" do
          put(:bulk_reset, params:)
          expect(response).to redirect_to unauthorized_path
        end
      end

      context "where I manage the variant override hub" do
        before do
          allow(controller).to receive(:spree_current_user) { hub.owner }
        end

        context "where the producer has not granted create_variant_overrides permission " \
                "to the hub" do
          it "restricts access" do
            put(:bulk_reset, params:)
            expect(response).to redirect_to unauthorized_path
          end
        end

        context "where the producer has granted create_variant_overrides permission to the hub" do
          let!(:er1) {
            create(:enterprise_relationship, parent: producer, child: hub,
                                             permissions_list: [:create_variant_overrides])
          }

          it "loads data" do
            put(:bulk_reset, params:)
            expect(assigns[:hubs]).to eq [hub]
            expect(assigns[:producers]).to eq [producer]
            expect(assigns[:hub_permissions]).to eq({ hub.id => [producer.id] })
            expect(assigns[:inventory_items]).to eq []
          end

          it "updates stock to default values where reset is enabled" do
            expect(variant_override1.reload.count_on_hand).to eq 5 # reset enabled
            expect(variant_override2.reload.count_on_hand).to eq 2 # reset disabled
            put(:bulk_reset, params:)
            expect(variant_override1.reload.count_on_hand).to eq 7 # reset enabled
            expect(variant_override2.reload.count_on_hand).to eq 2 # reset disabled
          end

          context "and the producer has granted create_variant_overrides permission " \
                  "to another hub I manage" do
            before { hub.owner.update_attribute(:enterprise_limit, 2) }
            let(:hub2) { create(:distributor_enterprise, owner: hub.owner) }
            let(:product) { create(:product) }
            let(:variant3) { create(:variant, product:, supplier: producer) }
            let!(:variant_override3) {
              create(:variant_override, hub: hub2, variant: variant3, count_on_hand: 1,
                                        default_stock: 13, resettable: true)
            }
            let!(:er2) {
              create(:enterprise_relationship, parent: producer, child: hub2,
                                               permissions_list: [:create_variant_overrides])
            }

            it "does not reset count_on_hand for variant_overrides not in params" do
              expect {
                put :bulk_reset, params:
              }.not_to change{ variant_override3.reload.count_on_hand }
            end
          end
        end
      end
    end
  end
end