773 lines
23 KiB
Go
773 lines
23 KiB
Go
package provider
|
|
|
|
import (
|
|
"context"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/gochat/gochat/internal/channel"
|
|
"github.com/gochat/gochat/internal/model"
|
|
channelmodel "github.com/gochat/gochat/internal/model/channel"
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
// ===========================
|
|
// ChannelRegistry tests
|
|
// ===========================
|
|
|
|
func TestNewChannelRegistry_Cov6(t *testing.T) {
|
|
r := NewChannelRegistry()
|
|
require.NotNil(t, r)
|
|
assert.Empty(t, r.List())
|
|
}
|
|
|
|
func TestChannelRegistry_RegisterAndGet_Cov6(t *testing.T) {
|
|
r := NewChannelRegistry()
|
|
r.Register(&mockProviderCov6{name: "test_channel"})
|
|
p := r.Get("test_channel")
|
|
require.NotNil(t, p)
|
|
assert.Equal(t, "test_channel", p.Name())
|
|
}
|
|
|
|
func TestChannelRegistry_Get_NotFound_Cov6(t *testing.T) {
|
|
r := NewChannelRegistry()
|
|
p := r.Get("nonexistent")
|
|
assert.Nil(t, p)
|
|
}
|
|
|
|
func TestChannelRegistry_List_Cov6(t *testing.T) {
|
|
r := NewChannelRegistry()
|
|
r.Register(&mockProviderCov6{name: "channel1"})
|
|
r.Register(&mockProviderCov6{name: "channel2"})
|
|
names := r.List()
|
|
assert.Len(t, names, 2)
|
|
}
|
|
|
|
// ===========================
|
|
// TelegramProvider tests
|
|
// ===========================
|
|
|
|
func TestTelegramProvider_Type_Cov6(t *testing.T) {
|
|
p := NewTelegramProvider()
|
|
assert.Equal(t, channel.ChannelTelegram, p.Type())
|
|
}
|
|
|
|
func TestTelegramProvider_Name_Cov6(t *testing.T) {
|
|
p := NewTelegramProvider()
|
|
assert.Equal(t, "Telegram", p.Name())
|
|
}
|
|
|
|
func TestTelegramProvider_Description_Cov6(t *testing.T) {
|
|
p := NewTelegramProvider()
|
|
assert.NotEmpty(t, p.Description())
|
|
}
|
|
|
|
func TestTelegramProvider_ConfigSchema_Cov6(t *testing.T) {
|
|
p := NewTelegramProvider()
|
|
schema := p.ConfigSchema()
|
|
require.NotNil(t, schema)
|
|
assert.Equal(t, "object", schema.Type)
|
|
assert.Contains(t, schema.Required, "bot_token")
|
|
}
|
|
|
|
func TestTelegramProvider_DefaultConfig_Cov6(t *testing.T) {
|
|
p := NewTelegramProvider()
|
|
cfg := p.DefaultConfig()
|
|
// Telegram provider doesn't have DefaultConfig — it uses ConfigSchema
|
|
_ = cfg
|
|
}
|
|
|
|
func TestTelegramProvider_Capabilities_Cov6(t *testing.T) {
|
|
p := NewTelegramProvider()
|
|
caps := p.Capabilities()
|
|
assert.True(t, caps.SupportsAttachments)
|
|
}
|
|
|
|
func TestTelegramProvider_ValidateConfig_NoToken_Cov6(t *testing.T) {
|
|
p := NewTelegramProvider()
|
|
err := p.ValidateConfig(context.Background(), channel.ChannelConfig{})
|
|
require.Error(t, err)
|
|
assert.Contains(t, err.Error(), "bot_token")
|
|
}
|
|
|
|
func TestTelegramProvider_ValidateConfig_BadFormat_Cov6(t *testing.T) {
|
|
p := NewTelegramProvider()
|
|
err := p.ValidateConfig(context.Background(), channel.ChannelConfig{
|
|
"bot_token": "badtoken",
|
|
})
|
|
require.Error(t, err)
|
|
assert.Contains(t, err.Error(), "format")
|
|
}
|
|
|
|
func TestTelegramProvider_ValidateConfig_APIError_Cov6(t *testing.T) {
|
|
p := NewTelegramProvider()
|
|
// Can't easily override the Telegram API URL; test the token format validation only
|
|
ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
|
|
defer cancel()
|
|
err := p.ValidateConfig(ctx, channel.ChannelConfig{
|
|
"bot_token": "123:ABCDEF",
|
|
})
|
|
// This will fail because it hits the real Telegram API
|
|
_ = err
|
|
}
|
|
|
|
func TestTelegramProvider_CreateChannel_NoToken_Cov6(t *testing.T) {
|
|
p := NewTelegramProvider()
|
|
_, err := p.CreateChannel(context.Background(), 1, channel.ChannelConfig{})
|
|
require.Error(t, err)
|
|
assert.Contains(t, err.Error(), "bot_token")
|
|
}
|
|
|
|
func TestTelegramProvider_DeleteChannel_Cov6(t *testing.T) {
|
|
p := NewTelegramProvider()
|
|
err := p.DeleteChannel(context.Background(), 1)
|
|
require.NoError(t, err)
|
|
}
|
|
|
|
func TestTelegramProvider_DeleteChannelWithToken_Cov6(t *testing.T) {
|
|
p := NewTelegramProvider()
|
|
ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
|
|
defer cancel()
|
|
err := p.DeleteChannelWithToken(ctx, 1, "123:ABC")
|
|
require.NoError(t, err)
|
|
}
|
|
|
|
func TestTelegramProvider_HandleWebhook_Cov6(t *testing.T) {
|
|
p := NewTelegramProvider()
|
|
err := p.HandleWebhook(context.Background(), map[string]interface{}{
|
|
"update_id": float64(123),
|
|
"message": map[string]interface{}{
|
|
"message_id": float64(1),
|
|
"text": "hello",
|
|
},
|
|
})
|
|
require.NoError(t, err)
|
|
}
|
|
|
|
func TestTelegramProvider_HandleWebhook_BadPayload_Cov6(t *testing.T) {
|
|
p := NewTelegramProvider()
|
|
err := p.HandleWebhook(context.Background(), map[string]interface{}{
|
|
"bad": make(chan int), // unmarshalable
|
|
})
|
|
require.Error(t, err)
|
|
}
|
|
|
|
func TestTelegramProvider_ProcessIncomingMessage_BadPayload_Cov6(t *testing.T) {
|
|
p := NewTelegramProvider()
|
|
_, err := p.ProcessIncomingMessage(context.Background(), &model.Inbox{}, map[string]interface{}{
|
|
"bad": make(chan int),
|
|
})
|
|
require.Error(t, err)
|
|
}
|
|
|
|
func TestTelegramProvider_ProcessIncomingMessage_NoContent_Cov6(t *testing.T) {
|
|
p := NewTelegramProvider()
|
|
_, err := p.ProcessIncomingMessage(context.Background(), &model.Inbox{}, map[string]interface{}{
|
|
"update_id": float64(123),
|
|
})
|
|
require.Error(t, err)
|
|
}
|
|
|
|
// ===========================
|
|
// WebWidgetProvider tests
|
|
// ===========================
|
|
|
|
func TestWebWidgetProvider_Type_Cov6(t *testing.T) {
|
|
p := NewWebWidgetProvider()
|
|
assert.Equal(t, channel.ChannelWebWidget, p.Type())
|
|
}
|
|
|
|
func TestWebWidgetProvider_Name_Cov6(t *testing.T) {
|
|
p := NewWebWidgetProvider()
|
|
assert.Equal(t, "Web Widget", p.Name())
|
|
}
|
|
|
|
func TestWebWidgetProvider_Description_Cov6(t *testing.T) {
|
|
p := NewWebWidgetProvider()
|
|
assert.NotEmpty(t, p.Description())
|
|
}
|
|
|
|
func TestWebWidgetProvider_ConfigSchema_Cov6(t *testing.T) {
|
|
p := NewWebWidgetProvider()
|
|
schema := p.ConfigSchema()
|
|
require.NotNil(t, schema)
|
|
assert.Equal(t, "object", schema.Type)
|
|
assert.Contains(t, schema.Required, "website_url")
|
|
}
|
|
|
|
func TestWebWidgetProvider_DefaultConfig_Cov6(t *testing.T) {
|
|
p := NewWebWidgetProvider()
|
|
cfg := p.DefaultConfig()
|
|
assert.Contains(t, cfg, "website_url")
|
|
assert.Contains(t, cfg, "widget_color")
|
|
}
|
|
|
|
func TestWebWidgetProvider_Capabilities_Cov6(t *testing.T) {
|
|
p := NewWebWidgetProvider()
|
|
caps := p.Capabilities()
|
|
assert.True(t, caps.SupportsAttachments)
|
|
assert.True(t, caps.SupportsTypingIndicator)
|
|
}
|
|
|
|
func TestWebWidgetProvider_ValidateConfig_NoURL_Cov6(t *testing.T) {
|
|
p := NewWebWidgetProvider()
|
|
err := p.ValidateConfig(context.Background(), channel.ChannelConfig{})
|
|
require.Error(t, err)
|
|
assert.Contains(t, err.Error(), "website_url")
|
|
}
|
|
|
|
func TestWebWidgetProvider_ValidateConfig_BadURL_Cov6(t *testing.T) {
|
|
p := NewWebWidgetProvider()
|
|
err := p.ValidateConfig(context.Background(), channel.ChannelConfig{
|
|
"website_url": "not-a-url",
|
|
})
|
|
require.Error(t, err)
|
|
assert.Contains(t, err.Error(), "valid URL")
|
|
}
|
|
|
|
func TestWebWidgetProvider_ValidateConfig_Success_Cov6(t *testing.T) {
|
|
p := NewWebWidgetProvider()
|
|
err := p.ValidateConfig(context.Background(), channel.ChannelConfig{
|
|
"website_url": "https://example.com",
|
|
})
|
|
require.NoError(t, err)
|
|
}
|
|
|
|
func TestWebWidgetProvider_OnCreate_Cov6(t *testing.T) {
|
|
p := NewWebWidgetProvider()
|
|
inbox := &model.Inbox{}
|
|
inbox.ID = 1
|
|
cfg, err := p.OnCreate(context.Background(), inbox, channel.ChannelConfig{
|
|
"website_url": "https://example.com",
|
|
})
|
|
require.NoError(t, err)
|
|
assert.Contains(t, cfg, "hmac_token")
|
|
assert.Contains(t, cfg, "website_token")
|
|
}
|
|
|
|
func TestWebWidgetProvider_OnDestroy_Cov6(t *testing.T) {
|
|
p := NewWebWidgetProvider()
|
|
inbox := &model.Inbox{}
|
|
err := p.OnDestroy(context.Background(), inbox, channel.ChannelConfig{})
|
|
require.NoError(t, err)
|
|
}
|
|
|
|
func TestWebWidgetProvider_ProcessIncoming_BadJSON_Cov6(t *testing.T) {
|
|
p := NewWebWidgetProvider()
|
|
inbox := &model.Inbox{}
|
|
_, err := p.ProcessIncoming(context.Background(), inbox, []byte("bad json"))
|
|
require.Error(t, err)
|
|
}
|
|
|
|
func TestWebWidgetProvider_ProcessIncoming_Success_Cov6(t *testing.T) {
|
|
p := NewWebWidgetProvider()
|
|
inbox := &model.Inbox{}
|
|
inbox.ID = 1
|
|
inbox.AccountID = 10
|
|
msg, err := p.ProcessIncoming(context.Background(), inbox, []byte(`{
|
|
"content": "hello world",
|
|
"contact_id": "contact1",
|
|
"contact_name": "John"
|
|
}`))
|
|
require.NoError(t, err)
|
|
require.NotNil(t, msg)
|
|
assert.Equal(t, "hello world", msg.Content)
|
|
}
|
|
|
|
func TestWebWidgetProvider_ValidateWebhookRequest_NoToken_Cov6(t *testing.T) {
|
|
p := NewWebWidgetProvider()
|
|
inbox := &model.Inbox{}
|
|
err := p.ValidateWebhookRequest(context.Background(), inbox, &channel.WebhookRequest{
|
|
Method: "POST",
|
|
Headers: map[string]string{},
|
|
})
|
|
require.NoError(t, err)
|
|
}
|
|
|
|
func TestWebWidgetProvider_ValidateWebhookRequest_WithToken_Cov6(t *testing.T) {
|
|
p := NewWebWidgetProvider()
|
|
inbox := &model.Inbox{}
|
|
err := p.ValidateWebhookRequest(context.Background(), inbox, &channel.WebhookRequest{
|
|
Method: "POST",
|
|
Headers: map[string]string{"X-Hmac-Token": "sometoken"},
|
|
})
|
|
require.NoError(t, err)
|
|
}
|
|
|
|
func TestWebWidgetProvider_SendMessage_Cov6(t *testing.T) {
|
|
p := NewWebWidgetProvider()
|
|
inbox := &model.Inbox{}
|
|
inbox.ID = 1
|
|
msg := &model.Message{}
|
|
msg.ID = 1
|
|
result, err := p.SendMessage(context.Background(), inbox, msg, &model.Contact{})
|
|
require.NoError(t, err)
|
|
require.NotNil(t, result)
|
|
assert.Contains(t, result.ExternalID, "widget_")
|
|
}
|
|
|
|
func TestWebWidgetProvider_GetContactProfile_Cov6(t *testing.T) {
|
|
p := NewWebWidgetProvider()
|
|
inbox := &model.Inbox{}
|
|
profile, err := p.GetContactProfile(context.Background(), inbox, "visitor123")
|
|
require.NoError(t, err)
|
|
require.NotNil(t, profile)
|
|
assert.Equal(t, "visitor123", profile.Name)
|
|
}
|
|
|
|
// ===========================
|
|
// EmailProvider (provider package) tests
|
|
// ===========================
|
|
|
|
func TestEmailProvider_Type_Cov6(t *testing.T) {
|
|
p := NewEmailProvider()
|
|
assert.Equal(t, channel.ChannelEmail, p.Type())
|
|
}
|
|
|
|
func TestEmailProvider_Name_Cov6(t *testing.T) {
|
|
p := NewEmailProvider()
|
|
assert.Equal(t, "Email", p.Name())
|
|
}
|
|
|
|
func TestEmailProvider_Description_Cov6(t *testing.T) {
|
|
p := NewEmailProvider()
|
|
assert.NotEmpty(t, p.Description())
|
|
}
|
|
|
|
func TestEmailProvider_ConfigSchema_Cov6(t *testing.T) {
|
|
p := NewEmailProvider()
|
|
schema := p.ConfigSchema()
|
|
require.NotNil(t, schema)
|
|
assert.Equal(t, "object", schema.Type)
|
|
assert.Contains(t, schema.Required, "email")
|
|
}
|
|
|
|
func TestEmailProvider_DefaultConfig_Cov6(t *testing.T) {
|
|
p := NewEmailProvider()
|
|
cfg := p.DefaultConfig()
|
|
assert.Contains(t, cfg, "email")
|
|
assert.Contains(t, cfg, "imap_enabled")
|
|
assert.Contains(t, cfg, "smtp_enabled")
|
|
}
|
|
|
|
func TestEmailProvider_Capabilities_Cov6(t *testing.T) {
|
|
p := NewEmailProvider()
|
|
caps := p.Capabilities()
|
|
assert.True(t, caps.SupportsAttachments)
|
|
assert.True(t, caps.SupportsReplies)
|
|
assert.True(t, caps.SupportsEmailHeaders)
|
|
}
|
|
|
|
func TestEmailProvider_PollInterval_Cov6(t *testing.T) {
|
|
p := NewEmailProvider()
|
|
assert.True(t, p.PollInterval() > 0)
|
|
}
|
|
|
|
func TestEmailProvider_ValidateConfig_NoEmail_Cov6(t *testing.T) {
|
|
p := NewEmailProvider()
|
|
err := p.ValidateConfig(context.Background(), channel.ChannelConfig{})
|
|
require.Error(t, err)
|
|
assert.Contains(t, err.Error(), "email is required")
|
|
}
|
|
|
|
func TestEmailProvider_ValidateConfig_BadEmail_Cov6(t *testing.T) {
|
|
p := NewEmailProvider()
|
|
err := p.ValidateConfig(context.Background(), channel.ChannelConfig{
|
|
"email": "not-an-email",
|
|
})
|
|
require.Error(t, err)
|
|
assert.Contains(t, err.Error(), "invalid")
|
|
}
|
|
|
|
func TestEmailProvider_ValidateConfig_ValidEmail_Cov6(t *testing.T) {
|
|
p := NewEmailProvider()
|
|
err := p.ValidateConfig(context.Background(), channel.ChannelConfig{
|
|
"email": "test@example.com",
|
|
})
|
|
require.NoError(t, err)
|
|
}
|
|
|
|
func TestEmailProvider_ValidateConfig_IMAPEnabled_NoAddress_Cov6(t *testing.T) {
|
|
p := NewEmailProvider()
|
|
err := p.ValidateConfig(context.Background(), channel.ChannelConfig{
|
|
"email": "test@example.com",
|
|
"imap_enabled": true,
|
|
})
|
|
require.Error(t, err)
|
|
assert.Contains(t, err.Error(), "imap_address")
|
|
}
|
|
|
|
func TestEmailProvider_ValidateConfig_IMAPEnabled_NoLogin_Cov6(t *testing.T) {
|
|
p := NewEmailProvider()
|
|
err := p.ValidateConfig(context.Background(), channel.ChannelConfig{
|
|
"email": "test@example.com",
|
|
"imap_enabled": true,
|
|
"imap_address": "imap.example.com",
|
|
})
|
|
require.Error(t, err)
|
|
assert.Contains(t, err.Error(), "imap_login")
|
|
}
|
|
|
|
func TestEmailProvider_ValidateConfig_IMAPEnabled_NoPassword_Cov6(t *testing.T) {
|
|
p := NewEmailProvider()
|
|
err := p.ValidateConfig(context.Background(), channel.ChannelConfig{
|
|
"email": "test@example.com",
|
|
"imap_enabled": true,
|
|
"imap_address": "imap.example.com",
|
|
"imap_login": "user",
|
|
})
|
|
require.Error(t, err)
|
|
assert.Contains(t, err.Error(), "imap_password")
|
|
}
|
|
|
|
func TestEmailProvider_ValidateConfig_SMTPEnabled_NoAddress_Cov6(t *testing.T) {
|
|
p := NewEmailProvider()
|
|
err := p.ValidateConfig(context.Background(), channel.ChannelConfig{
|
|
"email": "test@example.com",
|
|
"smtp_enabled": true,
|
|
})
|
|
require.Error(t, err)
|
|
assert.Contains(t, err.Error(), "smtp_address")
|
|
}
|
|
|
|
func TestEmailProvider_ValidateConfig_SMTPEnabled_NoLogin_Cov6(t *testing.T) {
|
|
p := NewEmailProvider()
|
|
err := p.ValidateConfig(context.Background(), channel.ChannelConfig{
|
|
"email": "test@example.com",
|
|
"smtp_enabled": true,
|
|
"smtp_address": "smtp.example.com",
|
|
})
|
|
require.Error(t, err)
|
|
assert.Contains(t, err.Error(), "smtp_login")
|
|
}
|
|
|
|
func TestEmailProvider_ValidateConfig_SMTPEnabled_NoPassword_Cov6(t *testing.T) {
|
|
p := NewEmailProvider()
|
|
err := p.ValidateConfig(context.Background(), channel.ChannelConfig{
|
|
"email": "test@example.com",
|
|
"smtp_enabled": true,
|
|
"smtp_address": "smtp.example.com",
|
|
"smtp_login": "user",
|
|
})
|
|
require.Error(t, err)
|
|
assert.Contains(t, err.Error(), "smtp_password")
|
|
}
|
|
|
|
func TestEmailProvider_ValidateConfig_BadIMAPPort_Cov6(t *testing.T) {
|
|
p := NewEmailProvider()
|
|
err := p.ValidateConfig(context.Background(), channel.ChannelConfig{
|
|
"email": "test@example.com",
|
|
"imap_enabled": true,
|
|
"imap_address": "imap.example.com",
|
|
"imap_login": "user",
|
|
"imap_password": "pass",
|
|
"imap_port": float64(99999),
|
|
})
|
|
require.Error(t, err)
|
|
assert.Contains(t, err.Error(), "imap_port")
|
|
}
|
|
|
|
func TestEmailProvider_ValidateConfig_BadSMTPPort_Cov6(t *testing.T) {
|
|
p := NewEmailProvider()
|
|
err := p.ValidateConfig(context.Background(), channel.ChannelConfig{
|
|
"email": "test@example.com",
|
|
"smtp_enabled": true,
|
|
"smtp_address": "smtp.example.com",
|
|
"smtp_login": "user",
|
|
"smtp_password": "pass",
|
|
"smtp_port": float64(99999),
|
|
})
|
|
require.Error(t, err)
|
|
assert.Contains(t, err.Error(), "smtp_port")
|
|
}
|
|
|
|
func TestEmailProvider_OnCreate_NoEmail_Cov6(t *testing.T) {
|
|
p := NewEmailProvider()
|
|
inbox := &model.Inbox{}
|
|
inbox.ID = 1
|
|
_, err := p.OnCreate(context.Background(), inbox, channel.ChannelConfig{})
|
|
require.Error(t, err)
|
|
}
|
|
|
|
func TestEmailProvider_OnCreate_Success_Cov6(t *testing.T) {
|
|
p := NewEmailProvider()
|
|
inbox := &model.Inbox{}
|
|
inbox.ID = 1
|
|
cfg, err := p.OnCreate(context.Background(), inbox, channel.ChannelConfig{
|
|
"email": "test@example.com",
|
|
})
|
|
require.NoError(t, err)
|
|
assert.Contains(t, cfg, "forward_to_address")
|
|
assert.Contains(t, cfg, "domain")
|
|
}
|
|
|
|
func TestEmailProvider_OnCreate_WithForward_Cov6(t *testing.T) {
|
|
p := NewEmailProvider()
|
|
inbox := &model.Inbox{}
|
|
inbox.ID = 1
|
|
cfg, err := p.OnCreate(context.Background(), inbox, channel.ChannelConfig{
|
|
"email": "test@example.com",
|
|
"forward_to_address": "custom@forward.com",
|
|
})
|
|
require.NoError(t, err)
|
|
assert.Equal(t, "custom@forward.com", cfg["forward_to_address"])
|
|
}
|
|
|
|
func TestEmailProvider_OnDestroy_Cov6(t *testing.T) {
|
|
p := NewEmailProvider()
|
|
inbox := &model.Inbox{}
|
|
err := p.OnDestroy(context.Background(), inbox, channel.ChannelConfig{
|
|
"email": "test@example.com",
|
|
})
|
|
require.NoError(t, err)
|
|
}
|
|
|
|
func TestEmailProvider_ProcessIncoming_BadJSON_Cov6(t *testing.T) {
|
|
p := NewEmailProvider()
|
|
inbox := &model.Inbox{}
|
|
_, err := p.ProcessIncoming(context.Background(), inbox, []byte("bad json"))
|
|
require.Error(t, err)
|
|
}
|
|
|
|
func TestEmailProvider_ProcessIncoming_Success_Cov6(t *testing.T) {
|
|
p := NewEmailProvider()
|
|
inbox := &model.Inbox{}
|
|
inbox.ID = 1
|
|
inbox.AccountID = 10
|
|
payload := `{"message_id":"msg1","from":"sender@test.com","from_name":"Sender","subject":"Test","text_content":"hello"}`
|
|
msg, err := p.ProcessIncoming(context.Background(), inbox, []byte(payload))
|
|
require.NoError(t, err)
|
|
require.NotNil(t, msg)
|
|
assert.Equal(t, "hello", msg.Content)
|
|
}
|
|
|
|
func TestEmailProvider_ValidateWebhookRequest_Cov6(t *testing.T) {
|
|
p := NewEmailProvider()
|
|
inbox := &model.Inbox{}
|
|
err := p.ValidateWebhookRequest(context.Background(), inbox, &channel.WebhookRequest{})
|
|
require.NoError(t, err)
|
|
}
|
|
|
|
func TestEmailProvider_SendMessage_NoService_Cov6(t *testing.T) {
|
|
p := NewEmailProvider()
|
|
inbox := &model.Inbox{}
|
|
_, err := p.SendMessage(context.Background(), inbox, &model.Message{}, &model.Contact{})
|
|
require.Error(t, err)
|
|
}
|
|
|
|
func TestEmailProvider_SendMessage_WithMockService_Cov6(t *testing.T) {
|
|
p := NewEmailProvider()
|
|
p.SetService(&mockEmailServiceCov6{})
|
|
inbox := &model.Inbox{}
|
|
inbox.ID = 1
|
|
inbox.ChannelConfig = `{"smtp_enabled":true,"smtp_address":"smtp.test.com","email":"from@test.com"}`
|
|
msg := &model.Message{}
|
|
msg.Content = "test message"
|
|
contact := &model.Contact{}
|
|
contact.Identifier = "to@test.com"
|
|
result, err := p.SendMessage(context.Background(), inbox, msg, contact)
|
|
require.NoError(t, err)
|
|
require.NotNil(t, result)
|
|
assert.Equal(t, "mock_msg_id", result.ExternalID)
|
|
}
|
|
|
|
func TestEmailProvider_SendMessage_SMTPDisabled_Cov6(t *testing.T) {
|
|
p := NewEmailProvider()
|
|
p.SetService(&mockEmailServiceCov6{})
|
|
inbox := &model.Inbox{}
|
|
inbox.ID = 1
|
|
inbox.ChannelConfig = `{"smtp_enabled":false}`
|
|
_, err := p.SendMessage(context.Background(), inbox, &model.Message{}, &model.Contact{})
|
|
require.Error(t, err)
|
|
assert.Contains(t, err.Error(), "not enabled")
|
|
}
|
|
|
|
func TestEmailProvider_SendMessage_NoContact_Cov6(t *testing.T) {
|
|
p := NewEmailProvider()
|
|
p.SetService(&mockEmailServiceCov6{})
|
|
inbox := &model.Inbox{}
|
|
inbox.ID = 1
|
|
inbox.ChannelConfig = `{"smtp_enabled":true,"smtp_address":"smtp.test.com","email":"from@test.com"}`
|
|
_, err := p.SendMessage(context.Background(), inbox, &model.Message{}, &model.Contact{})
|
|
require.Error(t, err)
|
|
assert.Contains(t, err.Error(), "no email address")
|
|
}
|
|
|
|
func TestEmailProvider_GetContactProfile_Cov6(t *testing.T) {
|
|
p := NewEmailProvider()
|
|
inbox := &model.Inbox{}
|
|
profile, err := p.GetContactProfile(context.Background(), inbox, "user@test.com")
|
|
require.NoError(t, err)
|
|
require.NotNil(t, profile)
|
|
assert.Equal(t, "user@test.com", profile.Name)
|
|
}
|
|
|
|
func TestEmailProvider_PollMessages_NoService_Cov6(t *testing.T) {
|
|
p := NewEmailProvider()
|
|
inbox := &model.Inbox{}
|
|
msgs, err := p.PollMessages(context.Background(), inbox)
|
|
require.NoError(t, err)
|
|
assert.Nil(t, msgs)
|
|
}
|
|
|
|
func TestEmailProvider_PollMessages_IMAPDisabled_Cov6(t *testing.T) {
|
|
p := NewEmailProvider()
|
|
p.SetService(&mockEmailServiceCov6{})
|
|
inbox := &model.Inbox{}
|
|
inbox.ID = 1
|
|
inbox.ChannelConfig = `{"imap_enabled":false}`
|
|
msgs, err := p.PollMessages(context.Background(), inbox)
|
|
require.NoError(t, err)
|
|
assert.Nil(t, msgs)
|
|
}
|
|
|
|
func TestEmailProvider_PollMessages_BadConfig_Cov6(t *testing.T) {
|
|
p := NewEmailProvider()
|
|
p.SetService(&mockEmailServiceCov6{})
|
|
inbox := &model.Inbox{}
|
|
inbox.ID = 1
|
|
inbox.ChannelConfig = `bad json`
|
|
msgs, err := p.PollMessages(context.Background(), inbox)
|
|
require.NoError(t, err)
|
|
assert.Nil(t, msgs)
|
|
}
|
|
|
|
func TestEmailProvider_PollMessages_IncompleteConfig_Cov6(t *testing.T) {
|
|
p := NewEmailProvider()
|
|
p.SetService(&mockEmailServiceCov6{})
|
|
inbox := &model.Inbox{}
|
|
inbox.ID = 1
|
|
inbox.ChannelConfig = `{"imap_enabled":true}`
|
|
msgs, err := p.PollMessages(context.Background(), inbox)
|
|
require.NoError(t, err)
|
|
assert.Nil(t, msgs)
|
|
}
|
|
|
|
func TestEmailProvider_PollMessages_Success_Cov6(t *testing.T) {
|
|
p := NewEmailProvider()
|
|
p.SetService(&mockEmailServiceCov6{})
|
|
inbox := &model.Inbox{}
|
|
inbox.ID = 1
|
|
inbox.ChannelConfig = `{"imap_enabled":true,"imap_address":"imap.test.com","imap_login":"user","imap_password":"pass"}`
|
|
msgs, err := p.PollMessages(context.Background(), inbox)
|
|
require.NoError(t, err)
|
|
assert.Len(t, msgs, 1)
|
|
}
|
|
|
|
// ===========================
|
|
// Helper function tests
|
|
// ===========================
|
|
|
|
func TestInboxConfigMap_Empty_Cov6(t *testing.T) {
|
|
cfg, err := inboxConfigMap(&model.Inbox{})
|
|
require.NoError(t, err)
|
|
assert.Empty(t, cfg)
|
|
}
|
|
|
|
func TestInboxConfigMap_BadJSON_Cov6(t *testing.T) {
|
|
_, err := inboxConfigMap(&model.Inbox{ChannelConfig: "bad json"})
|
|
require.Error(t, err)
|
|
}
|
|
|
|
func TestInboxConfigMap_Success_Cov6(t *testing.T) {
|
|
cfg, err := inboxConfigMap(&model.Inbox{ChannelConfig: `{"key":"value"}`})
|
|
require.NoError(t, err)
|
|
assert.Equal(t, "value", cfg["key"])
|
|
}
|
|
|
|
func TestInboxConfigValue_Empty_Cov6(t *testing.T) {
|
|
v := inboxConfigValue(&model.Inbox{}, "key")
|
|
assert.Empty(t, v)
|
|
}
|
|
|
|
func TestInboxConfigValue_String_Cov6(t *testing.T) {
|
|
v := inboxConfigValue(&model.Inbox{ChannelConfig: `{"key":"value"}`}, "key")
|
|
assert.Equal(t, "value", v)
|
|
}
|
|
|
|
func TestInboxConfigValue_Bool_Cov6(t *testing.T) {
|
|
v := inboxConfigValue(&model.Inbox{ChannelConfig: `{"key":true}`}, "key")
|
|
assert.Equal(t, "true", v)
|
|
}
|
|
|
|
func TestInboxConfigValue_Int_Cov6(t *testing.T) {
|
|
v := inboxConfigValue(&model.Inbox{ChannelConfig: `{"key":42}`}, "key")
|
|
assert.Equal(t, "42", v)
|
|
}
|
|
|
|
func TestStripHTMLTags_Cov6(t *testing.T) {
|
|
result := stripHTMLTags("<p>Hello</p>")
|
|
assert.Equal(t, "Hello", result)
|
|
}
|
|
|
|
func TestStripHTMLTags_Entities_Cov6(t *testing.T) {
|
|
result := stripHTMLTags("<p>Hello & goodbye</p>")
|
|
assert.Equal(t, "Hello & goodbye", result)
|
|
}
|
|
|
|
func TestBuildEmailSubject_Cov6(t *testing.T) {
|
|
inbox := &model.Inbox{}
|
|
msg := &model.Message{}
|
|
msg.Content = "test message"
|
|
subject := buildEmailSubject(inbox, msg, channel.ChannelConfig{})
|
|
assert.Contains(t, subject, "Support")
|
|
assert.Contains(t, subject, "test message")
|
|
}
|
|
|
|
func TestBuildEmailSubject_LongContent_Cov6(t *testing.T) {
|
|
inbox := &model.Inbox{}
|
|
msg := &model.Message{}
|
|
msg.Content = "this is a very long message that exceeds fifty characters and should be truncated with dots"
|
|
subject := buildEmailSubject(inbox, msg, channel.ChannelConfig{})
|
|
assert.Contains(t, subject, "...")
|
|
}
|
|
|
|
func TestBuildEmailSubject_WithMailboxName_Cov6(t *testing.T) {
|
|
inbox := &model.Inbox{}
|
|
msg := &model.Message{}
|
|
msg.Content = "test"
|
|
subject := buildEmailSubject(inbox, msg, channel.ChannelConfig{
|
|
"mailbox_name": "Custom",
|
|
})
|
|
assert.Contains(t, subject, "Custom")
|
|
}
|
|
|
|
// ===========================
|
|
// Mock types
|
|
// ===========================
|
|
|
|
type mockProviderCov6 struct {
|
|
name string
|
|
}
|
|
|
|
func (m *mockProviderCov6) Name() string { return m.name }
|
|
func (m *mockProviderCov6) CreateChannel(ctx context.Context, accountID uint, params map[string]interface{}) (channelmodel.Channelable, error) {
|
|
return nil, nil
|
|
}
|
|
func (m *mockProviderCov6) UpdateChannel(ctx context.Context, channelID uint, params map[string]interface{}) (channelmodel.Channelable, error) {
|
|
return nil, nil
|
|
}
|
|
func (m *mockProviderCov6) DeleteChannel(ctx context.Context, channelID uint) error { return nil }
|
|
func (m *mockProviderCov6) HandleWebhook(ctx context.Context, payload map[string]interface{}) error {
|
|
return nil
|
|
}
|
|
func (m *mockProviderCov6) ProcessIncomingMessage(ctx context.Context, inboxID uint, contactID uint, payload map[string]interface{}) (*IncomingMessageResult, error) {
|
|
return nil, nil
|
|
}
|
|
func (m *mockProviderCov6) ProcessOutgoingMessage(ctx context.Context, conversationID uint, messageID uint, content string) error {
|
|
return nil
|
|
}
|
|
func (m *mockProviderCov6) ValidateConfig(params map[string]interface{}) error { return nil }
|
|
|
|
type mockEmailServiceCov6 struct{}
|
|
|
|
func (m *mockEmailServiceCov6) ValidateIMAPConnection(config channel.ChannelConfig) error { return nil }
|
|
func (m *mockEmailServiceCov6) ValidateSMTPConnection(config channel.ChannelConfig) error { return nil }
|
|
func (m *mockEmailServiceCov6) FetchIMAPMessages(ctx context.Context, inbox *model.Inbox, config channel.ChannelConfig) ([]*channel.IncomingMessage, error) {
|
|
return []*channel.IncomingMessage{{Content: "test"}}, nil
|
|
}
|
|
func (m *mockEmailServiceCov6) SendViaSMTP(config channel.ChannelConfig, from, to, subject, body string) (string, error) {
|
|
return "mock_msg_id", nil
|
|
}
|