refactor tests to use available functions

Author: ylembachar

rolling-shutter/keyperimpl/gnosis/syncmonitor.go

@@ -59,7 +59,7 @@ func (s *SyncMonitor) runMonitor(ctx context.Context) error {
 			}
 		case <-ctx.Done():
 			log.Info().Msg("stopping syncMonitor due to context cancellation")
-			return nil
+			return ctx.Err()
 		}
 	}
-}
+}

rolling-shutter/keyperimpl/gnosis/syncmonitor_test.go

@@ -2,13 +2,12 @@ package gnosis_test
 
 import (
 	"context"
+	"github.com/shutter-network/rolling-shutter/rolling-shutter/keyperimpl/gnosis/database"
 	"testing"
 	"time"
 
-	"github.com/rs/zerolog/log"
 	"gotest.tools/assert"
 
-	"github.com/shutter-network/rolling-shutter/rolling-shutter/keyper/database"
 	"github.com/shutter-network/rolling-shutter/rolling-shutter/keyperimpl/gnosis"
 	"github.com/shutter-network/rolling-shutter/rolling-shutter/medley/service"
 	"github.com/shutter-network/rolling-shutter/rolling-shutter/medley/testsetup"
@@ -18,28 +17,19 @@ func TestSyncMonitor_ThrowsErrorWhenBlockNotIncreasing(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	dbpool, closeDB := testsetup.NewTestDBPool(ctx, t, database.Definition)
-	defer closeDB()
-
-	_, err := dbpool.Exec(ctx, `
-    CREATE TABLE IF NOT EXISTS transaction_submitted_events_synced_until(
-        enforce_one_row bool PRIMARY KEY DEFAULT true,
-        block_hash bytea NOT NULL,
-        block_number bigint NOT NULL CHECK (block_number >= 0),
-        slot bigint NOT NULL CHECK (slot >= 0)
-    );
-    `)
-	if err != nil {
-		t.Fatalf("failed to create table: %v", err)
-	}
+	dbpool, dbclose := testsetup.NewTestDBPool(ctx, t, database.Definition)
+	defer dbclose()
+	db := database.New(dbpool)
 
 	initialBlockNumber := int64(100)
-	_, err = dbpool.Exec(ctx, `
-    INSERT INTO transaction_submitted_events_synced_until (block_hash, block_number, slot)
-    VALUES ($1, $2, $3);
-    `, []byte{0x01, 0x02, 0x03}, initialBlockNumber, 1)
+
+	err := db.SetTransactionSubmittedEventsSyncedUntil(ctx, database.SetTransactionSubmittedEventsSyncedUntilParams{
+		BlockHash:   []byte{0x01, 0x02, 0x03},
+		BlockNumber: initialBlockNumber,
+		Slot:        1,
+	})
 	if err != nil {
-		t.Fatalf("failed to insert initial data: %v", err)
+		t.Fatalf("failed to set initial synced data: %v", err)
 	}
 
 	monitor := &gnosis.SyncMonitor{
@@ -72,41 +62,21 @@ func TestSyncMonitor_HandlesBlockNumberIncreasing(t *testing.T) {
 
 	dbpool, closeDB := testsetup.NewTestDBPool(ctx, t, database.Definition)
 	defer closeDB()
-
-	_, err := dbpool.Exec(ctx, `
-    CREATE TABLE IF NOT EXISTS transaction_submitted_events_synced_until(
-        enforce_one_row bool PRIMARY KEY DEFAULT true,
-        block_hash bytea NOT NULL,
-        block_number bigint NOT NULL CHECK (block_number >= 0),
-        slot bigint NOT NULL CHECK (slot >= 0)
-    );
-`)
-	if err != nil {
-		t.Fatalf("failed to create table: %v", err)
-	}
+	db := database.New(dbpool)
 
 	initialBlockNumber := int64(100)
-	_, err = dbpool.Exec(ctx, `
-    INSERT INTO transaction_submitted_events_synced_until (block_hash, block_number, slot)
-    VALUES ($1, $2, $3);
-`, []byte{0x01, 0x02, 0x03}, initialBlockNumber, 1)
-	if err != nil {
-		t.Fatalf("failed to insert initial data: %v", err)
-	}
-
-	var count int
-	err = dbpool.QueryRow(ctx, `
-    SELECT count(*) FROM transaction_submitted_events_synced_until
-    WHERE block_number = $1;
-`, initialBlockNumber).Scan(&count)
+	err := db.SetTransactionSubmittedEventsSyncedUntil(ctx, database.SetTransactionSubmittedEventsSyncedUntilParams{
+		BlockHash:   []byte{0x01, 0x02, 0x03},
+		BlockNumber: initialBlockNumber,
+		Slot:        1,
+	})
 	if err != nil {
-		t.Fatalf("failed to verify initial data: %v", err)
+		t.Fatalf("failed to set initial synced data: %v", err)
 	}
 
-	assert.Equal(t, 1, count, "initial data should be inserted")
-
 	monitor := &gnosis.SyncMonitor{
-		DBPool: dbpool,
+		DBPool:        dbpool,
+		CheckInterval: 30 * time.Second,
 	}
 
 	_, deferFn := service.RunBackground(ctx, monitor)
@@ -115,18 +85,12 @@ func TestSyncMonitor_HandlesBlockNumberIncreasing(t *testing.T) {
 	doneCh := make(chan struct{})
 	go func() {
 		for i := 0; i < 5; i++ {
-			// Simulate block number increment by updating the database
 			newBlockNumber := initialBlockNumber + int64(i+1)
-			log.Info().
-				Int64("previous-block-number", initialBlockNumber+int64(i)).
-				Int64("new-block-number", newBlockNumber).
-				Msg("comparing consecutive blocks")
-
-			_, err := dbpool.Exec(ctx, `
-        UPDATE transaction_submitted_events_synced_until
-        SET block_number = $1
-        WHERE block_number = $2;
-`, newBlockNumber, initialBlockNumber+int64(i))
+			err := db.SetTransactionSubmittedEventsSyncedUntil(ctx, database.SetTransactionSubmittedEventsSyncedUntilParams{
+				BlockHash:   []byte{0x01, 0x02, 0x03},
+				BlockNumber: newBlockNumber,
+				Slot:        1,
+			})
 			if err != nil {
 				t.Errorf("failed to update block number: %v", err)
 				return
@@ -139,43 +103,28 @@ func TestSyncMonitor_HandlesBlockNumberIncreasing(t *testing.T) {
 	}()
 
 	<-doneCh
-	var finalBlockNumber int64
-	err = dbpool.QueryRow(ctx, `SELECT block_number FROM transaction_submitted_events_synced_until LIMIT 1;`).Scan(&finalBlockNumber)
+	syncedData, err := db.GetTransactionSubmittedEventsSyncedUntil(ctx)
 	if err != nil {
 		t.Fatalf("failed to retrieve final block number: %v", err)
 	}
 
-	assert.Equal(t, initialBlockNumber+5, finalBlockNumber, "block number should have been incremented correctly")
+	assert.Equal(t, initialBlockNumber+5, syncedData.BlockNumber, "block number should have been incremented correctly")
 }
 
 func TestSyncMonitor_ContinuesWhenNoRows(t *testing.T) {
-	parentCtx, cancelParent := context.WithCancel(context.Background())
-	defer cancelParent()
-
-	dbpool, closeDB := testsetup.NewTestDBPool(parentCtx, t, database.Definition)
-	defer func() {
-		closeDB()
-		cancelParent()
-	}()
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
 
-	_, err := dbpool.Exec(parentCtx, `
-    CREATE TABLE IF NOT EXISTS transaction_submitted_events_synced_until(
-        enforce_one_row bool PRIMARY KEY DEFAULT true,
-        block_hash bytea NOT NULL,
-        block_number bigint NOT NULL CHECK (block_number >= 0),
-        slot bigint NOT NULL CHECK (slot >= 0)
-    );
-    `)
-	if err != nil {
-		t.Fatalf("failed to create table: %v", err)
-	}
+	dbpool, closeDB := testsetup.NewTestDBPool(ctx, t, database.Definition)
+	defer closeDB()
+	_ = database.New(dbpool)
 
 	monitor := &gnosis.SyncMonitor{
 		DBPool:        dbpool,
 		CheckInterval: 5 * time.Second,
 	}
 
-	monitorCtx, cancelMonitor := context.WithCancel(parentCtx)
+	monitorCtx, cancelMonitor := context.WithCancel(ctx)
 	defer cancelMonitor()
 
 	errCh := make(chan error, 1)