122 lines
3.9 KiB
Go
122 lines
3.9 KiB
Go
package channel
|
|
|
|
import (
|
|
"context"
|
|
"testing"
|
|
|
|
"github.com/gochat/gochat/internal/model"
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
// mockProvider implements ChannelProvider for testing
|
|
type mockProvider struct {
|
|
channelType ChannelType
|
|
}
|
|
|
|
func (m *mockProvider) Type() ChannelType { return m.channelType }
|
|
func (m *mockProvider) Name() string { return string(m.channelType) }
|
|
func (m *mockProvider) Description() string { return "Mock " + string(m.channelType) }
|
|
func (m *mockProvider) ConfigSchema() *ConfigSchemaDefinition { return nil }
|
|
func (m *mockProvider) ValidateConfig(ctx context.Context, c ChannelConfig) error { return nil }
|
|
func (m *mockProvider) DefaultConfig() ChannelConfig { return ChannelConfig{} }
|
|
func (m *mockProvider) OnCreate(ctx context.Context, inbox *model.Inbox, c ChannelConfig) (ChannelConfig, error) {
|
|
return c, nil
|
|
}
|
|
func (m *mockProvider) OnDestroy(ctx context.Context, inbox *model.Inbox, c ChannelConfig) error {
|
|
return nil
|
|
}
|
|
func (m *mockProvider) ProcessIncoming(ctx context.Context, inbox *model.Inbox, raw []byte) (*IncomingMessage, error) {
|
|
return &IncomingMessage{InboxID: inbox.ID}, nil
|
|
}
|
|
func (m *mockProvider) ValidateWebhookRequest(ctx context.Context, inbox *model.Inbox, req *WebhookRequest) error {
|
|
return nil
|
|
}
|
|
func (m *mockProvider) SendMessage(ctx context.Context, inbox *model.Inbox, msg *model.Message, contact *model.Contact) (*SendResult, error) {
|
|
return &SendResult{}, nil
|
|
}
|
|
func (m *mockProvider) GetContactProfile(ctx context.Context, inbox *model.Inbox, src string) (*ContactProfile, error) {
|
|
return &ContactProfile{}, nil
|
|
}
|
|
func (m *mockProvider) Capabilities() ChannelCapabilities { return ChannelCapabilities{} }
|
|
|
|
func TestRegistry_RegisterAndGet(t *testing.T) {
|
|
ct := ChannelType("test_mock_unique2")
|
|
provider := &mockProvider{channelType: ct}
|
|
|
|
err := Register(provider)
|
|
require.NoError(t, err)
|
|
|
|
got, err := Get(ct)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, ct, got.Type())
|
|
}
|
|
|
|
func TestRegistry_Get_NotRegistered(t *testing.T) {
|
|
_, err := Get(ChannelType("nonexistent_type_xyz"))
|
|
require.Error(t, err)
|
|
}
|
|
|
|
func TestRegistry_Register_Duplicate(t *testing.T) {
|
|
ct := ChannelType("test_dup2")
|
|
provider := &mockProvider{channelType: ct}
|
|
|
|
err := Register(provider)
|
|
require.NoError(t, err)
|
|
|
|
err = Register(provider)
|
|
require.Error(t, err)
|
|
}
|
|
|
|
func TestRegistry_IsRegistered(t *testing.T) {
|
|
ct := ChannelType("test_isregistered2")
|
|
provider := &mockProvider{channelType: ct}
|
|
|
|
assert.False(t, IsRegistered(ct))
|
|
_ = Register(provider)
|
|
assert.True(t, IsRegistered(ct))
|
|
}
|
|
|
|
func TestRegistry_List(t *testing.T) {
|
|
types := List()
|
|
assert.NotEmpty(t, types)
|
|
}
|
|
|
|
func TestRegistry_ListProviders(t *testing.T) {
|
|
providers := ListProviders()
|
|
assert.NotEmpty(t, providers)
|
|
}
|
|
|
|
func TestRegistry_GetRegistry(t *testing.T) {
|
|
r := GetRegistry()
|
|
assert.NotNil(t, r)
|
|
}
|
|
|
|
func TestRegistry_ProcessIncomingMessage_NotFound(t *testing.T) {
|
|
_, err := ProcessIncomingMessage(context.Background(), ChannelType("nonexistent"), &model.Inbox{}, []byte("{}"))
|
|
require.Error(t, err)
|
|
}
|
|
|
|
func TestRegistry_SendMessageToChannel_NotFound(t *testing.T) {
|
|
_, err := SendMessageToChannel(context.Background(), ChannelType("nonexistent"), &model.Inbox{}, &model.Message{}, &model.Contact{})
|
|
require.Error(t, err)
|
|
}
|
|
|
|
func TestRegistry_ValidateWebhookRequest_NotFound(t *testing.T) {
|
|
err := ValidateWebhookRequest(context.Background(), ChannelType("nonexistent"), &model.Inbox{}, &WebhookRequest{})
|
|
require.Error(t, err)
|
|
}
|
|
|
|
func TestRegistry_InstanceMethods(t *testing.T) {
|
|
r := &ChannelRegistry{providers: make(map[ChannelType]ChannelProvider)}
|
|
ct := ChannelType("instance_test2")
|
|
provider := &mockProvider{channelType: ct}
|
|
|
|
err := r.RegisterOnInstance(provider)
|
|
require.NoError(t, err)
|
|
|
|
got, err := r.Get(ct)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, ct, got.Type())
|
|
}
|