Open-source live-chat, email support, omni-channel desk. An alternative to Intercom, Zendesk, Salesforce Service Cloud etc. 🔥💬
Ruby actioncablechat-widgetconversationcustomer-supportdashboarddesigndockerdocker-imageherokuintercomjavascriptlivechatopensourcerailsrubysassvuejswhatsappzendesk
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