feat: add tests for config (#57)

assets/fs.go

@@ -0,0 +1,6 @@
+package assets
+
+import "embed"
+
+//go:embed *
+var AssetsFS embed.FS

assets/invalid-timezone.toml

@@ -0,0 +1,20 @@
+timezone = "invalid"
+
+[[reporters]]
+name = "reporter"
+type = "telegram"
+telegram-config = { token = "xxx:yyy", chat = 12345, admins = [67890] }
+
+[[subscriptions]]
+reporter = "telegram"
+name = "subscription"
+[[subscriptions.chains]]
+name = "cosmos"
+filters = ["message.action = '/cosmos.gov.v1beta1.MsgVote'", ]
+
+[[chains]]
+name = "cosmos"
+chain-id = "cosmoshub-4"
+tendermint-nodes = ["https://rpc.cosmos.quokkastake.io:443", ]
+api-nodes = ["https://api.cosmos.quokkastake.io"]
+

assets/invalid-toml.toml

@@ -0,0 +1 @@
+not-valid-toml

assets/valid.toml

@@ -0,0 +1,23 @@
+timezone = "Etc/UTC"
+
+[[reporters]]
+name = "reporter"
+type = "telegram"
+telegram-config = { token = "xxx:yyy", chat = 12345, admins = [67890] }
+
+[[subscriptions]]
+reporter = "reporter"
+name = "subscription"
+[[subscriptions.chains]]
+name = "cosmos"
+filters = ["message.action = '/cosmos.gov.v1beta1.MsgVote'", ]
+
+[[chains]]
+name = "cosmos"
+chain-id = "cosmoshub-4"
+tendermint-nodes = ["https://rpc.cosmos.quokkastake.io:443", ]
+api-nodes = ["https://api.cosmos.quokkastake.io"]
+mintscan-prefix = "cosmos"
+denoms = [
+    { denom = "uatom", display-denom = "atom", coingecko-currency = "cosmos" }
+]

cmd/cosmos-transactions-bot.go

@@ -1,9 +1,11 @@
 package main
 
 import (
+	"io/fs"
 	"main/pkg"
 	configPkg "main/pkg/config"
 	loggerPkg "main/pkg/logger"
+	"os"
 
 	"github.com/spf13/cobra"
 )
@@ -13,7 +15,8 @@ var (
 )
 
 func Execute(configPath string) {
-	config, err := configPkg.GetConfig(configPath)
+	filesystem, _ := os.DirFS(".").(fs.ReadFileFS)
+	config, err := configPkg.GetConfig(configPath, filesystem)
 	if err != nil {
 		loggerPkg.GetDefaultLogger().Fatal().Err(err).Msg("Could not load config")
 	}

pkg/config/config.go

@@ -2,7 +2,6 @@ package config
 
 import (
 	"bytes"
-	"os"
 	"time"
 
 	"gopkg.in/guregu/null.v4"
@@ -16,7 +15,6 @@ import (
 )
 
 type AppConfig struct {
-	Path          string
 	AliasesPath   string
 	LogConfig     LogConfig
 	Chains        types.Chains
@@ -36,8 +34,12 @@ type MetricsConfig struct {
 	ListenAddr string
 }
 
-func GetConfig(path string) (*AppConfig, error) {
-	configBytes, err := os.ReadFile(path)
+type ReadFileFs interface {
+	ReadFile(name string) ([]byte, error)
+}
+
+func GetConfig(path string, filesystem ReadFileFs) (*AppConfig, error) {
+	configBytes, err := filesystem.ReadFile(path)
 	if err != nil {
 		return nil, err
 	}
@@ -49,22 +51,19 @@ func GetConfig(path string) (*AppConfig, error) {
 		return nil, err
 	}
 
-	if err = defaults.Set(configStruct); err != nil {
-		return nil, err
-	}
+	defaults.MustSet(configStruct)
 
 	if err := configStruct.Validate(); err != nil {
 		return nil, err
 	}
 
-	return FromTomlConfig(configStruct, path), nil
+	return FromTomlConfig(configStruct), nil
 }
 
-func FromTomlConfig(c *tomlConfig.TomlConfig, path string) *AppConfig {
+func FromTomlConfig(c *tomlConfig.TomlConfig) *AppConfig {
 	timezone, _ := time.LoadLocation(c.Timezone)
 
 	return &AppConfig{
-		Path:        path,
 		AliasesPath: c.AliasesPath,
 		LogConfig: LogConfig{
 			LogLevel:   c.LogConfig.LogLevel,
@@ -115,27 +114,9 @@ func (c *AppConfig) DisplayWarnings() []types.DisplayWarning {
 	return warnings
 }
 
-func (c *AppConfig) Save() error {
+func (c *AppConfig) GetConfigAsString() string {
 	configStruct := c.ToTomlConfig()
-
-	f, err := os.Create(c.Path)
-	if err != nil {
-		return err
-	}
-	if err := toml.NewEncoder(f).Encode(configStruct); err != nil {
-		return err
-	}
-	return f.Close()
-}
-
-func (c *AppConfig) GetConfigAsString() (string, error) {
-	configStruct := c.ToTomlConfig()
-
 	buffer := new(bytes.Buffer)
-
-	if err := toml.NewEncoder(buffer).Encode(configStruct); err != nil {
-		return "", err
-	}
-
-	return buffer.String(), nil
+	_ = toml.NewEncoder(buffer).Encode(configStruct)
+	return buffer.String()
 }

pkg/config/config_test.go

@@ -0,0 +1,154 @@
+package config_test
+
+import (
+	"main/assets"
+	configPkg "main/pkg/config"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestLoadConfigErrorReading(t *testing.T) {
+	t.Parallel()
+
+	config, err := configPkg.GetConfig("config.toml", assets.AssetsFS)
+
+	require.Error(t, err)
+	require.Nil(t, config)
+}
+
+func TestLoadConfigInvalidConfig(t *testing.T) {
+	t.Parallel()
+
+	config, err := configPkg.GetConfig("invalid-timezone.toml", assets.AssetsFS)
+
+	require.Error(t, err)
+	require.Nil(t, config)
+}
+
+func TestLoadConfigInvalidToml(t *testing.T) {
+	t.Parallel()
+
+	config, err := configPkg.GetConfig("invalid-toml.toml", assets.AssetsFS)
+
+	require.Error(t, err)
+	require.Nil(t, config)
+}
+
+func TestLoadConfigValid(t *testing.T) {
+	t.Parallel()
+
+	config, err := configPkg.GetConfig("valid.toml", assets.AssetsFS)
+
+	require.NoError(t, err)
+	require.NotNil(t, config)
+}
+
+func TestConfigDisplayWarnings(t *testing.T) {
+	t.Parallel()
+
+	config, err := configPkg.GetConfig("valid.toml", assets.AssetsFS)
+
+	require.NoError(t, err)
+	require.NotNil(t, config)
+
+	warnings := config.DisplayWarnings()
+	require.Empty(t, warnings)
+}
+
+func TestConfigDisplayAsToml(t *testing.T) {
+	t.Parallel()
+
+	config, err := configPkg.GetConfig("valid.toml", assets.AssetsFS)
+	require.NoError(t, err)
+
+	tomlConfig := config.ToTomlConfig()
+	configAgain := configPkg.FromTomlConfig(tomlConfig)
+
+	require.EqualValues(t, config.LogConfig, configAgain.LogConfig)
+	require.EqualValues(t, config.AliasesPath, configAgain.AliasesPath)
+	require.EqualValues(t, config.Metrics, configAgain.Metrics)
+	require.EqualValues(t, config.Timezone, configAgain.Timezone)
+
+	require.Equal(t, len(config.Chains), len(configAgain.Chains))
+	for index := range config.Chains {
+		configChain := config.Chains[index]
+		configChainAgain := configAgain.Chains[index]
+
+		require.EqualValues(t, configChain.Name, configChainAgain.Name)
+		require.EqualValues(t, configChain.PrettyName, configChainAgain.PrettyName)
+		require.EqualValues(t, configChain.ChainID, configChainAgain.ChainID)
+		require.EqualValues(t, configChain.TendermintNodes, configChainAgain.TendermintNodes)
+		require.EqualValues(t, configChain.APINodes, configChainAgain.APINodes)
+		require.EqualValues(t, configChain.Explorer, configChainAgain.Explorer)
+		require.EqualValues(t, configChain.SupportedExplorer, configChainAgain.SupportedExplorer)
+		require.EqualValues(t, configChain.Denoms, configChainAgain.Denoms)
+
+		require.Equal(t, len(configChain.Queries), len(configChainAgain.Queries))
+		for queryIndex := range configChain.Queries {
+			require.EqualValues(
+				t,
+				configChain.Queries[queryIndex].String(),
+				configChainAgain.Queries[queryIndex].String(),
+			)
+		}
+	}
+
+	require.Equal(t, len(config.Subscriptions), len(configAgain.Subscriptions))
+	for index := range config.Subscriptions {
+		configSubscription := config.Subscriptions[index]
+		configSubscriptionAgain := configAgain.Subscriptions[index]
+
+		require.EqualValues(t, configSubscription.Name, configSubscriptionAgain.Name)
+		require.EqualValues(t, configSubscription.Reporter, configSubscriptionAgain.Reporter)
+
+		require.Equal(
+			t,
+			len(configSubscription.ChainSubscriptions),
+			len(configSubscriptionAgain.ChainSubscriptions),
+		)
+
+		for chainSubscriptionIndex := range configSubscription.ChainSubscriptions {
+			configChainSubscription := configSubscription.ChainSubscriptions[chainSubscriptionIndex]
+			configChainSubscriptionAgain := configSubscriptionAgain.ChainSubscriptions[chainSubscriptionIndex]
+
+			require.EqualValues(t, configChainSubscription.Chain, configChainSubscriptionAgain.Chain)
+			require.EqualValues(t, configChainSubscription.LogNodeErrors, configChainSubscriptionAgain.LogNodeErrors)
+			require.EqualValues(t, configChainSubscription.LogUnparsedMessages, configChainSubscriptionAgain.LogUnparsedMessages)
+			require.EqualValues(t, configChainSubscription.LogUnknownMessages, configChainSubscriptionAgain.LogUnknownMessages)
+			require.EqualValues(t, configChainSubscription.LogFailedTransactions, configChainSubscriptionAgain.LogFailedTransactions)
+			require.EqualValues(t, configChainSubscription.FilterInternalMessages, configChainSubscriptionAgain.FilterInternalMessages)
+
+			require.Equal(
+				t,
+				len(configChainSubscription.Filters),
+				len(configChainSubscriptionAgain.Filters),
+			)
+
+			for filterIndex := range configChainSubscription.Filters {
+				require.Equal(
+					t,
+					len(configChainSubscription.Filters[filterIndex].String()),
+					len(configChainSubscriptionAgain.Filters[filterIndex].String()),
+				)
+			}
+		}
+	}
+
+	require.Equal(t, len(config.Reporters), len(configAgain.Reporters))
+	for index := range config.Reporters {
+		require.EqualValues(t, config.Reporters[index], configAgain.Reporters[index])
+	}
+}
+
+func TestGetConfigAsString(t *testing.T) {
+	t.Parallel()
+
+	config, err := configPkg.GetConfig("valid.toml", assets.AssetsFS)
+
+	require.NoError(t, err)
+	require.NotNil(t, config)
+
+	configString := config.GetConfigAsString()
+	require.NotEmpty(t, configString)
+}

pkg/reporters/telegram/get_config.go

@@ -1,7 +1,6 @@
 package telegram
 
 import (
-	"fmt"
 	"main/pkg/constants"
 
 	tele "gopkg.in/telebot.v3"
@@ -15,10 +14,6 @@ func (reporter *Reporter) HandleGetConfig(c tele.Context) error {
 
 	reporter.MetricsManager.LogReporterQuery(reporter.Name(), constants.ReporterQueryGetConfig)
 
-	configString, err := reporter.Config.GetConfigAsString()
-	if err != nil {
-		return reporter.BotReply(c, fmt.Sprintf("Error converting config to string: %s", err))
-	}
-
+	configString := reporter.Config.GetConfigAsString()
 	return reporter.BotReply(c, configString)
 }