controller_test_example.rb

require 'rails_helper'

describe OrdersController do
  describe 'GET #index' do
    it_requires_authentication do
      get :index
    end

    for_users :admin, :analyst do
      it 'loads all the orders in distinct order' do
        order1, order2 = Fabricate(:order), Fabricate(:order)

        get :index

        expect(assigns(:orders)).to eq([order2, order1])
      end
    end

    for_user :call_operator do
      it 'loads orders only for this call_operator in distinct order' do
        order1, order2, order3 = Fabricate(:order),
          Fabricate(:order_new, call_operator: user),
          Fabricate(:order_new, call_operator: user)

        get :index

        expect(assigns(:orders)).to eq([order3, order2])
      end
    end

    for_user :post_manager do
      it 'loads orders only for this post_manager in distinct order' do
        order1, order2, order3 = Fabricate(:order),
          Fabricate(:order_confirmed), Fabricate(:order_confirmed)

        [order2, order3].each { |order| order.update(post_manager: user) }

        get :index

        expect(assigns(:orders)).to eq([order3, order2])
      end
    end
  end

  describe 'PATCH #update' do
    it_requires_authentication do
      patch_update_request_with_valid_params
    end

    for_users :analyst, :call_operator, :post_manager do
      it 'updates order' do
        patch_update_request_with_valid_params

        check_if_updated_successfully
      end
    end

    for_user :admin do
      it_raises_authorization_error do
        patch_update_request_with_valid_params
      end
    end

    def patch_update_request_with_valid_params
      order = Fabricate(:order)
      patch :update, id: order.id, order: params_for_update
    end

    def check_if_updated_successfully
      order = assigns(:order).reload
      expect(order.note).to eq(params_for_update['note'])
    end

    def params_for_update
      @params_for_update ||= Fabricate.attributes_for(:order).slice(:note)
    end
  end

  describe 'POST #batch_set_post_manager' do
    for_user :admin, :analyst do
      it 'set post_manager for 2 orders' do
        post_manager = Fabricate(:user_post_manager)
        order1, order2 = Fabricate(:order_confirmed), Fabricate(:order_confirmed)

        post :batch_set_post_manager, {post_manager_id: post_manager.id, order_ids: [order1.id, order2.id]}

        expect(order1.reload.post_manager).to eq(post_manager)
        expect(order2.reload.post_manager).to eq(post_manager)
      end
    end

    for_users :call_operator, :post_manager do
      it_raises_authorization_error do
        post :batch_set_post_manager
      end
    end
  end

  describe 'POST #batch_set_call_operator' do
    for_user :admin, :analyst do
      it 'set call_operator for 2 orders' do
        call_operator = Fabricate(:user_call_operator)
        order1, order2 = Fabricate(:order_confirmed), Fabricate(:order_confirmed)

        post :batch_set_call_operator, {call_operator_id: call_operator.id, order_ids: [order1.id, order2.id]}

        expect(order1.reload.call_operator).to eq(call_operator)
        expect(order2.reload.call_operator).to eq(call_operator)
      end
    end

    for_users :call_operator, :post_manager do
      it_raises_authorization_error do
        post :batch_set_post_manager
      end
    end
  end

  describe 'POST #batch_clarify' do
    for_user :call_operator do
      it "mass set order's state to 'clarification'" do
        order1, order2 = Fabricate(:order_new, call_operator: user),
          Fabricate(:order_new, call_operator: user)

        post :batch_clarify, {order_ids: [order1.id, order2.id]}
      end
    end

    for_users :admin, :analyst, :post_manager do
      it_raises_authorization_error do
        post :batch_clarify
      end
    end
  end

  describe 'POST #batch_confirm' do
    for_user :call_operator do
      it "mass set order's state to 'confirmed'" do
        order1, order2 = Fabricate(:order_clarification, call_operator: user),
          Fabricate(:order_clarification, call_operator: user)

        post :batch_confirm, {order_ids: [order1.id, order2.id]}
      end
    end

    for_users :admin, :analyst, :post_manager do
      it_raises_authorization_error do
        post :batch_confirm
      end
    end
  end

  describe 'POST #batch_cancel' do
    for_users :call_operator, :analyst do
      it "mass set order's state to 'canceled'" do
        order1, order2 = Fabricate(:order_clarification, call_operator: user),
          Fabricate(:order_clarification, call_operator: user)

        post :batch_cancel, {order_ids: [order1.id, order2.id]}
      end
    end

    for_users :admin, :post_manager do
      it_raises_authorization_error do
        post :batch_confirm
      end
    end
  end

  describe 'POST #batch_process' do
    for_user :post_manager do
      it "mass set order's state to 'processing'" do
        order1, order2 = Fabricate(:order_confirmed), Fabricate(:order_confirmed)

        [order1, order2].each { |order| order.update(post_manager: user) }

        post :batch_process, {order_ids: [order1.id, order2.id]}

        expect(order1.reload.post_manager).to eq(user)
        expect(order2.reload.post_manager).to eq(user)
      end
    end

    for_users :admin, :analyst, :call_operator do
      it_raises_authorization_error do
        post :batch_process
      end
    end
  end

  describe 'POST #batch_mark_as_sent' do
    for_user :post_manager do
      it 'mark orders as sent' do
        order1, order2 = Fabricate(:order_processing), Fabricate(:order_processing)

        [order1, order2].each { |order| order.update(post_manager: user) }

        post :batch_mark_as_sent, {order_ids: [order1.id, order2.id]}

        expect(order1.reload.post_manager).to eq(user)
        expect(order2.reload.post_manager).to eq(user)
      end
    end

    for_users :admin, :analyst, :call_operator do
      it_raises_authorization_error do
        post :batch_mark_as_sent
      end
    end
  end

  describe 'POST #batch_mark_as_returned' do
    for_user :post_manager do
      it 'mark orders as returned' do
        order1, order2 = Fabricate(:order_sent), Fabricate(:order_sent)

        [order1, order2].each { |order| order.update(post_manager: user) }

        post :batch_mark_as_returned, {order_ids: [order1.id, order2.id]}

        expect(order1.reload.post_manager).to eq(user)
        expect(order2.reload.post_manager).to eq(user)
      end
    end

    for_users :admin, :analyst, :call_operator do
      it_raises_authorization_error do
        post :batch_mark_as_returned
      end
    end
  end

  describe 'POST #batch_mark_as_paid' do
    for_user :post_manager do
      it 'mark orders as paid' do
        order1, order2 = Fabricate(:order_sent), Fabricate(:order_sent)

        [order1, order2].each { |order| order.update(post_manager: user) }

        post :batch_mark_as_paid, {order_ids: [order1.id, order2.id]}

        expect(order1.reload.post_manager).to eq(user)
        expect(order2.reload.post_manager).to eq(user)
      end
    end

    for_users :admin, :analyst, :call_operator do
      it_raises_authorization_error do
        post :batch_mark_as_paid
      end
    end
  end
end