Skip to content

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

26.4 KB
Raw Blame
require 'rails_helper'

RSpec.describe 'Accounts API', type: :request do
  describe 'POST /api/v1/accounts' do
    let(:email) { Faker::Internet.email }
    let(:user_full_name) { Faker::Name.name_with_middle }

    context 'when posting to accounts with correct parameters' do
      let(:account_builder) { double }
      let(:account) { create(:account) }
      let(:user) { create(:user, email: email, account: account, name: user_full_name) }

      before do
        allow(AccountBuilder).to receive(:new).and_return(account_builder)
      end

      it 'calls account builder' do
        with_modified_env ENABLE_ACCOUNT_SIGNUP: 'true' do
          allow(account_builder).to receive(:perform).and_return([user, account])

          params = { account_name: 'test', email: email, user: nil, locale: nil, user_full_name: user_full_name, password: 'Password1!' }

          post api_v1_accounts_url,
               params: params,
               as: :json

          expect(AccountBuilder).to have_received(:new).with(params.except(:password).merge(user_password: params[:password]))
          expect(account_builder).to have_received(:perform)
          expect(response.headers.keys).not_to include('access-token', 'token-type', 'client', 'expiry', 'uid')
          expect(response.parsed_body['email']).to eq(email)
        end
      end

      it 'calls ChatwootCaptcha' do
        with_modified_env ENABLE_ACCOUNT_SIGNUP: 'true' do
          captcha = double
          allow(account_builder).to receive(:perform).and_return([user, account])
          allow(ChatwootCaptcha).to receive(:new).and_return(captcha)
          allow(captcha).to receive(:valid?).and_return(true)

          params = { account_name: 'test', email: email, user: nil, locale: nil, user_full_name: user_full_name, password: 'Password1!',
                     h_captcha_client_response: '123' }

          post api_v1_accounts_url,
               params: params,
               as: :json

          expect(ChatwootCaptcha).to have_received(:new).with('123')
          expect(response.headers.keys).not_to include('access-token', 'token-type', 'client', 'expiry', 'uid')
          expect(response.parsed_body['email']).to eq(email)
        end
      end

      it 'renders error response on invalid params' do
        with_modified_env ENABLE_ACCOUNT_SIGNUP: 'true' do
          allow(account_builder).to receive(:perform).and_return(nil)

          params = { account_name: nil, email: nil, user: nil, locale: 'en', user_full_name: nil }

          post api_v1_accounts_url,
               params: params,
               as: :json

          expect(AccountBuilder).not_to have_received(:new)
          expect(response).to have_http_status(:forbidden)
          expect(response.body).to eq({ message: I18n.t('errors.signup.invalid_params') }.to_json)
        end
      end
    end

    context 'with a Shopify pending installation token' do
      let(:pending_install_token) { SecureRandom.hex(16) }
      let(:pending_installation) do
        instance_double(
          Shopify::PendingInstallation,
          data: {
            'access_token' => 'shopify-access-token',
            'shop' => 'my-store.myshopify.com',
            'scope' => 'read_customers,read_orders',
            'connected_at' => Time.current.utc.iso8601(6)
          }
        )
      end
      let(:params) do
        {
          account_name: 'Shopify Store',
          email: email,
          user_full_name: user_full_name,
          password: 'Password1!',
          shopify_pending_install_token: pending_install_token
        }
      end

      before do
        allow(Shopify::FeatureGate).to receive(:enabled?).and_return(true)
        allow(Shopify::FeatureGate).to receive(:globally_enabled?).and_return(true)
        allow(Shopify::PendingInstallation).to receive(:pending?)
          .with(token: pending_install_token)
          .and_return(true)
        allow(Shopify::PendingInstallation).to receive(:claim)
          .with(token: pending_install_token)
          .and_return(pending_installation)
        allow(pending_installation).to receive(:with_current_installation).and_yield
        allow(pending_installation).to receive(:bind_to_account!)
        allow(pending_installation).to receive(:consume!)
        allow(pending_installation).to receive(:release!)
      end

      after { GlobalConfig.clear_cache }

      it 'creates a new Shopify-billed account and consumes the token' do
        with_modified_env ENABLE_ACCOUNT_SIGNUP: 'true' do
          post api_v1_accounts_url, params: params, as: :json
        end

        account = Account.order(:id).last
        expect(response).to have_http_status(:success)
        expect(response.parsed_body['email']).to eq(email)
        expect(account.internal_attributes).to include('billing_provider' => 'shopify', 'signup_source' => 'shopify')
        expect(account).to be_feature_enabled('shopify_integration')
        expect(account.hooks.find_by!(app_id: 'shopify').reference_id).to eq('my-store.myshopify.com')
        expect(pending_installation).to have_received(:consume!)
      end

      it 'creates a Shopify-billed account when general account signup is disabled' do
        with_modified_env ENABLE_ACCOUNT_SIGNUP: 'false' do
          post api_v1_accounts_url, params: params, as: :json
        end

        expect(response).to have_http_status(:success)
        expect(Account.order(:id).last.internal_attributes).to include(
          'billing_provider' => 'shopify',
          'signup_source' => 'shopify'
        )
      end

      it 'does not bypass disabled account signup for an invalid pending token' do
        allow(Shopify::PendingInstallation).to receive(:pending?).and_return(false)

        expect do
          with_modified_env ENABLE_ACCOUNT_SIGNUP: 'false' do
            post api_v1_accounts_url, params: params, as: :json
          end
        end.not_to change(Account, :count)

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

      it 'returns a clear error for an invalid or expired token' do
        allow(Shopify::PendingInstallation).to receive(:claim)
          .and_raise(Shopify::PendingInstallation::InvalidToken, 'Invalid or expired install token')

        expect do
          with_modified_env ENABLE_ACCOUNT_SIGNUP: 'true' do
            post api_v1_accounts_url, params: params, as: :json
          end
        end.not_to change(Account, :count)

        expect(response).to have_http_status(:unprocessable_entity)
        expect(response.parsed_body['message']).to eq('Invalid or expired install token')
      end

      it 'consumes a real pending installation and prevents replay' do
        encryption_env = {
          'ACTIVE_RECORD_ENCRYPTION_PRIMARY_KEY' => 'primary-key',
          'ACTIVE_RECORD_ENCRYPTION_DETERMINISTIC_KEY' => 'deterministic-key',
          'ACTIVE_RECORD_ENCRYPTION_KEY_DERIVATION_SALT' => 'key-derivation-salt'
        }

        with_modified_env(encryption_env.merge('ENABLE_ACCOUNT_SIGNUP' => 'true')) do
          allow(Shopify::PendingInstallation).to receive(:claim).and_call_original
          real_token = Shopify::PendingInstallation.create(
            access_token: 'shopify-access-token',
            shop: 'my-store.myshopify.com',
            scope: 'read_customers,read_orders'
          )

          post api_v1_accounts_url,
               params: params.merge(shopify_pending_install_token: real_token),
               as: :json
          expect(response).to have_http_status(:success)

          expect do
            post api_v1_accounts_url,
                 params: params.merge(email: '[email protected]', shopify_pending_install_token: real_token),
                 as: :json
          end.not_to change(Account, :count)

          expect(response).to have_http_status(:unprocessable_entity)
          expect(response.parsed_body['message']).to eq('Invalid or expired install token')
        ensure
          Redis::Alfred.delete("shopify_pending_install:#{real_token}") if real_token
          Redis::Alfred.delete("shopify_pending_install_claim:#{real_token}") if real_token
        end
      end

      it 'does not claim the token or create an account when Shopify is disabled' do
        allow(Shopify::FeatureGate).to receive(:enabled?).and_return(false)
        expect(Shopify::PendingInstallation).not_to receive(:claim)

        expect do
          with_modified_env ENABLE_ACCOUNT_SIGNUP: 'true' do
            post api_v1_accounts_url, params: params, as: :json
          end
        end.not_to change(Account, :count)

        expect(response).to have_http_status(:unprocessable_entity)
        expect(response.parsed_body['message']).to eq('Shopify signup is unavailable')
      end

      it 'does not let an authenticated user claim the token for a new account' do
        existing_user = create(:user)
        expect(Shopify::PendingInstallation).not_to receive(:claim)

        expect do
          with_modified_env ENABLE_ACCOUNT_SIGNUP: 'true' do
            post api_v1_accounts_url,
                 params: params.merge(email: '[email protected]'),
                 headers: existing_user.create_new_auth_token,
                 as: :json
          end
        end.not_to change(Account, :count)

        expect(response).to have_http_status(:forbidden)
        expect(response.parsed_body['message']).to include(existing_user.email)
      end
    end

    context 'when an authenticated user creates a second account' do
      let(:existing_user) { create(:user, password: 'Password1!') }

      it 'returns the full response with account_id' do
        with_modified_env ENABLE_ACCOUNT_SIGNUP: 'true' do
          post api_v1_accounts_url,
               params: { account_name: 'Second Account', email: existing_user.email,
                         user_full_name: existing_user.name, password: 'Password1!' },
               headers: existing_user.create_new_auth_token,
               as: :json

          expect(response).to have_http_status(:success)
          expect(response.parsed_body.dig('data', 'account_id')).to be_present
        end
      end
    end

    context 'when ENABLE_ACCOUNT_SIGNUP env variable is set to false' do
      it 'responds 404 on requests' do
        params = { account_name: 'test', email: email, user_full_name: user_full_name }
        with_modified_env ENABLE_ACCOUNT_SIGNUP: 'false' do
          post api_v1_accounts_url,
               params: params,
               as: :json

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

    context 'when ENABLE_ACCOUNT_SIGNUP is stored as boolean false' do
      before do
        GlobalConfig.clear_cache
        InstallationConfig.where(name: 'ENABLE_ACCOUNT_SIGNUP').delete_all
        InstallationConfig.create!(name: 'ENABLE_ACCOUNT_SIGNUP', value: false, locked: false)
      end

      after do
        InstallationConfig.where(name: 'ENABLE_ACCOUNT_SIGNUP').delete_all
        GlobalConfig.clear_cache
      end

      it 'responds 404 on requests' do
        params = { account_name: 'test', email: email, user_full_name: user_full_name, password: 'Password1!' }

        post api_v1_accounts_url,
             params: params,
             as: :json

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

    context 'when ENABLE_ACCOUNT_SIGNUP env variable is set to api_only' do
      before do
        GlobalConfig.clear_cache
        InstallationConfig.where(name: 'ENABLE_ACCOUNT_SIGNUP').delete_all
      end

      after do
        InstallationConfig.where(name: 'ENABLE_ACCOUNT_SIGNUP').delete_all
        GlobalConfig.clear_cache
      end

      it 'returns auth headers and full response for api_only signup' do
        params = { account_name: 'test', email: email, user_full_name: user_full_name, password: 'Password1!' }
        with_modified_env ENABLE_ACCOUNT_SIGNUP: 'api_only' do
          post api_v1_accounts_url,
               params: params,
               as: :json

          expect(response).to have_http_status(:success)
          expect(response.headers.keys).to include('access-token', 'token-type', 'client', 'expiry', 'uid')
        end
      end
    end

    context 'when CW_API_ONLY_SERVER is true' do
      it 'returns auth headers and full response' do
        params = { account_name: 'test', email: email, user_full_name: user_full_name, password: 'Password1!' }
        with_modified_env ENABLE_ACCOUNT_SIGNUP: 'true', CW_API_ONLY_SERVER: 'true' do
          post api_v1_accounts_url,
               params: params,
               as: :json

          expect(response).to have_http_status(:success)
          expect(response.headers.keys).to include('access-token', 'token-type', 'client', 'expiry', 'uid')
        end
      end
    end
  end

  describe 'GET /api/v1/accounts/{account.id}' do
    let(:account) { create(:account) }
    let(:agent) { create(:user, account: account, role: :agent) }
    let(:user_without_access) { create(:user) }
    let(:admin) { create(:user, account: account, role: :administrator) }

    context 'when it is an unauthenticated user' do
      it 'returns unauthorized' do
        get "/api/v1/accounts/#{account.id}"
        expect(response).to have_http_status(:unauthorized)
      end
    end

    context 'when it is an unauthorized user' do
      it 'returns unauthorized' do
        get "/api/v1/accounts/#{account.id}",
            headers: user_without_access.create_new_auth_token

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

    context 'when it is an authenticated user' do
      it 'shows an account' do
        account.update(name: 'new name')

        get "/api/v1/accounts/#{account.id}",
            headers: admin.create_new_auth_token,
            as: :json

        expect(response).to have_http_status(:success)
        expect(response).to conform_schema(200)
        expect(response.body).to include(account.name)
        expect(response.body).to include(account.locale)
        expect(response.body).to include(account.domain)
        expect(response.body).to include(account.support_email)
        expect(response.body).to include(account.locale)
      end

      it 'exposes the latest chatwoot version' do
        Redis::Alfred.set(Redis::Alfred::LATEST_CHATWOOT_VERSION, '4.16.1')

        get "/api/v1/accounts/#{account.id}",
            headers: admin.create_new_auth_token,
            as: :json

        expect(response.parsed_body['latest_chatwoot_version']).to eq('4.16.1')
      end

      it 'exposes the Shopify account feature when the installation switch is enabled' do
        account.enable_features!('shopify_integration')
        allow(GlobalConfigService).to receive(:load).and_call_original
        InstallationConfig.where(name: 'ENABLE_SHOPIFY_INTEGRATION').first_or_initialize.update!(value: true)

        get "/api/v1/accounts/#{account.id}",
            headers: admin.create_new_auth_token,
            as: :json

        expect(response.parsed_body.dig('features', 'shopify_integration')).to be true
      end

      it 'hides the Shopify account feature when the installation switch is disabled' do
        account.enable_features!('shopify_integration')
        allow(GlobalConfigService).to receive(:load).and_call_original
        InstallationConfig.where(name: 'ENABLE_SHOPIFY_INTEGRATION').first_or_initialize.update!(value: false)

        get "/api/v1/accounts/#{account.id}",
            headers: admin.create_new_auth_token,
            as: :json

        expect(response.parsed_body.fetch('features')).not_to have_key('shopify_integration')
      end

      it 'exposes the reporting timezone as an IANA identifier for browser reports' do
        account.update!(reporting_timezone: 'Pacific Time (US & Canada)')

        get "/api/v1/accounts/#{account.id}", headers: admin.create_new_auth_token, as: :json

        expect(response.parsed_body['reporting_timezone']).to eq('America/Los_Angeles')
      end
    end

    context 'when API and webhook access is disabled for the account' do
      it 'returns forbidden for API token authentication' do
        account_scope = double
        allow(account_scope).to receive(:find).with(account.id.to_s).and_return(account)
        allow_any_instance_of(User).to receive(:accounts).and_return(account_scope) # rubocop:disable RSpec/AnyInstance
        allow(account).to receive(:api_and_webhooks_enabled?).and_return(false)

        get "/api/v1/accounts/#{account.id}",
            headers: { api_access_token: admin.access_token.token },
            as: :json

        expect(response).to have_http_status(:forbidden)
        expect(response.parsed_body['error']).to eq('API access is not enabled for this account')
      end
    end
  end

  describe 'GET /api/v1/accounts/{account.id}/cache_keys' do
    let(:account) { create(:account) }
    let(:admin) { create(:user, account: account, role: :administrator) }

    it 'returns cache_keys as expected' do
      account.update(auto_resolve_duration: 30)

      get "/api/v1/accounts/#{account.id}/cache_keys",
          headers: admin.create_new_auth_token,
          as: :json

      expect(response).to have_http_status(:success)
      expect(response.parsed_body['cache_keys'].keys).to match_array(%w[label inbox team canned_response])
    end

    it 'sets the appropriate cache headers' do
      get "/api/v1/accounts/#{account.id}/cache_keys",
          headers: admin.create_new_auth_token,
          as: :json

      expect(response.headers['Cache-Control']).to include('max-age=10')
      expect(response.headers['Cache-Control']).to include('private')
      expect(response.headers['Cache-Control']).to include('stale-while-revalidate=300')
    end

    context 'when API and webhook access is disabled for the account' do
      it 'returns forbidden for API token authentication' do
        account_scope = double
        allow(account_scope).to receive(:find).with(account.id.to_s).and_return(account)
        allow_any_instance_of(User).to receive(:accounts).and_return(account_scope) # rubocop:disable RSpec/AnyInstance
        allow(account).to receive(:api_and_webhooks_enabled?).and_return(false)

        get "/api/v1/accounts/#{account.id}/cache_keys",
            headers: { api_access_token: admin.access_token.token },
            as: :json

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

  describe 'PATCH /api/v1/accounts/{account.id}' do
    let(:account) { create(:account) }
    let(:agent) { create(:user, account: account, role: :agent) }
    let(:admin) { create(:user, account: account, role: :administrator) }

    context 'with mfa enforcement setting' do
      before do
        skip('Skipping since MFA is not configured in this environment') unless Chatwoot.encryption_configured?
      end

      it 'allows administrators to enable enforce_mfa via session auth' do
        patch "/api/v1/accounts/#{account.id}",
              params: { enforce_mfa: true },
              headers: admin.create_new_auth_token,
              as: :json

        expect(response).to have_http_status(:success)
        expect(account.reload.enforce_mfa?).to be true
      end

      it 'ignores enforce_mfa when mfa feature unavailable' do
        allow(Chatwoot).to receive(:mfa_enabled?).and_return(false)

        patch "/api/v1/accounts/#{account.id}",
              params: { enforce_mfa: true },
              headers: admin.create_new_auth_token,
              as: :json

        expect(response).to have_http_status(:success)
        expect(account.reload.settings['enforce_mfa']).to be_nil
      end

      it 'blocks an unenrolled admin token from updating the account' do
        account.update!(enforce_mfa: true)

        patch "/api/v1/accounts/#{account.id}",
              params: { enforce_mfa: false },
              headers: { api_access_token: admin.access_token.token },
              as: :json

        expect(response).to have_http_status(:forbidden)
        expect(response.parsed_body['error_code']).to eq('mfa_enrollment_required')
        expect(account.reload.enforce_mfa?).to be true
      end

      it 'blocks account creation with an enforcement-pending token' do
        account.update!(enforce_mfa: true)

        with_modified_env ENABLE_ACCOUNT_SIGNUP: 'true' do
          post '/api/v1/accounts',
               params: { account_name: 'new team', email: admin.email, user_full_name: admin.name },
               headers: { api_access_token: admin.access_token.token },
               as: :json
        end

        expect(response).to have_http_status(:forbidden)
        expect(response.parsed_body['error_code']).to eq('mfa_enrollment_required')
      end

      it 'does not block account creation for saml users' do
        account.update!(enforce_mfa: true)
        admin.update!(provider: 'saml')

        with_modified_env ENABLE_ACCOUNT_SIGNUP: 'true' do
          post '/api/v1/accounts',
               params: { account_name: 'new team', email: admin.email, user_full_name: admin.name },
               headers: { api_access_token: admin.access_token.token },
               as: :json
        end

        expect(response).not_to have_http_status(:forbidden)
      end
    end

    context 'when it is an unauthenticated user' do
      it 'returns unauthorized' do
        patch "/api/v1/accounts/#{account.id}"
        expect(response).to have_http_status(:unauthorized)
      end
    end

    context 'when it is an unauthorized user' do
      it 'returns unauthorized' do
        patch "/api/v1/accounts/#{account.id}",
              headers: agent.create_new_auth_token

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

    context 'when it is an authenticated user' do
      params = {
        name: 'New Name',
        locale: 'en',
        domain: 'example.com',
        support_email: '[email protected]',
        auto_resolve_after: 40,
        auto_resolve_message: 'Auto resolved',
        auto_resolve_ignore_waiting: false,
        timezone: 'Asia/Kolkata',
        industry: 'Technology',
        company_size: '1-10'
      }

      it 'returns a valid schema' do
        patch "/api/v1/accounts/#{account.id}",
              params: params,
              headers: admin.create_new_auth_token,
              as: :json

        expect(response).to conform_schema(200)
      end

      it 'modifies an account' do
        patch "/api/v1/accounts/#{account.id}",
              params: params,
              headers: admin.create_new_auth_token,
              as: :json

        expect(response).to have_http_status(:success)
        expect(account.reload.name).to eq(params[:name])
        expect(account.reload.locale).to eq(params[:locale])
        expect(account.reload.domain).to eq(params[:domain])
        expect(account.reload.support_email).to eq(params[:support_email])

        %w[auto_resolve_after auto_resolve_message auto_resolve_ignore_waiting].each do |attribute|
          expect(account.reload.settings[attribute]).to eq(params[attribute.to_sym])
        end

        %w[timezone industry company_size].each do |attribute|
          expect(account.reload.custom_attributes[attribute]).to eq(params[attribute.to_sym])
        end
      end

      it 'updates onboarding step to invite_team if onboarding step is present in account custom attributes' do
        account.update(custom_attributes: { onboarding_step: 'account_update' })
        patch "/api/v1/accounts/#{account.id}",
              params: params,
              headers: admin.create_new_auth_token,
              as: :json

        expect(account.reload.custom_attributes['onboarding_step']).to eq('invite_team')
      end

      it 'will not update onboarding step if onboarding step is not present in account custom attributes' do
        patch "/api/v1/accounts/#{account.id}",
              params: params,
              headers: admin.create_new_auth_token,
              as: :json

        expect(account.reload.custom_attributes['onboarding_step']).to be_nil
      end

      it 'Throws error 422' do
        params[:name] = 'test' * 999

        patch "/api/v1/accounts/#{account.id}",
              params: params,
              headers: admin.create_new_auth_token,
              as: :json

        expect(response).to have_http_status(:unprocessable_entity)
        json_response = response.parsed_body
        expect(json_response['message']).to eq('Name is too long (maximum is 255 characters)')
      end
    end

    context 'when API and webhook access is disabled for the account' do
      it 'returns forbidden without modifying the account for API token authentication' do
        account_scope = double
        allow(account_scope).to receive(:find).with(account.id.to_s).and_return(account)
        allow_any_instance_of(User).to receive(:accounts).and_return(account_scope) # rubocop:disable RSpec/AnyInstance
        allow(account).to receive(:api_and_webhooks_enabled?).and_return(false)

        expect do
          patch "/api/v1/accounts/#{account.id}",
                params: { name: 'Updated through API' },
                headers: { api_access_token: admin.access_token.token },
                as: :json
        end.not_to(change { account.reload.name })

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

  describe 'POST /api/v1/accounts/{account.id}/update_active_at' do
    let(:account) { create(:account) }
    let(:agent) { create(:user, account: account, role: :agent) }

    context 'when it is an unauthenticated user' do
      it 'returns unauthorized' do
        post "/api/v1/accounts/#{account.id}/update_active_at"
        expect(response).to have_http_status(:unauthorized)
      end
    end

    context 'when it is an authenticated user' do
      it 'modifies an account' do
        expect(agent.account_users.first.active_at).to be_nil
        post "/api/v1/accounts/#{account.id}/update_active_at",
             params: {},
             headers: agent.create_new_auth_token,
             as: :json

        expect(response).to have_http_status(:success)
        expect(agent.account_users.first.active_at).not_to be_nil
      end
    end

    context 'when API and webhook access is disabled for the account' do
      it 'returns forbidden without updating active_at for API token authentication' do
        account_scope = double
        allow(account_scope).to receive(:find).with(account.id.to_s).and_return(account)
        allow_any_instance_of(User).to receive(:accounts).and_return(account_scope) # rubocop:disable RSpec/AnyInstance
        allow(account).to receive(:api_and_webhooks_enabled?).and_return(false)
        account_user = agent.account_users.first

        post "/api/v1/accounts/#{account.id}/update_active_at",
             headers: { api_access_token: agent.access_token.token },
             as: :json

        expect(response).to have_http_status(:forbidden)
        expect(account_user.reload.active_at).to be_nil
      end
    end
  end
end