Skip to content

Open-source live-chat, email support, omni-channel desk. An alternative to Intercom, Zendesk, Salesforce Service Cloud etc. 🔥💬

22.1 KB
Raw Blame
require 'rails_helper'

RSpec.describe DeviseOverrides::SessionsController, type: :controller do
  include Devise::Test::ControllerHelpers

  before do
    request.env['devise.mapping'] = Devise.mappings[:user]
  end

  describe 'POST #create' do
    let(:user) { create(:user, password: 'Test@123456') }

    context 'with standard authentication' do
      it 'authenticates with valid credentials' do
        post :create, params: { email: user.email, password: 'Test@123456' }

        expect(response).to have_http_status(:success)
      end

      it 'rejects invalid credentials' do
        post :create, params: { email: user.email, password: 'wrong' }

        expect(response).to have_http_status(:unauthorized)
      end

      it 'authenticates with valid credentials supplied as request headers' do
        request.headers['email'] = user.email
        request.headers['password'] = 'Test@123456'

        post :create

        expect(response).to have_http_status(:success)
      end
    end

    context 'with MFA authentication' do
      before do
        skip('Skipping since MFA is not configured in this environment') unless Chatwoot.encryption_configured?
        user.enable_two_factor!
        user.update!(otp_required_for_login: true)
      end

      it 'requires MFA verification after successful password authentication' do
        post :create, params: { email: user.email, password: 'Test@123456' }

        expect(response).to have_http_status(:partial_content)
        json_response = response.parsed_body
        expect(json_response['mfa_required']).to be(true)
        expect(json_response['mfa_token']).to be_present
      end

      it 'requires MFA verification when credentials arrive as request headers' do
        request.headers['email'] = user.email
        request.headers['password'] = 'Test@123456'

        post :create

        expect(response).to have_http_status(:partial_content)
        expect(response.parsed_body['mfa_required']).to be(true)
        expect(response.headers['access-token']).to be_nil
      end

      it 'does not let header credentials override body credentials' do
        request.headers['email'] = user.email
        request.headers['password'] = 'Test@123456'

        post :create, params: { email: user.email, password: 'wrong-password' }

        expect(response).not_to have_http_status(:partial_content)
        expect(response.headers['access-token']).to be_nil
      end

      it 'does not return authentication tokens before MFA verification' do
        post :create, params: { email: user.email, password: 'Test@123456' }

        expect(response).to have_http_status(:partial_content)

        # Check that no authentication headers are present
        expect(response.headers['access-token']).to be_nil
        expect(response.headers['uid']).to be_nil
        expect(response.headers['client']).to be_nil
        expect(response.headers['Authorization']).to be_nil

        # Check that no bearer token is present in any form
        response.headers.each do |key, value|
          expect(value.to_s).not_to include('Bearer') if key.downcase.include?('auth')
        end

        json_response = response.parsed_body
        expect(json_response['data']).to be_nil
      end

      context 'when verifying MFA' do
        let(:mfa_token) { Mfa::TokenService.new(user: user).generate_token }

        it 'authenticates with valid OTP' do
          post :create, params: {
            mfa_token: mfa_token,
            otp_code: user.current_otp
          }

          expect(response).to have_http_status(:success)
        end

        it 'authenticates with valid backup code' do
          backup_codes = user.generate_backup_codes!

          post :create, params: {
            mfa_token: mfa_token,
            backup_code: backup_codes.first
          }

          expect(response).to have_http_status(:success)
        end

        it 'rejects invalid OTP' do
          post :create, params: {
            mfa_token: mfa_token,
            otp_code: 'invalid'
          }

          expect(response).to have_http_status(:bad_request)
          expect(response.parsed_body['error']).to eq(I18n.t('errors.mfa.invalid_code'))
        end

        it 'rejects invalid backup code' do
          user.generate_backup_codes!

          post :create, params: {
            mfa_token: mfa_token,
            backup_code: 'invalid'
          }

          expect(response).to have_http_status(:bad_request)
          expect(response.parsed_body['error']).to eq(I18n.t('errors.mfa.invalid_code'))
        end

        it 'rejects expired MFA token' do
          expired_token = JWT.encode(
            { user_id: user.id, exp: 1.minute.ago.to_i },
            Rails.application.secret_key_base,
            'HS256'
          )

          post :create, params: {
            mfa_token: expired_token,
            otp_code: user.current_otp
          }

          expect(response).to have_http_status(:unauthorized)
          expect(response.parsed_body['error']).to eq(I18n.t('errors.mfa.invalid_token'))
        end

        it 'requires either OTP or backup code' do
          post :create, params: { mfa_token: mfa_token }

          expect(response).to have_http_status(:bad_request)
          expect(response.parsed_body['error']).to eq(I18n.t('errors.mfa.invalid_code'))
        end
      end
    end

    context 'with account MFA enforcement' do
      let(:account) { create(:account) }
      let(:user) { create(:user, password: 'Test@123456', account: account) }

      before do
        skip('Skipping since MFA is not configured in this environment') unless Chatwoot.encryption_configured?
        account.update!(enforce_mfa: true)
      end

      it 'returns setup challenge with provisioning data and no auth headers' do
        post :create, params: { email: user.email, password: 'Test@123456' }

        expect(response).to have_http_status(:partial_content)
        json_response = response.parsed_body
        expect(json_response['mfa_setup_required']).to be(true)
        expect(json_response['mfa_setup_token']).to be_present
        expect(json_response['provisioning_url']).to include('otpauth://')
        expect(json_response['secret']).to eq(user.reload.otp_secret)
        expect(response.headers['access-token']).to be_nil
      end

      it 'does not rotate the secret on repeated challenges' do
        post :create, params: { email: user.email, password: 'Test@123456' }
        first_secret = user.reload.otp_secret

        post :create, params: { email: user.email, password: 'Test@123456' }

        expect(user.reload.otp_secret).to eq(first_secret)
      end

      it 'sends the normal mfa challenge for already-enrolled users' do
        user.enable_two_factor!
        user.update!(otp_required_for_login: true)

        post :create, params: { email: user.email, password: 'Test@123456' }

        expect(response.parsed_body['mfa_required']).to be(true)
        expect(response.parsed_body['mfa_setup_required']).to be_nil
      end

      it 'keeps the active secret and serves the mfa challenge when enrolment wins the race' do
        # Complete enrolment through a second record instance just before the
        # provisioning lock is taken; the lock's reload must observe it.
        concurrent_secret = nil
        original_with_lock = user.method(:with_lock)
        allow(User).to receive(:from_email).and_return(user)
        allow(user).to receive(:with_lock) do |*args, &block|
          User.find(user.id).tap do |concurrent_user|
            concurrent_user.enable_two_factor!
            concurrent_user.update!(otp_required_for_login: true)
            concurrent_secret = concurrent_user.otp_secret
          end
          original_with_lock.call(*args, &block)
        end

        post :create, params: { email: user.email, password: 'Test@123456' }

        expect(response).to have_http_status(:partial_content)
        expect(response.parsed_body['mfa_required']).to be(true)
        expect(response.parsed_body['mfa_setup_required']).to be_nil
        expect(user.reload.otp_secret).to eq(concurrent_secret)
      end

      it 'does not challenge when password is wrong' do
        post :create, params: { email: user.email, password: 'wrong' }

        expect(response).to have_http_status(:unauthorized)
      end

      it 'does not challenge users of non-enforcing accounts' do
        other_user = create(:user, password: 'Test@123456')

        post :create, params: { email: other_user.email, password: 'Test@123456' }

        expect(response).to have_http_status(:success)
      end

      it 'does not challenge SSO sign-ins' do
        sso_token = user.generate_sso_auth_token

        post :create, params: { email: user.email, sso_auth_token: sso_token }

        expect(response).to have_http_status(:success)
      end

      context 'when verifying setup' do
        render_views

        def setup_token_for(user)
          post :create, params: { email: user.email, password: 'Test@123456' }
          response.parsed_body['mfa_setup_token']
        end

        it 'activates mfa, signs in, and returns backup codes on valid otp' do
          token = setup_token_for(user)

          post :create, params: { mfa_setup_token: token, otp_code: user.reload.current_otp }

          expect(response).to have_http_status(:success)
          json_response = response.parsed_body
          expect(json_response['backup_codes'].length).to eq(10)
          expect(json_response['data']['email']).to eq(user.email)
          expect(response.headers['access-token']).to be_present
          expect(user.reload.otp_required_for_login).to be(true)
        end

        it 'rejects invalid otp' do
          token = setup_token_for(user)

          post :create, params: { mfa_setup_token: token, otp_code: '000000' }

          expect(response).to have_http_status(:bad_request)
          expect(response.parsed_body['error']).to eq(I18n.t('errors.mfa.invalid_code'))
          expect(user.reload.otp_required_for_login).to be(false)
        end

        it 'rejects a setup token for an already-enrolled user' do
          token = setup_token_for(user)
          user.reload.update!(otp_required_for_login: true)

          post :create, params: { mfa_setup_token: token, otp_code: user.reload.current_otp }

          expect(response).to have_http_status(:bad_request)
          expect(response.parsed_body['error']).to eq(I18n.t('errors.mfa.already_enabled'))
        end

        it 'rejects a login mfa_token used as setup token' do
          login_token = Mfa::TokenService.new(user: user).generate_token

          post :create, params: { mfa_setup_token: login_token, otp_code: '000000' }

          expect(response).to have_http_status(:unauthorized)
          expect(response.parsed_body['error']).to eq(I18n.t('errors.mfa.invalid_token'))
        end
      end
    end

    context 'with SSO authentication' do
      it 'authenticates with valid SSO token' do
        sso_token = user.generate_sso_auth_token

        post :create, params: {
          email: user.email,
          sso_auth_token: sso_token
        }

        expect(response).to have_http_status(:success)
      end

      it 'rejects invalid SSO token' do
        post :create, params: {
          email: user.email,
          sso_auth_token: 'invalid'
        }

        expect(response).to have_http_status(:unauthorized)
      end
    end
  end

  describe 'GET #new' do
    it 'redirects to frontend login page' do
      allow(ENV).to receive(:fetch).and_call_original
      allow(ENV).to receive(:fetch).with('FRONTEND_URL', nil).and_return('/frontend')

      get :new

      expect(response).to redirect_to('/frontend/app/login?error=access-denied')
    end
  end

  describe 'session limit enforcement' do
    around { |example| with_modified_env('MAX_USER_SESSIONS' => '5') { example.run } }

    let(:user) { create(:user, password: 'Test@123456') }
    let(:session_limit) { ENV.fetch('MAX_USER_SESSIONS', '5').to_i }
    let(:browser_ua) { 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.2.1 Safari/605.1.15' }
    let(:mobile_ua) { 'okhttp/4.9.3' }

    def seed_token(client_id, expiry_offset_days: 30, with_session: true)
      user.tokens = user.tokens.merge(
        client_id => { 'token' => 'x', 'expiry' => (Time.current + expiry_offset_days.days).to_i }
      )
      user.save!
      user.user_sessions.create!(client_id: client_id, last_activity_at: Time.current) if with_session
    end

    def login_params
      { email: user.email, password: 'Test@123456' }
    end

    context 'when under the limit' do
      it 'allows login without intervention' do
        request.env['HTTP_USER_AGENT'] = browser_ua
        3.times { |i| seed_token("c#{i}", expiry_offset_days: 30) }

        post :create, params: login_params

        expect(response).to have_http_status(:success)
      end

      it 'does not count expired tokens toward the cap' do
        request.env['HTTP_USER_AGENT'] = browser_ua
        # Raw token count reaches the cap, but three tokens are expired
        3.times { |i| seed_token("expired#{i}", expiry_offset_days: -1, with_session: false) }
        (session_limit - 3).times { |i| seed_token("active#{i}", expiry_offset_days: 30) }

        post :create, params: login_params

        expect(response).to have_http_status(:success)
      end
    end

    context 'when at the limit from a browser with full tracking' do
      before do
        request.env['HTTP_USER_AGENT'] = browser_ua
        session_limit.times { |i| seed_token("c#{i}", expiry_offset_days: 30) }
      end

      it 'returns 409 with the session list (picker)' do
        post :create, params: login_params

        expect(response).to have_http_status(:conflict)
        body = response.parsed_body
        expect(body['sessions_limit_reached']).to be true
        expect(body['sessions'].size).to eq(session_limit)
      end

      it 'does not create a new session row' do
        expect { post :create, params: login_params }.not_to change(user.user_sessions, :count)
      end
    end

    context 'when at the limit from a non-browser client' do
      before do
        request.env['HTTP_USER_AGENT'] = mobile_ua
        session_limit.times { |i| seed_token("c#{i}", expiry_offset_days: 30 + i, with_session: false) }
      end

      it 'silently evicts the oldest token and lets login proceed' do
        post :create, params: login_params

        expect(response).to have_http_status(:success)
        expect(user.reload.tokens.keys).not_to include('c0')
      end
    end

    context 'when at the limit but tracking is partial (legacy tokens present)' do
      before do
        request.env['HTTP_USER_AGENT'] = browser_ua
        # One tracked session, with the remaining tokens having no user_session rows
        seed_token('tracked', expiry_offset_days: 60, with_session: true)
        (session_limit - 1).times { |i| seed_token("legacy#{i}", expiry_offset_days: 10 + i, with_session: false) }
      end

      it 'silent-evicts instead of showing a partial picker' do
        post :create, params: login_params

        expect(response).to have_http_status(:success)
      end

      it 'drops an untracked token first, keeping the tracked session alive' do
        post :create, params: login_params

        tokens = user.reload.tokens.keys
        expect(tokens).to include('tracked')
        # legacy0 expires soonest -> evict_oldest_token picks it
        expect(tokens).not_to include('legacy0')
      end
    end

    context 'when at the limit with full tracking (no legacy gap)' do
      before do
        request.env['HTTP_USER_AGENT'] = mobile_ua
        # Tracked sessions with varying activity timestamps
        session_limit.times do |i|
          seed_token("tracked#{i}", expiry_offset_days: 30)
          user.user_sessions.find_by(client_id: "tracked#{i}").update!(last_activity_at: (session_limit - i).days.ago)
        end
      end

      it 'evicts the oldest tracked session by last_activity_at' do
        post :create, params: login_params

        expect(response).to have_http_status(:success)
        # tracked0 has the oldest last_activity_at
        expect(user.reload.tokens.keys).not_to include('tracked0')
        expect(user.user_sessions.exists?(client_id: 'tracked0')).to be false
      end
    end

    context 'with revoke_session_id during login' do
      before do
        request.env['HTTP_USER_AGENT'] = browser_ua
        session_limit.times { |i| seed_token("c#{i}", expiry_offset_days: 30) }
      end

      it 'revokes the chosen session and proceeds with login' do
        target = user.user_sessions.find_by(client_id: 'c2')

        post :create, params: login_params.merge(revoke_session_id: target.id)

        expect(response).to have_http_status(:success)
        expect(user.reload.tokens.keys).not_to include('c2')
        expect(user.user_sessions.exists?(id: target.id)).to be false
      end

      it 'keeps an SSO token usable after the picker so the login can be retried' do
        sso_token = user.generate_sso_auth_token
        post :create, params: { email: user.email, sso_auth_token: sso_token }
        expect(response).to have_http_status(:conflict)

        target = user.user_sessions.find_by(client_id: 'c2')
        post :create, params: { email: user.email, sso_auth_token: sso_token, revoke_session_id: target.id }

        expect(response).to have_http_status(:success)
      end
    end

    context 'with revoke_all_sessions during login' do
      before do
        request.env['HTTP_USER_AGENT'] = browser_ua
        session_limit.times { |i| seed_token("c#{i}", expiry_offset_days: 30) }
      end

      it 'wipes all sessions and tokens, then proceeds with login' do
        post :create, params: login_params.merge(revoke_all_sessions: true)

        expect(response).to have_http_status(:success)
        expect(user.reload.tokens.keys).not_to include('c0', 'c1', 'c2', 'c3', 'c4')
        # the new login adds one fresh token
        expect(user.tokens.keys.size).to eq(1)
      end
    end

    context 'with a successful login' do
      before { request.env['HTTP_USER_AGENT'] = browser_ua }

      it 'creates a UserSession row for the new client_id' do
        expect { post :create, params: login_params }.to change(user.user_sessions, :count).by(1)

        session = user.user_sessions.last
        expect(session.browser_name).to eq('Safari')
        expect(session.platform_name).to eq('macOS')
      end
    end
  end

  describe 'impersonation SSO login' do
    let(:user) { create(:user, password: 'Test@123456') }
    let(:super_admin) { create(:super_admin) }
    let(:browser_ua) { 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.2.1 Safari/605.1.15' }

    before { request.env['HTTP_USER_AGENT'] = browser_ua }

    it 'rejects an impersonation link already redeemed by a concurrent request' do
      sso_token = user.generate_sso_auth_token(impersonated_by: super_admin)
      allow(Redis::Alfred).to receive(:delete).and_return(0)

      post :create, params: { email: user.email, sso_auth_token: sso_token }

      expect(response).to have_http_status(:unauthorized)
      expect(user.reload.tokens).to be_blank
    end

    it 'does not create a UserSession row for impersonation login' do
      sso_token = user.generate_sso_auth_token(impersonated_by: super_admin)

      expect do
        post :create, params: { email: user.email, sso_auth_token: sso_token }
      end.not_to change(user.user_sessions, :count)

      expect(response).to have_http_status(:success)
    end

    it 'creates a short-lived token for impersonation login' do
      sso_token = user.generate_sso_auth_token(impersonated_by: super_admin)

      post :create, params: { email: user.email, sso_auth_token: sso_token }

      expect(response).to have_http_status(:success)
      token_entry = user.reload.tokens.values.last
      # 2-day lifespan: expiry should be within ~3 days from now (token creation + lifespan)
      expect(token_entry['expiry']).to be < (3.days.from_now).to_i
    end

    it 'marks the session token with the impersonating super admin' do
      sso_token = user.generate_sso_auth_token(impersonated_by: super_admin)

      post :create, params: { email: user.email, sso_auth_token: sso_token }

      expect(user.reload.tokens[response.headers['client']]['impersonated_by']).to eq(super_admin.id)
    end

    it 'treats a token minted before super admin attribution as impersonation' do
      sso_token = SecureRandom.hex(32)
      Redis::Alfred.setex(format(Redis::RedisKeys::USER_SSO_AUTH_TOKEN, user_id: user.id, token: sso_token), 'impersonation', 5.minutes)

      expect do
        post :create, params: { email: user.email, sso_auth_token: sso_token }
      end.not_to change(user.user_sessions, :count)

      token_entry = user.reload.tokens[response.headers['client']]
      expect(token_entry['impersonation']).to be(true)
      expect(token_entry).not_to have_key('impersonated_by')
      expect(token_entry['expiry']).to be < 3.days.from_now.to_i
    end

    it 'does not mark the session token for a regular SSO login' do
      post :create, params: { email: user.email, sso_auth_token: user.generate_sso_auth_token }

      token_entry = user.reload.tokens[response.headers['client']]
      expect(token_entry).not_to have_key('impersonation')
      expect(token_entry).not_to have_key('impersonated_by')
    end

    it 'creates a normal UserSession row for regular SSO login' do
      sso_token = user.generate_sso_auth_token

      expect do
        post :create, params: { email: user.email, sso_auth_token: sso_token }
      end.to change(user.user_sessions, :count).by(1)
    end

    it 'preserves the impersonation token when target user is at the device cap' do
      allow(DeviseTokenAuth).to receive(:max_number_of_devices).and_return(5)
      5.times do |i|
        user.tokens["existing#{i}"] = { 'token' => 'x', 'expiry' => (Time.current + (30 + i).days).to_i }
      end
      user.save!
      sso_token = user.generate_sso_auth_token(impersonated_by: super_admin)

      post :create, params: { email: user.email, sso_auth_token: sso_token }

      expect(response).to have_http_status(:success)
      new_client_id = response.headers['client']
      expect(user.reload.tokens.keys).to include(new_client_id)
      expect(user.tokens.size).to eq(5)
    end
  end
end