osmedeus/internal/notify/telegram_test.go

package notify

import (
	"os"
	"path/filepath"
	"testing"

	"github.com/j3ssie/osmedeus/v5/internal/config"
	"github.com/stretchr/testify/assert"
)

// NewTelegramClient validation tests

func TestNewTelegramClient_EmptyToken(t *testing.T) {
	cfg := &config.TelegramConfig{
		BotToken: "",
		ChatID:   123456789,
		Enabled:  true,
	}

	client, err := NewTelegramClient(cfg)
	assert.Error(t, err)
	assert.Nil(t, client)
	assert.Contains(t, err.Error(), "telegram bot token is required")
}

func TestNewTelegramClient_ZeroChatID(t *testing.T) {
	cfg := &config.TelegramConfig{
		BotToken: "1234567890:ABCdefGHIjklMNOpqrsTUVwxyz",
		ChatID:   0,
		Enabled:  true,
	}

	client, err := NewTelegramClient(cfg)
	assert.Error(t, err)
	assert.Nil(t, client)
	assert.Contains(t, err.Error(), "telegram chat ID is required")
}

// Note: Testing actual Telegram client creation with a valid token is skipped
// because it requires making an API call to validate the bot token.
// The validation tests above cover the input validation logic.

// File existence tests
// These tests verify the file existence checks without making actual API calls

func TestSendFile_FileNotFound(t *testing.T) {
	// Create a mock client with nil bot (we only test file existence check)
	client := &TelegramClient{
		bot:    nil,
		chatID: 123456789,
	}

	err := client.SendFile("/nonexistent/path/to/file.txt")
	assert.Error(t, err)
	assert.Contains(t, err.Error(), "file not found: /nonexistent/path/to/file.txt")
}

func TestSendFileWithCaption_FileNotFound(t *testing.T) {
	client := &TelegramClient{
		bot:    nil,
		chatID: 123456789,
	}

	err := client.SendFileWithCaption("/nonexistent/path/to/file.txt", "caption")
	assert.Error(t, err)
	assert.Contains(t, err.Error(), "file not found: /nonexistent/path/to/file.txt")
}

func TestSendPhoto_FileNotFound(t *testing.T) {
	client := &TelegramClient{
		bot:    nil,
		chatID: 123456789,
	}

	err := client.SendPhoto("/nonexistent/path/to/photo.jpg")
	assert.Error(t, err)
	assert.Contains(t, err.Error(), "file not found: /nonexistent/path/to/photo.jpg")
}

func TestSendPhotoWithCaption_FileNotFound(t *testing.T) {
	client := &TelegramClient{
		bot:    nil,
		chatID: 123456789,
	}

	err := client.SendPhotoWithCaption("/nonexistent/path/to/photo.jpg", "caption")
	assert.Error(t, err)
	assert.Contains(t, err.Error(), "file not found: /nonexistent/path/to/photo.jpg")
}

// Test file existence check passes with existing file (but API call will fail)
func TestSendFile_FileExists_ButNoBot(t *testing.T) {
	tmpDir := t.TempDir()
	testFile := filepath.Join(tmpDir, "test.txt")
	err := os.WriteFile(testFile, []byte("test content"), 0644)
	assert.NoError(t, err)

	// Client with nil bot - file exists but bot is nil
	client := &TelegramClient{
		bot:    nil,
		chatID: 123456789,
	}

	// This should panic or fail because bot is nil after the file check passes
	// We use recover to catch the panic
	func() {
		defer func() {
			if r := recover(); r != nil {
				// Expected - bot is nil, panic is expected behavior
				_ = r // Silence staticcheck SA9003
			}
		}()
		_ = client.SendFile(testFile)
	}()
}

// Global function tests

func TestNewTelegramClientFromGlobal_NoConfig(t *testing.T) {
	config.Set(nil)

	client, err := NewTelegramClientFromGlobal()
	assert.Error(t, err)
	assert.Nil(t, client)
	assert.Contains(t, err.Error(), "global config not loaded")
}

func TestNewTelegramClientFromGlobal_NotConfigured(t *testing.T) {
	cfg := &config.Config{
		Notification: config.NotificationConfig{
			Provider: "telegram",
			Enabled:  false, // Disabled
			Telegram: config.TelegramConfig{
				BotToken: "",
				ChatID:   0,
				Enabled:  false,
			},
		},
	}
	config.Set(cfg)
	t.Cleanup(func() { config.Set(nil) })

	client, err := NewTelegramClientFromGlobal()
	assert.Error(t, err)
	assert.Nil(t, client)
	assert.Contains(t, err.Error(), "telegram not configured")
}

func TestNewTelegramClientFromGlobal_TelegramNotEnabled(t *testing.T) {
	cfg := &config.Config{
		Notification: config.NotificationConfig{
			Provider: "webhook", // Not telegram
			Enabled:  true,
			Telegram: config.TelegramConfig{
				BotToken: "token",
				ChatID:   123,
				Enabled:  false,
			},
		},
	}
	config.Set(cfg)
	t.Cleanup(func() { config.Set(nil) })

	client, err := NewTelegramClientFromGlobal()
	assert.Error(t, err)
	assert.Nil(t, client)
	assert.Contains(t, err.Error(), "telegram not configured")
}

// SendTelegramNotification format test
// Note: This only verifies that the format function works correctly
// Actual sending requires a real Telegram bot
func TestSendTelegramNotification_Format(t *testing.T) {
	// Verify the format by checking what message would be sent
	title := "Test Title"
	message := "This is the message body"
	expectedFormat := "*Test Title*\n\nThis is the message body"

	// We can't call the actual function without a configured Telegram bot,
	// but we can verify the format is correct by checking the code
	// The format is: fmt.Sprintf("*%s*\n\n%s", title, message)
	actualFormat := "*" + title + "*\n\n" + message
	assert.Equal(t, expectedFormat, actualFormat)
}

// SendTelegramMessage tests

func TestSendTelegramMessage_NoGlobalConfig(t *testing.T) {
	config.Set(nil)

	err := SendTelegramMessage("test message")
	assert.Error(t, err)
	assert.Contains(t, err.Error(), "global config not loaded")
}

func TestSendTelegramMessage_NotConfigured(t *testing.T) {
	cfg := &config.Config{
		Notification: config.NotificationConfig{
			Provider: "telegram",
			Enabled:  false,
			Telegram: config.TelegramConfig{
				BotToken: "",
				ChatID:   0,
				Enabled:  false,
			},
		},
	}
	config.Set(cfg)
	t.Cleanup(func() { config.Set(nil) })

	err := SendTelegramMessage("test message")
	assert.Error(t, err)
	assert.Contains(t, err.Error(), "telegram not configured")
}

// SendTelegramFile tests

func TestSendTelegramFile_NoGlobalConfig(t *testing.T) {
	config.Set(nil)

	err := SendTelegramFile("/some/file.txt")
	assert.Error(t, err)
	assert.Contains(t, err.Error(), "global config not loaded")
}

func TestSendTelegramFile_NotConfigured(t *testing.T) {
	cfg := &config.Config{
		Notification: config.NotificationConfig{
			Provider: "telegram",
			Enabled:  false,
			Telegram: config.TelegramConfig{
				BotToken: "",
				ChatID:   0,
				Enabled:  false,
			},
		},
	}
	config.Set(cfg)
	t.Cleanup(func() { config.Set(nil) })

	err := SendTelegramFile("/some/file.txt")
	assert.Error(t, err)
	assert.Contains(t, err.Error(), "telegram not configured")
}

// SendTelegramNotification tests

func TestSendTelegramNotification_NoGlobalConfig(t *testing.T) {
	config.Set(nil)

	err := SendTelegramNotification("Title", "Message")
	assert.Error(t, err)
	assert.Contains(t, err.Error(), "global config not loaded")
}

func TestSendTelegramNotification_NotConfigured(t *testing.T) {
	cfg := &config.Config{
		Notification: config.NotificationConfig{
			Provider: "telegram",
			Enabled:  false,
			Telegram: config.TelegramConfig{
				BotToken: "",
				ChatID:   0,
				Enabled:  false,
			},
		},
	}
	config.Set(cfg)
	t.Cleanup(func() { config.Set(nil) })

	err := SendTelegramNotification("Title", "Message")
	assert.Error(t, err)
	assert.Contains(t, err.Error(), "telegram not configured")
}