LeadMagnet/leadchat
1
0
Fork 0
Code Issues Pull Requests Actions 3 Packages Projects Releases Wiki Activity

feat: Add backend changes for whatsapp csat template (#12984)

Browse Source 
This PR add the backend changes for the feature [sending CSAT surveys
via WhatsApp message templates
](https://github.com/chatwoot/chatwoot/pull/12787)

---------

Co-authored-by: Vinay Keerthi <11478411+stonecharioteer@users.noreply.github.com>
This commit is contained in:
Muhsin Keloth
2025-12-11 16:36:37 +05:30
committed by GitHub
parent 1de8d3e56d
commit 2bd8e76886
10 changed files with 1331 additions and 18 deletions
Download Patch File Download Diff File Expand all files Collapse all files

376
spec/services/whatsapp/csat_template_service_spec.rb Normal file
View File

@@ -0,0 +1,376 @@
require 'rails_helper'
RSpec.describe Whatsapp::CsatTemplateService do
let(:account) { create(:account) }
let(:whatsapp_channel) do
create(:channel_whatsapp, account: account, provider: 'whatsapp_cloud', sync_templates: false, validate_provider_config: false)
end
let(:inbox) { create(:inbox, channel: whatsapp_channel, account: account) }
let(:service) { described_class.new(whatsapp_channel) }
let(:expected_template_name) { "customer_satisfaction_survey_#{whatsapp_channel.inbox.id}" }
let(:template_config) do
{
message: 'How would you rate your experience?',
button_text: 'Rate Us',
language: 'en',
base_url: 'https://example.com',
template_name: expected_template_name
}
end
before do
allow(ENV).to receive(:fetch).and_call_original
allow(ENV).to receive(:fetch).with('WHATSAPP_CLOUD_BASE_URL', anything).and_return('https://graph.facebook.com')
end
describe '#generate_template_name' do
context 'when no existing template' do
it 'returns base name as-is' do
whatsapp_channel.inbox.update!(csat_config: {})
result = service.send(:generate_template_name, 'new_template_name')
expect(result).to eq('new_template_name')
end
it 'returns base name when template key is missing' do
whatsapp_channel.inbox.update!(csat_config: { 'other_config' => 'value' })
result = service.send(:generate_template_name, 'new_template_name')
expect(result).to eq('new_template_name')
end
end
context 'when existing template has no versioned name' do
it 'starts versioning from 1' do
whatsapp_channel.inbox.update!(csat_config: {
'template' => { 'name' => expected_template_name }
})
result = service.send(:generate_template_name, 'new_template_name')
expect(result).to eq("#{expected_template_name}_1")
end
it 'starts versioning from 1 for custom name' do
whatsapp_channel.inbox.update!(csat_config: {
'template' => { 'name' => 'custom_survey' }
})
result = service.send(:generate_template_name, 'new_template_name')
expect(result).to eq("#{expected_template_name}_1")
end
end
context 'when existing template has versioned name' do
it 'increments version number' do
whatsapp_channel.inbox.update!(csat_config: {
'template' => { 'name' => "#{expected_template_name}_1" }
})
result = service.send(:generate_template_name, 'new_template_name')
expect(result).to eq("#{expected_template_name}_2")
end
it 'increments higher version numbers' do
whatsapp_channel.inbox.update!(csat_config: {
'template' => { 'name' => "#{expected_template_name}_5" }
})
result = service.send(:generate_template_name, 'new_template_name')
expect(result).to eq("#{expected_template_name}_6")
end
it 'handles double digit version numbers' do
whatsapp_channel.inbox.update!(csat_config: {
'template' => { 'name' => "#{expected_template_name}_12" }
})
result = service.send(:generate_template_name, 'new_template_name')
expect(result).to eq("#{expected_template_name}_13")
end
end
context 'when existing template has non-matching versioned name' do
it 'starts versioning from 1' do
whatsapp_channel.inbox.update!(csat_config: {
'template' => { 'name' => 'different_survey_3' }
})
result = service.send(:generate_template_name, 'new_template_name')
expect(result).to eq("#{expected_template_name}_1")
end
end
context 'when template name is blank' do
it 'returns base name' do
whatsapp_channel.inbox.update!(csat_config: {
'template' => { 'name' => '' }
})
result = service.send(:generate_template_name, 'new_template_name')
expect(result).to eq('new_template_name')
end
it 'returns base name when template name is nil' do
whatsapp_channel.inbox.update!(csat_config: {
'template' => { 'name' => nil }
})
result = service.send(:generate_template_name, 'new_template_name')
expect(result).to eq('new_template_name')
end
end
end
describe '#build_template_request_body' do
it 'builds correct request structure' do
result = service.send(:build_template_request_body, template_config)
expect(result).to eq({
name: expected_template_name,
language: 'en',
category: 'MARKETING',
components: [
{
type: 'BODY',
text: 'How would you rate your experience?'
},
{
type: 'BUTTONS',
buttons: [
{
type: 'URL',
text: 'Rate Us',
url: 'https://example.com/survey/responses/{{1}}',
example: ['12345']
}
]
}
]
})
end
it 'uses default language when not provided' do
config_without_language = template_config.except(:language)
result = service.send(:build_template_request_body, config_without_language)
expect(result[:language]).to eq('en')
end
it 'uses default button text when not provided' do
config_without_button = template_config.except(:button_text)
result = service.send(:build_template_request_body, config_without_button)
expect(result[:components][1][:buttons][0][:text]).to eq('Please rate us')
end
end
describe '#create_template' do
let(:mock_response) do
# rubocop:disable RSpec/VerifiedDoubles
double('response', :success? => true, :body => '{}', '[]' => { 'id' => '123', 'name' => 'template_name' })
# rubocop:enable RSpec/VerifiedDoubles
end
before do
allow(HTTParty).to receive(:post).and_return(mock_response)
inbox.update!(csat_config: {})
end
it 'creates template with generated name' do
expected_body = {
name: expected_template_name,
language: 'en',
category: 'MARKETING',
components: [
{
type: 'BODY',
text: 'How would you rate your experience?'
},
{
type: 'BUTTONS',
buttons: [
{
type: 'URL',
text: 'Rate Us',
url: 'https://example.com/survey/responses/{{1}}',
example: ['12345']
}
]
}
]
}
expect(HTTParty).to receive(:post).with(
"https://graph.facebook.com/v14.0/#{whatsapp_channel.provider_config['business_account_id']}/message_templates",
headers: {
'Authorization' => "Bearer #{whatsapp_channel.provider_config['api_key']}",
'Content-Type' => 'application/json'
},
body: expected_body.to_json
)
service.create_template(template_config)
end
it 'returns success response on successful creation' do
allow(mock_response).to receive(:[]).with('id').and_return('template_123')
allow(mock_response).to receive(:[]).with('name').and_return(expected_template_name)
result = service.create_template(template_config)
expect(result).to eq({
success: true,
template_id: 'template_123',
template_name: expected_template_name,
language: 'en',
status: 'PENDING'
})
end
context 'when API call fails' do
let(:error_response) do
# rubocop:disable RSpec/VerifiedDoubles
double('response', success?: false, code: 400, body: '{"error": "Invalid template"}')
# rubocop:enable RSpec/VerifiedDoubles
end
before do
allow(HTTParty).to receive(:post).and_return(error_response)
allow(Rails.logger).to receive(:error)
end
it 'returns error response' do
result = service.create_template(template_config)
expect(result).to eq({
success: false,
error: 'Template creation failed',
response_body: '{"error": "Invalid template"}'
})
end
it 'logs the error' do
expect(Rails.logger).to receive(:error).with('WhatsApp template creation failed: 400 - {"error": "Invalid template"}')
service.create_template(template_config)
end
end
end
describe '#delete_template' do
it 'makes DELETE request to correct endpoint' do
# rubocop:disable RSpec/VerifiedDoubles
mock_response = double('response', success?: true, body: '{}')
# rubocop:enable RSpec/VerifiedDoubles
expect(HTTParty).to receive(:delete).with(
"https://graph.facebook.com/v14.0/#{whatsapp_channel.provider_config['business_account_id']}/message_templates?name=test_template",
headers: {
'Authorization' => "Bearer #{whatsapp_channel.provider_config['api_key']}",
'Content-Type' => 'application/json'
}
).and_return(mock_response)
result = service.delete_template('test_template')
expect(result).to eq({ success: true, response_body: '{}' })
end
it 'uses default template name when none provided' do
# rubocop:disable RSpec/VerifiedDoubles
mock_response = double('response', success?: true, body: '{}')
# rubocop:enable RSpec/VerifiedDoubles
expect(HTTParty).to receive(:delete).with(
"https://graph.facebook.com/v14.0/#{whatsapp_channel.provider_config['business_account_id']}/message_templates?name=#{expected_template_name}",
anything
).and_return(mock_response)
service.delete_template
end
it 'returns failure response when API call fails' do
# rubocop:disable RSpec/VerifiedDoubles
mock_response = double('response', success?: false, body: '{"error": "Template not found"}')
# rubocop:enable RSpec/VerifiedDoubles
allow(HTTParty).to receive(:delete).and_return(mock_response)
result = service.delete_template('test_template')
expect(result).to eq({ success: false, response_body: '{"error": "Template not found"}' })
end
end
describe '#get_template_status' do
it 'makes GET request to correct endpoint' do
# rubocop:disable RSpec/VerifiedDoubles
mock_response = double('response', success?: true, body: '{}')
# rubocop:enable RSpec/VerifiedDoubles
allow(mock_response).to receive(:[]).with('data').and_return([{
'id' => '123',
'name' => 'test_template',
'status' => 'APPROVED',
'language' => 'en'
}])
expect(HTTParty).to receive(:get).with(
"https://graph.facebook.com/v14.0/#{whatsapp_channel.provider_config['business_account_id']}/message_templates?name=test_template",
headers: {
'Authorization' => "Bearer #{whatsapp_channel.provider_config['api_key']}",
'Content-Type' => 'application/json'
}
).and_return(mock_response)
service.get_template_status('test_template')
end
it 'returns success response when template exists' do
# rubocop:disable RSpec/VerifiedDoubles
mock_response = double('response', success?: true, body: '{}')
# rubocop:enable RSpec/VerifiedDoubles
allow(mock_response).to receive(:[]).with('data').and_return([{
'id' => '123',
'name' => 'test_template',
'status' => 'APPROVED',
'language' => 'en'
}])
allow(HTTParty).to receive(:get).and_return(mock_response)
result = service.get_template_status('test_template')
expect(result).to eq({
success: true,
template: {
id: '123',
name: 'test_template',
status: 'APPROVED',
language: 'en'
}
})
end
it 'returns failure response when template not found' do
# rubocop:disable RSpec/VerifiedDoubles
mock_response = double('response', success?: true, body: '{}')
# rubocop:enable RSpec/VerifiedDoubles
allow(mock_response).to receive(:[]).with('data').and_return([])
allow(HTTParty).to receive(:get).and_return(mock_response)
result = service.get_template_status('test_template')
expect(result).to eq({ success: false, error: 'Template not found' })
end
it 'returns failure response when API call fails' do
# rubocop:disable RSpec/VerifiedDoubles
mock_response = double('response', success?: false, body: '{}')
# rubocop:enable RSpec/VerifiedDoubles
allow(HTTParty).to receive(:get).and_return(mock_response)
result = service.get_template_status('test_template')
expect(result).to eq({ success: false, error: 'Template not found' })
end
context 'when API raises an exception' do
before do
allow(HTTParty).to receive(:get).and_raise(StandardError, 'Network error')
allow(Rails.logger).to receive(:error)
end
it 'handles exceptions gracefully' do
result = service.get_template_status('test_template')
expect(result).to eq({ success: false, error: 'Network error' })
end
it 'logs the error' do
expect(Rails.logger).to receive(:error).with('Error fetching template status: Network error')
service.get_template_status('test_template')
end
end
end
end

88
spec/services/whatsapp/providers/whatsapp_cloud_service_spec.rb
View File

@@ -312,4 +312,92 @@ describe Whatsapp::Providers::WhatsappCloudService do
end
end
end
describe 'CSAT template methods' do
let(:mock_csat_template_service) { instance_double(Whatsapp::CsatTemplateService) }
let(:expected_template_name) { "customer_satisfaction_survey_#{whatsapp_channel.inbox.id}" }
let(:template_config) do
{
name: expected_template_name,
language: 'en',
category: 'UTILITY'
}
end
before do
allow(Whatsapp::CsatTemplateService).to receive(:new)
.with(whatsapp_channel)
.and_return(mock_csat_template_service)
end
describe '#create_csat_template' do
it 'delegates to csat_template_service with correct config' do
allow(mock_csat_template_service).to receive(:create_template)
.with(template_config)
.and_return({ success: true, template_id: '123' })
result = service.create_csat_template(template_config)
expect(mock_csat_template_service).to have_received(:create_template).with(template_config)
expect(result).to eq({ success: true, template_id: '123' })
end
end
describe '#delete_csat_template' do
it 'delegates to csat_template_service with default template name' do
allow(mock_csat_template_service).to receive(:delete_template)
.with(expected_template_name)
.and_return({ success: true })
result = service.delete_csat_template
expect(mock_csat_template_service).to have_received(:delete_template).with(expected_template_name)
expect(result).to eq({ success: true })
end
it 'delegates to csat_template_service with custom template name' do
custom_template_name = 'custom_csat_template'
allow(mock_csat_template_service).to receive(:delete_template)
.with(custom_template_name)
.and_return({ success: true })
result = service.delete_csat_template(custom_template_name)
expect(mock_csat_template_service).to have_received(:delete_template).with(custom_template_name)
expect(result).to eq({ success: true })
end
end
describe '#get_template_status' do
it 'delegates to csat_template_service with template name' do
template_name = 'customer_survey_template'
expected_response = { success: true, template: { status: 'APPROVED' } }
allow(mock_csat_template_service).to receive(:get_template_status)
.with(template_name)
.and_return(expected_response)
result = service.get_template_status(template_name)
expect(mock_csat_template_service).to have_received(:get_template_status).with(template_name)
expect(result).to eq(expected_response)
end
end
describe 'csat_template_service memoization' do
it 'creates and memoizes the csat_template_service instance' do
allow(Whatsapp::CsatTemplateService).to receive(:new)
.with(whatsapp_channel)
.and_return(mock_csat_template_service)
allow(mock_csat_template_service).to receive(:get_template_status)
.and_return({ success: true })
# Call multiple methods that use the service
service.get_template_status('test1')
service.get_template_status('test2')
# Verify the service was only instantiated once
expect(Whatsapp::CsatTemplateService).to have_received(:new).once
end
end
end
end