logger_test.go

package gtl

import (
	"crypto/rand"
	"encoding/base64"
	"errors"
	"testing"

	"github.com/cheatsnake/gtl/internal/telegram"
)

func TestNew(t *testing.T) {
	testBotToken := randomString(8)
	testChatID := randomString(8)

	tests := []struct {
		name        string
		botToken    string
		opts        Options
		expectedErr string
	}{
		{
			name:        "Valid parameters",
			botToken:    testBotToken,
			opts:        Options{ChatID: testChatID},
			expectedErr: "",
		},
		{
			name:        "Empty bot token",
			botToken:    "",
			opts:        Options{ChatID: testChatID},
			expectedErr: botTokenRequiredErr,
		},
		{
			name:        "Empty chat ID",
			botToken:    testBotToken,
			opts:        Options{ChatID: ""},
			expectedErr: chatIdRequiredErr,
		},
		{
			name:        "Empty bot token and chat ID",
			botToken:    "",
			opts:        Options{ChatID: ""},
			expectedErr: botTokenRequiredErr,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			_, err := New(tt.botToken, tt.opts)

			if tt.expectedErr == "" {
				if err != nil {
					t.Fatalf("expected no error, got %v", err)
				}
			} else {
				if err == nil {
					t.Fatalf("expected error %q, got nil", tt.expectedErr)
				}
				if err.Error() != tt.expectedErr {
					t.Errorf("expected error %q, got %q", tt.expectedErr, err.Error())
				}
			}
		})
	}
}

func TestLoggerOptions(t *testing.T) {
	defaultOpts := Options{ChatID: randomString(8)}
	logger, err := New(randomString(8), defaultOpts)
	if err != nil {
		t.Fatalf("expected no error, got %v", err)
	}

	t.Run("Default options", func(t *testing.T) {
		if defaultOpts != logger.Options {
			t.Fatalf("expected %v, got %v", defaultOpts, logger.Options)
		}
	})

	t.Run("Override options", func(t *testing.T) {
		logger.Ok("", Options{
			ChatID:              randomString(8),
			ThreadID:            1,
			ParseMode:           "MarkdownV2",
			DisableNotification: true,
			WrapAsCode:          true,
			CodeExtension:       randomString(8),
			TimeMetadata:        true,
		})

		if defaultOpts != logger.Options {
			t.Fatalf("expected %v, got %v", defaultOpts, logger.Options)
		}
	})

}

type MockBot struct {
	shouldFail bool
}

func (mb *MockBot) SendMessage(text string, chatID string, threadID int, parseMode string, disableNotify bool) (*telegram.Response, error) {
	if mb.shouldFail {
		return &telegram.Response{}, errors.New("fail")
	}

	return &telegram.Response{}, nil
}

func TestLoggerMethods(t *testing.T) {
	t.Run("Valid logs", func(t *testing.T) {
		logger := &Logger{
			botAPI:  &MockBot{shouldFail: false},
			Options: Options{ChatID: randomString(8)},
		}

		_, err := logger.Ok(randomString(8))
		if err != nil {
			t.Fatalf("expected no error, got %v", err)
		}

		_, err = logger.Info(randomString(8))
		if err != nil {
			t.Fatalf("expected no error, got %v", err)
		}

		_, err = logger.Warn(randomString(8))
		if err != nil {
			t.Fatalf("expected no error, got %v", err)
		}

		_, err = logger.Err(randomString(8))
		if err != nil {
			t.Fatalf("expected no error, got %v", err)
		}

		_, err = logger.Raw(randomString(8))
		if err != nil {
			t.Fatalf("expected no error, got %v", err)
		}

	})

	t.Run("Failed logs", func(t *testing.T) {
		logger := &Logger{
			botAPI:  &MockBot{shouldFail: true},
			Options: Options{ChatID: randomString(8)},
		}

		_, err := logger.Ok(randomString(8))
		if err == nil {
			t.Fatalf("expected error %q, got nil", err)
		}

		_, err = logger.Info(randomString(8))
		if err == nil {
			t.Fatalf("expected error %q, got nil", err)
		}

		_, err = logger.Warn(randomString(8))
		if err == nil {
			t.Fatalf("expected error %q, got nil", err)
		}

		_, err = logger.Err(randomString(8))
		if err == nil {
			t.Fatalf("expected error %q, got nil", err)
		}

		_, err = logger.Raw(randomString(8))
		if err == nil {
			t.Fatalf("expected error %q, got nil", err)
		}
	})

	logger := &Logger{
		botAPI:  &MockBot{shouldFail: false},
		Options: Options{ChatID: randomString(8)},
	}

	t.Run("Log nil value", func(t *testing.T) {
		_, err := logger.Ok(nil)
		if err != nil {
			t.Fatalf("expected no error, got %v", err)
		}
	})

	t.Run("Log struct value", func(t *testing.T) {
		_, err := logger.Ok(struct {
			Value string `json:"value"`
		}{
			Value: randomString(8),
		})
		if err != nil {
			t.Fatalf("expected no error, got %v", err)
		}
	})
}

func randomString(n int) string {
	b := make([]byte, n)
	rand.Read(b)
	return base64.RawURLEncoding.EncodeToString(b)[:n]
}