Merge pull request #66 from lungria/feature/add-logs

logs and bugfix for IntervalProvider

app/init.go

@@ -60,7 +60,7 @@ func initImporter(cfg config.Config, cl *mono.Client, a *account.Repository, t *
 	gen := interval.NewGenerator(t)
 	acIm := account.NewImporter(cl, a)
 	txIm := transaction.NewImporter(cl, t, gen)
-	globalIm := importer.NewImporter(acIm, txIm)
+	globalIm := importer.NewImporter(txIm, acIm)
 
 	return importer.NewWorker(globalIm, cfg.MonoAccountID)
 }

importer/importer.go

@@ -2,6 +2,7 @@ package importer
 
 import (
 	"context"
+	"time"
 
 	"github.com/rs/zerolog/log"
 )
@@ -15,7 +16,7 @@ type AccountImporter interface {
 // TransactionsImporter abstracts transactions import logic implementation.
 type TransactionsImporter interface {
 	// Import loads transactions in specified interval for specified accountID and saves them to storage.
-	Import(ctx context.Context, accountID string) error
+	Import(ctx context.Context, accountID string) (time.Time, time.Time, error)
 }
 
 // Importer loads latest data from bank for specified accountID.
@@ -32,17 +33,25 @@ func NewImporter(transactions TransactionsImporter, accounts AccountImporter) *I
 	}
 }
 
-// Import latest data from bank for specified accountID.
+// Import the latest data from bank for specified accountID.
 func (i *Importer) Import(ctx context.Context, accountID string) {
 	err := i.accounts.Import(ctx, accountID)
 	if err != nil {
-		log.Err(err).Msg("failed import")
+		log.Err(err).Msg("failed account import")
 		return
 	}
 
-	err = i.transactions.Import(ctx, accountID)
+	from, to, err := i.transactions.Import(ctx, accountID)
 	if err != nil {
-		log.Err(err).Msg("failed import")
+		log.Err(err).
+			Time("from", from).
+			Time("to", to).
+			Msg("failed transactions import")
 		return
 	}
+
+	log.Debug().
+		Time("from", from).
+		Time("to", to).
+		Msg("import finished")
 }

importer/importer_test.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"io/ioutil"
 	"testing"
+	"time"
 
 	"github.com/lungria/spendshelf-backend/importer"
 	"github.com/lungria/spendshelf-backend/importer/mock"
@@ -18,8 +19,8 @@ func TestImport_WhenCalled_ImportsAccountsAndTransactions(t *testing.T) {
 		return nil
 	}
 	transactions := &mock.TransactionsImporterMock{}
-	transactions.ImportFunc = func(ctx context.Context, accountID string) error {
-		return nil
+	transactions.ImportFunc = func(ctx context.Context, accountID string) (time.Time, time.Time, error) {
+		return time.Time{}, time.Time{}, nil
 	}
 	log.Logger = zerolog.New(ioutil.Discard)
 	svc := importer.NewImporter(transactions, accounts)

importer/worker.go

@@ -4,8 +4,6 @@ import (
 	"context"
 	"sync"
 	"time"
-
-	"github.com/rs/zerolog/log"
 )
 
 const (
@@ -40,7 +38,6 @@ func (w *Worker) Start() {
 		select {
 		case _ = <-ticker.C:
 			w.executeWithTimeout(w.ctx)
-			log.Debug().Msg("import finished")
 		case _ = <-w.ctx.Done():
 			return
 		}

transaction/importer.go

@@ -52,10 +52,10 @@ func NewImporter(
 }
 
 // Import loads transactions in specified interval for specified accountID and saves them to storage.
-func (i *Importer) Import(ctx context.Context, accountID string) error {
+func (i *Importer) Import(ctx context.Context, accountID string) (time.Time, time.Time, error) {
 	from, to, err := i.intervalGen.GetInterval(ctx, accountID)
 	if err != nil {
-		return fmt.Errorf("failed import transaction for account '%s': %w", accountID, err)
+		return i.resultWithErr(fmt.Errorf("failed import transaction for account '%s': %w", accountID, err))
 	}
 
 	query := mono.GetTransactionsQuery{
@@ -66,21 +66,25 @@ func (i *Importer) Import(ctx context.Context, accountID string) error {
 
 	monoTransactions, err := i.api.GetTransactions(ctx, query)
 	if err != nil {
-		return fmt.Errorf("failed import transaction for account '%s': %w", accountID, err)
+		return i.resultWithErr(fmt.Errorf("failed import transaction for account '%s': %w", accountID, err))
 	}
 
 	if len(monoTransactions) == 0 {
-		return nil
+		return from, to, nil
 	}
 
 	transactions := i.mapTransactions(accountID, monoTransactions)
 
 	err = i.transactions.Save(ctx, transactions)
 	if err != nil {
-		return fmt.Errorf("failed import transaction for account '%s': %w", accountID, err)
+		return i.resultWithErr(fmt.Errorf("failed import transaction for account '%s': %w", accountID, err))
 	}
 
-	return nil
+	return from, to, nil
+}
+
+func (i *Importer) resultWithErr(err error) (time.Time, time.Time, error) {
+	return time.Time{}, time.Time{}, err
 }
 
 func (i *Importer) mapTransactions(accountID string, src []mono.Transaction) []Transaction {

transaction/importer_test.go

@@ -22,7 +22,7 @@ func TestImport_WhenGetIntervalFails_ReturnsError(t *testing.T) {
 	}
 	svc := transaction.NewImporter(api, storage, gen)
 
-	err := svc.Import(context.Background(), "acc")
+	_, _, err := svc.Import(context.Background(), "acc")
 
 	assert.True(t, errors.Is(err, testError))
 	assert.Zero(t, len(storage.SaveCalls()))
@@ -43,7 +43,7 @@ func TestImport_WhenApiGetTransactionsFails_ReturnsError(t *testing.T) {
 	}
 	svc := transaction.NewImporter(api, storage, gen)
 
-	err := svc.Import(context.Background(), "acc")
+	_, _, err := svc.Import(context.Background(), "acc")
 
 	assert.True(t, errors.Is(err, testError))
 	assert.Zero(t, len(storage.SaveCalls()))
@@ -63,7 +63,7 @@ func TestImport_WhenApiGetTransactionsReturnsNothing_StorageNotCalled(t *testing
 	}
 	svc := transaction.NewImporter(api, storage, gen)
 
-	err := svc.Import(context.Background(), "acc")
+	_, _, err := svc.Import(context.Background(), "acc")
 
 	assert.Nil(t, err)
 	assert.Equal(t, 0, len(storage.SaveCalls()))
@@ -93,7 +93,7 @@ func TestImport_WhenStorageSaveReturnsError_ReturnsError(t *testing.T) {
 	}
 	svc := transaction.NewImporter(api, db, gen)
 
-	err := svc.Import(context.Background(), "acc")
+	_, _, err := svc.Import(context.Background(), "acc")
 	saveCalls := db.SaveCalls()
 
 	assert.Error(t, err)
@@ -124,7 +124,7 @@ func TestImport_WhenDataIsSaved_ReturnsNil(t *testing.T) {
 	}
 	svc := transaction.NewImporter(api, db, gen)
 
-	err := svc.Import(context.Background(), "acc")
+	_, _, err := svc.Import(context.Background(), "acc")
 	saveCalls := db.SaveCalls()
 
 	assert.Nil(t, err)

transaction/interval/interval.go

@@ -49,7 +49,7 @@ func (gen *Generator) GetInterval(ctx context.Context, accountID string) (from,
 
 	diffSecs := nowUtc.Sub(lastKnownTransactionDate.UTC()).Seconds()
 	if diffSecs > maxAllowedIntervalDuration {
-		return lastKnownTransactionDate, lastKnownTransactionDate.Add(maxAllowedIntervalDuration / 2), nil
+		return lastKnownTransactionDate, lastKnownTransactionDate.Add(time.Second * maxAllowedIntervalDuration / 2), nil
 	}
 
 	return lastKnownTransactionDate.UTC(), nowUtc, nil