chore: add utils and types test (#61)

* chore: add utils and types test

* chore: add logger tests

* chore: add chain query test

* chore: fixed linting

* chore: add display warning

* chore: add tests for chain

* chore: add tests for consumer chain

* chore: add tests for denom info

* chore: add tests for tracing

* chore: fix linting

* chore: add tests for tracing

* chore: moved validator to a separate file

* chore: add config test

* chore: add tests for get config

* chore: added displayWarning for missing consensus address

assets/fs.go

@@ -0,0 +1,8 @@
+package assets
+
+import (
+	"embed"
+)
+
+//go:embed *
+var EmbedFS embed.FS

assets/invalid.toml

@@ -0,0 +1 @@
+notvalid

assets/valid.toml

@@ -0,0 +1,10 @@
+[[chains]]
+name = "sentinel"
+lcd-endpoint = "https://api.sentinel.quokkastake.io"
+coingecko-currency = "sentinel"
+base-denom = "udvpn"
+denom = "dvpn"
+bech-wallet-prefix = "sent"
+validators = [
+    { address = "sentvaloper1rw9wtyhsus7jvx55v3qv5nzun054ma6kz4237k" }
+]

cmd/cosmos-validators-exporter.go

@@ -4,6 +4,7 @@ import (
 	"main/pkg"
 	configPkg "main/pkg/config"
 	"main/pkg/logger"
+	"os"
 
 	"github.com/spf13/cobra"
 )
@@ -12,13 +13,22 @@ var (
 	version = "unknown"
 )
 
+type OsFS struct {
+}
+
+func (fs *OsFS) ReadFile(name string) ([]byte, error) {
+	return os.ReadFile(name)
+}
+
 func ExecuteMain(configPath string) {
-	app := pkg.NewApp(configPath, version)
+	filesystem := &OsFS{}
+	app := pkg.NewApp(configPath, filesystem, version)
 	app.Start()
 }
 
 func ExecuteValidateConfig(configPath string) {
-	config, err := configPkg.GetConfig(configPath)
+	filesystem := &OsFS{}
+	config, err := configPkg.GetConfig(configPath, filesystem)
 	if err != nil {
 		logger.GetDefaultLogger().Fatal().Err(err).Msg("Could not load config!")
 	}
@@ -27,7 +37,17 @@ func ExecuteValidateConfig(configPath string) {
 		logger.GetDefaultLogger().Fatal().Err(err).Msg("Config is invalid!")
 	}
 
-	config.DisplayWarnings(logger.GetDefaultLogger())
+	warnings := config.DisplayWarnings()
+
+	for _, warning := range warnings {
+		entry := logger.GetDefaultLogger().Warn()
+		for label, value := range warning.Labels {
+			entry = entry.Str(label, value)
+		}
+
+		entry.Msg(warning.Message)
+	}
+
 	logger.GetDefaultLogger().Info().Msg("Provided config is valid.")
 }
 

pkg/app.go

@@ -2,6 +2,7 @@ package pkg
 
 import (
 	fetchersPkg "main/pkg/fetchers"
+	"main/pkg/fs"
 	generatorsPkg "main/pkg/generators"
 	coingeckoPkg "main/pkg/price_fetchers/coingecko"
 	dexScreenerPkg "main/pkg/price_fetchers/dex_screener"
@@ -45,8 +46,8 @@ type App struct {
 	Generators []generatorsPkg.Generator
 }
 
-func NewApp(configPath string, version string) *App {
-	appConfig, err := config.GetConfig(configPath)
+func NewApp(configPath string, filesystem fs.FS, version string) *App {
+	appConfig, err := config.GetConfig(configPath, filesystem)
 	if err != nil {
 		loggerPkg.GetDefaultLogger().Fatal().Err(err).Msg("Could not load config")
 	}
@@ -56,7 +57,15 @@ func NewApp(configPath string, version string) *App {
 	}
 
 	logger := loggerPkg.GetLogger(appConfig.LogConfig)
-	appConfig.DisplayWarnings(logger)
+	warnings := appConfig.DisplayWarnings()
+	for _, warning := range warnings {
+		entry := logger.Warn()
+		for label, value := range warning.Labels {
+			entry = entry.Str(label, value)
+		}
+
+		entry.Msg(warning.Message)
+	}
 
 	tracer, err := tracing.InitTracer(appConfig.TracingConfig, version)
 	if err != nil {

pkg/config/chain.go

@@ -5,8 +5,6 @@ import (
 	"fmt"
 
 	"github.com/guregu/null/v5"
-
-	"github.com/rs/zerolog"
 )
 
 type Chain struct {
@@ -68,14 +66,23 @@ func (c *Chain) Validate() error {
 	return nil
 }
 
-func (c *Chain) DisplayWarnings(logger *zerolog.Logger) {
+func (c *Chain) DisplayWarnings() []Warning {
+	warnings := []Warning{}
+
 	if c.BaseDenom == "" {
-		logger.Warn().
-			Str("chain", c.Name).
-			Msg("Base denom is not set")
+		warnings = append(warnings, Warning{
+			Message: "Base denom is not set",
+			Labels:  map[string]string{"chain": c.Name},
+		})
 	}
 
 	for _, denom := range c.Denoms {
-		denom.DisplayWarnings(c, logger)
+		warnings = append(warnings, denom.DisplayWarnings(c)...)
 	}
+
+	for _, validator := range c.Validators {
+		warnings = append(warnings, validator.DisplayWarnings(c)...)
+	}
+
+	return warnings
 }

pkg/config/chain_test.go

@@ -0,0 +1,139 @@
+package config
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestChainMethods(t *testing.T) {
+	t.Parallel()
+
+	chain := Chain{
+		LCDEndpoint: "example",
+		Name:        "chain",
+		Queries:     map[string]bool{"enabled": true},
+	}
+
+	assert.Equal(t, "example", chain.GetHost())
+	assert.Equal(t, "chain", chain.GetName())
+	assert.Len(t, chain.GetQueries(), 1)
+}
+
+func TestChainValidateNoName(t *testing.T) {
+	t.Parallel()
+
+	chain := Chain{}
+	err := chain.Validate()
+	require.Error(t, err)
+}
+
+func TestChainValidateNoEndpoint(t *testing.T) {
+	t.Parallel()
+
+	chain := Chain{Name: "test"}
+	err := chain.Validate()
+	require.Error(t, err)
+}
+
+func TestChainValidateNoValidators(t *testing.T) {
+	t.Parallel()
+
+	chain := Chain{Name: "test", LCDEndpoint: "test"}
+	err := chain.Validate()
+	require.Error(t, err)
+}
+
+func TestChainValidateInvalidValidator(t *testing.T) {
+	t.Parallel()
+
+	chain := Chain{
+		Name:        "test",
+		LCDEndpoint: "test",
+		Validators:  []Validator{{}},
+	}
+	err := chain.Validate()
+	require.Error(t, err)
+}
+
+func TestChainValidateInvalidDenom(t *testing.T) {
+	t.Parallel()
+
+	chain := Chain{
+		Name:        "test",
+		LCDEndpoint: "test",
+		Validators:  []Validator{{Address: "test"}},
+		Denoms:      DenomInfos{{}},
+	}
+	err := chain.Validate()
+	require.Error(t, err)
+}
+
+func TestChainValidateInvalidConsumer(t *testing.T) {
+	t.Parallel()
+
+	chain := Chain{
+		Name:           "test",
+		LCDEndpoint:    "test",
+		Validators:     []Validator{{Address: "test"}},
+		Denoms:         DenomInfos{{Denom: "ustake", DisplayDenom: "stake"}},
+		ConsumerChains: []*ConsumerChain{{}},
+	}
+	err := chain.Validate()
+	require.Error(t, err)
+}
+
+func TestChainValidateValid(t *testing.T) {
+	t.Parallel()
+
+	chain := Chain{
+		Name:        "test",
+		LCDEndpoint: "test",
+		Validators:  []Validator{{Address: "test"}},
+		Denoms:      DenomInfos{{Denom: "ustake", DisplayDenom: "stake"}},
+	}
+	err := chain.Validate()
+	require.NoError(t, err)
+}
+
+func TestChainDisplayWarningsNoBaseDenom(t *testing.T) {
+	t.Parallel()
+
+	chain := Chain{
+		Name:        "test",
+		LCDEndpoint: "test",
+		Validators:  []Validator{{Address: "test"}},
+		Denoms:      DenomInfos{{Denom: "ustake", DisplayDenom: "stake", CoingeckoCurrency: "stake"}},
+	}
+	warnings := chain.DisplayWarnings()
+	require.NotEmpty(t, warnings)
+}
+
+func TestChainDisplayWarningsDenomWarning(t *testing.T) {
+	t.Parallel()
+
+	chain := Chain{
+		Name:        "test",
+		LCDEndpoint: "test",
+		BaseDenom:   "ustake",
+		Validators:  []Validator{{Address: "test", ConsensusAddress: "test"}},
+		Denoms:      DenomInfos{{Denom: "ustake", DisplayDenom: "stake"}},
+	}
+	warnings := chain.DisplayWarnings()
+	require.NotEmpty(t, warnings)
+}
+
+func TestChainDisplayWarningsEmpty(t *testing.T) {
+	t.Parallel()
+
+	chain := Chain{
+		Name:        "test",
+		LCDEndpoint: "test",
+		BaseDenom:   "ustake",
+		Validators:  []Validator{{Address: "test", ConsensusAddress: "test"}},
+		Denoms:      DenomInfos{{Denom: "ustake", DisplayDenom: "stake", CoingeckoCurrency: "stake"}},
+	}
+	warnings := chain.DisplayWarnings()
+	require.Empty(t, warnings)
+}

pkg/config/config.go

@@ -3,27 +3,12 @@ package config
 import (
 	"errors"
 	"fmt"
-	"os"
-
-	"github.com/rs/zerolog"
+	"main/pkg/fs"
 
 	"github.com/BurntSushi/toml"
 	"github.com/creasty/defaults"
 )
 
-type Validator struct {
-	Address          string `toml:"address"`
-	ConsensusAddress string `toml:"consensus-address"`
-}
-
-func (v *Validator) Validate() error {
-	if v.Address == "" {
-		return errors.New("validator address is expected!")
-	}
-
-	return nil
-}
-
 type Config struct {
 	LogConfig     LogConfig     `toml:"log"`
 	TracingConfig TracingConfig `toml:"tracing"`
@@ -55,10 +40,14 @@ func (c *Config) Validate() error {
 	return nil
 }
 
-func (c *Config) DisplayWarnings(logger *zerolog.Logger) {
+func (c *Config) DisplayWarnings() []Warning {
+	warnings := []Warning{}
+
 	for _, chain := range c.Chains {
-		chain.DisplayWarnings(logger)
+		warnings = append(warnings, chain.DisplayWarnings()...)
 	}
+
+	return warnings
 }
 
 func (c *Config) GetCoingeckoCurrencies() []string {
@@ -70,13 +59,21 @@ func (c *Config) GetCoingeckoCurrencies() []string {
 				currencies = append(currencies, denom.CoingeckoCurrency)
 			}
 		}
+
+		for _, consumerChain := range chain.ConsumerChains {
+			for _, denom := range consumerChain.Denoms {
+				if denom.CoingeckoCurrency != "" {
+					currencies = append(currencies, denom.CoingeckoCurrency)
+				}
+			}
+		}
 	}
 
 	return currencies
 }
 
-func GetConfig(path string) (*Config, error) {
-	configBytes, err := os.ReadFile(path)
+func GetConfig(path string, filesystem fs.FS) (*Config, error) {
+	configBytes, err := filesystem.ReadFile(path)
 	if err != nil {
 		return nil, err
 	}
@@ -88,9 +85,6 @@ func GetConfig(path string) (*Config, error) {
 		return nil, err
 	}
 
-	if err = defaults.Set(&configStruct); err != nil {
-		return nil, err
-	}
-
+	defaults.MustSet(&configStruct)
 	return &configStruct, nil
 }