feat: add app test (#76)

* feat: add app test

* chore: add test reporter test

* chore: fixed linting

pkg/app.go

@@ -3,6 +3,7 @@ package pkg
 import (
 	configTypes "main/pkg/config/types"
 	fsPkg "main/pkg/fs"
+	"main/pkg/types"
 	"os"
 	"os/signal"
 	"syscall"
@@ -28,6 +29,7 @@ type App struct {
 	DataFetcher    *data_fetcher.DataFetcher
 	Filterer       *filtererPkg.Filterer
 	MetricsManager *metricsPkg.Manager
+	QuitChannel    chan os.Signal
 
 	Version string
 }
@@ -82,6 +84,7 @@ func NewApp(filesystem fsPkg.FS, configPath string, version string) *App {
 		Filterer:       filterer,
 		MetricsManager: metricsManager,
 		Version:        version,
+		QuitChannel:    make(chan os.Signal, 1),
 	}
 }
 
@@ -101,47 +104,50 @@ func (a *App) Start() {
 
 	a.NodesManager.Listen()
 
-	quit := make(chan os.Signal, 1)
-	signal.Notify(quit, os.Interrupt, syscall.SIGTERM)
+	signal.Notify(a.QuitChannel, os.Interrupt, syscall.SIGTERM)
 
 	for {
 		select {
 		case rawReport := <-a.NodesManager.Channel:
-			reportablesForReporters := a.Filterer.GetReportableForReporters(rawReport)
-
-			if len(reportablesForReporters) == 0 {
-				a.Logger.Debug().
-					Str("node", rawReport.Node).
-					Str("chain", rawReport.Chain.Name).
-					Str("hash", rawReport.Reportable.GetHash()).
-					Msg("Got report which is nowhere to send")
-				continue
-			}
-
-			for reporterName, report := range reportablesForReporters {
-				a.Logger.Info().
-					Str("node", report.Node).
-					Str("chain", report.Chain.Name).
-					Str("reporter", reporterName).
-					Str("hash", report.Reportable.GetHash()).
-					Msg("Got report")
-
-				report.Reportable.GetAdditionalData(a.DataFetcher, report.Subscription.Name)
-
-				reporter := a.Reporters.FindByName(reporterName)
-
-				if err := reporter.Send(report); err != nil {
-					a.Logger.Error().
-						Err(err).
-						Msg("Error sending report")
-					a.MetricsManager.LogReport(report, reporterName, false)
-				} else {
-					a.MetricsManager.LogReport(report, reporterName, true)
-				}
-			}
-		case <-quit:
+			a.ProcessReport(rawReport)
+		case <-a.QuitChannel:
 			a.NodesManager.Stop()
-			os.Exit(0)
+			a.MetricsManager.Stop()
+			return
+		}
+	}
+}
+
+func (a *App) ProcessReport(rawReport types.Report) {
+	reportablesForReporters := a.Filterer.GetReportableForReporters(rawReport)
+
+	if len(reportablesForReporters) == 0 {
+		a.Logger.Debug().
+			Str("node", rawReport.Node).
+			Str("chain", rawReport.Chain.Name).
+			Str("hash", rawReport.Reportable.GetHash()).
+			Msg("Got report which is nowhere to send")
+	}
+
+	for reporterName, report := range reportablesForReporters {
+		a.Logger.Info().
+			Str("node", report.Node).
+			Str("chain", report.Chain.Name).
+			Str("reporter", reporterName).
+			Str("hash", report.Reportable.GetHash()).
+			Msg("Got report")
+
+		report.Reportable.GetAdditionalData(a.DataFetcher, report.Subscription.Name)
+
+		reporter := a.Reporters.FindByName(reporterName)
+
+		if err := reporter.Send(report); err != nil {
+			a.Logger.Error().
+				Err(err).
+				Msg("Error sending report")
+			a.MetricsManager.LogReport(report, reporterName, false)
+		} else {
+			a.MetricsManager.LogReport(report, reporterName, true)
 		}
 	}
 }

pkg/app_test.go

@@ -0,0 +1,147 @@
+package pkg
+
+import (
+	"errors"
+	configPkg "main/pkg/config"
+	configTypes "main/pkg/config/types"
+	filtererPkg "main/pkg/filterer"
+	"main/pkg/fs"
+	loggerPkg "main/pkg/logger"
+	metricsPkg "main/pkg/metrics"
+	reportersPkg "main/pkg/reporters"
+	"main/pkg/types"
+	"net/http"
+	"syscall"
+	"testing"
+	"time"
+
+	"github.com/jarcoal/httpmock"
+	"github.com/stretchr/testify/require"
+)
+
+func TestNewAppInvalidToml(t *testing.T) {
+	t.Parallel()
+
+	defer func() {
+		if r := recover(); r == nil {
+			require.Fail(t, "Expected to have a panic here!")
+		}
+	}()
+
+	NewApp(&fs.MockFs{}, "invalid-toml.toml", "1.2.3")
+}
+
+func TestNewAppValidTomlWithWarnings(t *testing.T) {
+	t.Parallel()
+
+	app := NewApp(&fs.MockFs{}, "valid-unused-chain.toml", "1.2.3")
+	require.NotNil(t, app)
+}
+
+func TestNewAppValidToml(t *testing.T) {
+	t.Parallel()
+
+	app := NewApp(&fs.MockFs{}, "valid.toml", "1.2.3")
+	require.NotNil(t, app)
+}
+
+//nolint:paralleltest // disabled due to httpmock usage
+func TestAppStart(t *testing.T) {
+	httpmock.Activate()
+	defer httpmock.DeactivateAndReset()
+
+	httpmock.RegisterResponder("GET", "http://localhost:9580/healthcheck", httpmock.InitialTransport.RoundTrip)
+	httpmock.RegisterResponder("GET", "http://localhost:9580/metrics", httpmock.InitialTransport.RoundTrip)
+
+	app := NewApp(&fs.MockFs{}, "valid.toml", "1.2.3")
+	require.NotNil(t, app)
+
+	go app.Start()
+
+	for {
+		request, err := http.Get("http://localhost:9580/healthcheck")
+		if request != nil && request.Body != nil {
+			_ = request.Body.Close()
+		}
+		if err == nil {
+			break
+		}
+
+		time.Sleep(time.Millisecond * 100)
+	}
+
+	app.NodesManager.Channel <- types.Report{
+		Chain: &configTypes.Chain{Name: "chain"},
+		Node:  "node",
+		Reportable: &types.NodeConnectError{
+			Error: errors.New("some error"),
+		},
+	}
+
+	app.QuitChannel <- syscall.SIGTERM
+}
+
+func TestAppProcessReport(t *testing.T) {
+	t.Parallel()
+
+	config := &configPkg.AppConfig{
+		Chains: configTypes.Chains{
+			{Name: "chain"},
+		},
+		Subscriptions: configTypes.Subscriptions{
+			{
+				Name:     "subscription",
+				Reporter: "test-reporter",
+				ChainSubscriptions: configTypes.ChainSubscriptions{
+					{
+						Chain:         "chain",
+						Filters:       configTypes.Filters{},
+						LogNodeErrors: true,
+					},
+				},
+			},
+			{
+				Name:     "subscription",
+				Reporter: "test-reporter-2",
+				ChainSubscriptions: configTypes.ChainSubscriptions{
+					{
+						Chain:         "chain",
+						Filters:       configTypes.Filters{},
+						LogNodeErrors: true,
+					},
+				},
+			},
+		},
+		Reporters: configTypes.Reporters{
+			{
+				Name: "test-reporter",
+			},
+			{
+				Name: "test-reporter-2",
+			},
+		},
+	}
+
+	logger := loggerPkg.GetNopLogger()
+	metricsManager := metricsPkg.NewManager(logger, configPkg.MetricsConfig{Enabled: true})
+	filterer := filtererPkg.NewFilterer(logger, config, metricsManager)
+
+	app := &App{
+		Reporters: reportersPkg.Reporters{
+			&reportersPkg.TestReporter{ReporterName: "test-reporter"},
+			&reportersPkg.TestReporter{ReporterName: "test-reporter-2", FailToSend: true},
+		},
+		Filterer:       filterer,
+		MetricsManager: metricsManager,
+	}
+
+	report := types.Report{
+		Chain: &configTypes.Chain{Name: "chain"},
+		Node:  "node",
+		Reportable: &types.NodeConnectError{
+			Error: errors.New("some error"),
+		},
+	}
+
+	app.ProcessReport(report)
+}

pkg/metrics/metrics.go

@@ -2,6 +2,7 @@ package metrics
 
 import (
 	"context"
+	"errors"
 	configPkg "main/pkg/config"
 	configTypes "main/pkg/config/types"
 	"main/pkg/constants"
@@ -178,14 +179,16 @@ func (m *Manager) Start() {
 		Str("addr", m.config.ListenAddr).
 		Msg("Metrics handler listening")
 
-	handler := http.NewServeMux()
-	handler.Handle("/metrics", promhttp.HandlerFor(m.registry, promhttp.HandlerOpts{
-		EnableOpenMetrics: true,
-	}))
-	handler.HandleFunc("/healthcheck", m.Healthcheck)
-	m.server.Handler = handler
+	go func() {
+		handler := http.NewServeMux()
+		handler.Handle("/metrics", promhttp.HandlerFor(m.registry, promhttp.HandlerOpts{
+			EnableOpenMetrics: true,
+		}))
+		handler.HandleFunc("/healthcheck", m.Healthcheck)
+		m.server.Handler = handler
+	}()
 
-	if err := m.server.ListenAndServe(); err != nil {
+	if err := m.server.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) {
 		m.logger.Panic().
 			Err(err).
 			Str("addr", m.config.ListenAddr).

pkg/reporters/test_reporter.go

@@ -0,0 +1,32 @@
+package reporters
+
+import (
+	"errors"
+	"main/pkg/constants"
+	"main/pkg/types"
+)
+
+type TestReporter struct {
+	FailToSend   bool
+	ReporterName string
+}
+
+func (r *TestReporter) Init() {
+
+}
+
+func (r *TestReporter) Name() string {
+	return r.ReporterName
+}
+
+func (r *TestReporter) Type() string {
+	return constants.ReporterTypeTelegram
+}
+
+func (r *TestReporter) Send(report types.Report) error {
+	if r.FailToSend {
+		return errors.New("send error")
+	}
+
+	return nil
+}

pkg/reporters/test_reporter_test.go

@@ -0,0 +1,16 @@
+package reporters
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestTestReporter(t *testing.T) {
+	t.Parallel()
+
+	reporter := &TestReporter{ReporterName: "test"}
+	reporter.Init()
+	assert.Equal(t, "test", reporter.Name())
+	assert.Equal(t, "telegram", reporter.Type())
+}

pkg/tendermint/ws/websocket_client.go

@@ -128,7 +128,7 @@ func (t *TendermintWebsocketClient) Listen() {
 func (t *TendermintWebsocketClient) Stop() {
 	t.Logger.Info().Msg("Stopping the node...")
 
-	if t.Client != nil {
+	if t.Client != nil && t.Client.ResponsesCh != nil {
 		if err := t.Client.Stop(); err != nil {
 			t.Logger.Warn().Err(err).Msg("Error stopping the node")
 		}