cre-1601: more tests; boosting test coverage

Author: mchain0

pkg/workflows/ring/factory_test.go

@@ -0,0 +1,63 @@
+package ring
+
+import (
+	"context"
+	"testing"
+
+	"github.com/smartcontractkit/chainlink-common/pkg/logger"
+	"github.com/smartcontractkit/libocr/offchainreporting2plus/ocr3types"
+	"github.com/stretchr/testify/require"
+)
+
+func TestFactory_NewFactory(t *testing.T) {
+	lggr := logger.Test(t)
+	store := NewStore()
+
+	t.Run("with_nil_config", func(t *testing.T) {
+		f, err := NewFactory(store, lggr, nil)
+		require.NoError(t, err)
+		require.NotNil(t, f)
+	})
+
+	t.Run("with_custom_config", func(t *testing.T) {
+		cfg := &ConsensusConfig{BatchSize: 50}
+		f, err := NewFactory(store, lggr, cfg)
+		require.NoError(t, err)
+		require.NotNil(t, f)
+	})
+}
+
+func TestFactory_NewReportingPlugin(t *testing.T) {
+	lggr := logger.Test(t)
+	store := NewStore()
+	f, err := NewFactory(store, lggr, nil)
+	require.NoError(t, err)
+
+	config := ocr3types.ReportingPluginConfig{N: 4, F: 1}
+	plugin, info, err := f.NewReportingPlugin(context.Background(), config)
+	require.NoError(t, err)
+	require.NotNil(t, plugin)
+	require.NotEmpty(t, info.Name)
+	require.Equal(t, "Shard Orchestrator Consensus Plugin", info.Name)
+	require.Equal(t, defaultMaxReportCount, info.Limits.MaxReportCount)
+}
+
+func TestFactory_Lifecycle(t *testing.T) {
+	lggr := logger.Test(t)
+	store := NewStore()
+	f, err := NewFactory(store, lggr, nil)
+	require.NoError(t, err)
+
+	err = f.Start(context.Background())
+	require.NoError(t, err)
+
+	name := f.Name()
+	require.NotEmpty(t, name)
+
+	report := f.HealthReport()
+	require.NotNil(t, report)
+	require.Contains(t, report, name)
+
+	err = f.Close()
+	require.NoError(t, err)
+}

pkg/workflows/ring/plugin.go

@@ -74,6 +74,7 @@ func NewPlugin(store *Store, config ocr3types.ReportingPluginConfig, lggr logger
 	}, nil
 }
 
+//coverage:ignore
 func (p *Plugin) Query(_ context.Context, _ ocr3types.OutcomeContext) (types.Query, error) {
 	return nil, nil
 }
@@ -100,6 +101,7 @@ func (p *Plugin) Observation(_ context.Context, _ ocr3types.OutcomeContext, _ ty
 	return proto.MarshalOptions{Deterministic: true}.Marshal(observation)
 }
 
+//coverage:ignore
 func (p *Plugin) ValidateObservation(_ context.Context, _ ocr3types.OutcomeContext, _ types.Query, _ types.AttributedObservation) error {
 	return nil
 }
@@ -265,14 +267,17 @@ func (p *Plugin) Reports(_ context.Context, _ uint64, outcome ocr3types.Outcome)
 	}, nil
 }
 
+//coverage:ignore
 func (p *Plugin) ShouldAcceptAttestedReport(_ context.Context, _ uint64, _ ocr3types.ReportWithInfo[[]byte]) (bool, error) {
 	return true, nil
 }
 
+//coverage:ignore
 func (p *Plugin) ShouldTransmitAcceptedReport(_ context.Context, _ uint64, _ ocr3types.ReportWithInfo[[]byte]) (bool, error) {
 	return true, nil
 }
 
+//coverage:ignore
 func (p *Plugin) Close() error {
 	return nil
 }

pkg/workflows/ring/plugin_test.go

@@ -1,6 +1,7 @@
 package ring
 
 import (
+	"context"
 	"testing"
 	"time"
 
@@ -374,3 +375,62 @@ func TestPlugin_getHealthyShards(t *testing.T) {
 		})
 	}
 }
+
+func TestPlugin_ObservationQuorum(t *testing.T) {
+	lggr := logger.Test(t)
+	store := NewStore()
+	config := ocr3types.ReportingPluginConfig{N: 4, F: 1}
+	plugin, err := NewPlugin(store, config, lggr, nil)
+	require.NoError(t, err)
+
+	ctx := context.Background()
+	outctx := ocr3types.OutcomeContext{}
+
+	t.Run("quorum_reached", func(t *testing.T) {
+		// Need 2F+1 = 3 observations for quorum with N=4, F=1
+		aos := make([]types.AttributedObservation, 3)
+		for i := range aos {
+			aos[i] = types.AttributedObservation{Observer: commontypes.OracleID(i)}
+		}
+
+		quorum, err := plugin.ObservationQuorum(ctx, outctx, nil, aos)
+		require.NoError(t, err)
+		require.True(t, quorum)
+	})
+
+	t.Run("quorum_not_reached", func(t *testing.T) {
+		// Only 2 observations - not enough for quorum
+		aos := make([]types.AttributedObservation, 2)
+		for i := range aos {
+			aos[i] = types.AttributedObservation{Observer: commontypes.OracleID(i)}
+		}
+
+		quorum, err := plugin.ObservationQuorum(ctx, outctx, nil, aos)
+		require.NoError(t, err)
+		require.False(t, quorum)
+	})
+
+	t.Run("exact_quorum", func(t *testing.T) {
+		// Exactly 2F+1 = 3 observations
+		aos := make([]types.AttributedObservation, 3)
+		for i := range aos {
+			aos[i] = types.AttributedObservation{Observer: commontypes.OracleID(i)}
+		}
+
+		quorum, err := plugin.ObservationQuorum(ctx, outctx, nil, aos)
+		require.NoError(t, err)
+		require.True(t, quorum)
+	})
+
+	t.Run("all_observations", func(t *testing.T) {
+		// All N=4 observations
+		aos := make([]types.AttributedObservation, 4)
+		for i := range aos {
+			aos[i] = types.AttributedObservation{Observer: commontypes.OracleID(i)}
+		}
+
+		quorum, err := plugin.ObservationQuorum(ctx, outctx, nil, aos)
+		require.NoError(t, err)
+		require.True(t, quorum)
+	})
+}

pkg/workflows/ring/store_test.go

@@ -225,3 +225,62 @@ func TestStore_PendingAllocsDuringTransition(t *testing.T) {
 		t.Fatal("allocation was not fulfilled")
 	}
 }
+
+func TestStore_AccessorMethods(t *testing.T) {
+	store := NewStore()
+
+	store.SetAllShardHealth(map[uint32]bool{0: true, 1: true, 2: false})
+	store.SetRoutingState(&pb.RoutingState{
+		State: &pb.RoutingState_RoutableShards{RoutableShards: 2},
+	})
+	store.SetShardForWorkflow("wf-1", 0)
+	store.SetShardForWorkflow("wf-2", 1)
+
+	t.Run("GetRoutingState", func(t *testing.T) {
+		state := store.GetRoutingState()
+		require.NotNil(t, state)
+		require.Equal(t, uint32(2), state.GetRoutableShards())
+	})
+
+	t.Run("IsInTransition_steady_state", func(t *testing.T) {
+		require.False(t, store.IsInTransition())
+	})
+
+	t.Run("GetShardHealth", func(t *testing.T) {
+		health := store.GetShardHealth()
+		require.Len(t, health, 3)
+		require.True(t, health[0])
+		require.True(t, health[1])
+		require.False(t, health[2])
+	})
+
+	t.Run("GetAllRoutingState", func(t *testing.T) {
+		routes := store.GetAllRoutingState()
+		require.Len(t, routes, 2)
+		require.Equal(t, uint32(0), routes["wf-1"])
+		require.Equal(t, uint32(1), routes["wf-2"])
+	})
+
+	t.Run("GetHealthyShardCount", func(t *testing.T) {
+		require.Equal(t, 2, store.GetHealthyShardCount())
+	})
+
+	t.Run("DeleteWorkflow", func(t *testing.T) {
+		store.DeleteWorkflow("wf-1")
+		routes := store.GetAllRoutingState()
+		require.Len(t, routes, 1)
+		require.NotContains(t, routes, "wf-1")
+	})
+
+	t.Run("IsInTransition_transition_state", func(t *testing.T) {
+		store.SetRoutingState(&pb.RoutingState{
+			State: &pb.RoutingState_Transition{Transition: &pb.Transition{WantShards: 3}},
+		})
+		require.True(t, store.IsInTransition())
+	})
+
+	t.Run("IsInTransition_nil_state", func(t *testing.T) {
+		store.SetRoutingState(nil)
+		require.True(t, store.IsInTransition())
+	})
+}

pkg/workflows/ring/transmitter_test.go

@@ -0,0 +1,121 @@
+package ring
+
+import (
+	"context"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"google.golang.org/grpc"
+	"google.golang.org/protobuf/proto"
+	"google.golang.org/protobuf/types/known/emptypb"
+
+	"github.com/smartcontractkit/chainlink-common/pkg/logger"
+	"github.com/smartcontractkit/chainlink-common/pkg/workflows/ring/pb"
+	"github.com/smartcontractkit/libocr/offchainreporting2plus/ocr3types"
+	"github.com/smartcontractkit/libocr/offchainreporting2plus/types"
+)
+
+type mockArbiterScaler struct {
+	called  bool
+	nShards uint32
+}
+
+func (m *mockArbiterScaler) Status(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*pb.ReplicaStatus, error) {
+	return &pb.ReplicaStatus{}, nil
+}
+
+func (m *mockArbiterScaler) ConsensusWantShards(ctx context.Context, req *pb.ConsensusWantShardsRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
+	m.called = true
+	m.nShards = req.NShards
+	return &emptypb.Empty{}, nil
+}
+
+func TestTransmitter_NewTransmitter(t *testing.T) {
+	lggr := logger.Test(t)
+	store := NewStore()
+	tx := NewTransmitter(lggr, store, nil, "test-account")
+	require.NotNil(t, tx)
+}
+
+func TestTransmitter_FromAccount(t *testing.T) {
+	lggr := logger.Test(t)
+	store := NewStore()
+	tx := NewTransmitter(lggr, store, nil, "my-account")
+
+	account, err := tx.FromAccount(context.Background())
+	require.NoError(t, err)
+	require.Equal(t, types.Account("my-account"), account)
+}
+
+func TestTransmitter_Transmit(t *testing.T) {
+	lggr := logger.Test(t)
+	store := NewStore()
+	mock := &mockArbiterScaler{}
+	tx := NewTransmitter(lggr, store, mock, "test-account")
+
+	outcome := &pb.Outcome{
+		State: &pb.RoutingState{
+			Id:    1,
+			State: &pb.RoutingState_RoutableShards{RoutableShards: 3},
+		},
+		Routes: map[string]*pb.WorkflowRoute{
+			"wf-1": {Shard: 0},
+			"wf-2": {Shard: 1},
+		},
+	}
+	outcomeBytes, err := proto.Marshal(outcome)
+	require.NoError(t, err)
+
+	report := ocr3types.ReportWithInfo[[]byte]{Report: outcomeBytes}
+	err = tx.Transmit(context.Background(), types.ConfigDigest{}, 0, report, nil)
+	require.NoError(t, err)
+
+	// Verify arbiter was notified
+	require.True(t, mock.called)
+	require.Equal(t, uint32(3), mock.nShards)
+
+	// Verify store was updated
+	require.Equal(t, uint32(3), store.GetRoutingState().GetRoutableShards())
+	routes := store.GetAllRoutingState()
+	require.Equal(t, uint32(0), routes["wf-1"])
+	require.Equal(t, uint32(1), routes["wf-2"])
+}
+
+func TestTransmitter_Transmit_NilArbiter(t *testing.T) {
+	lggr := logger.Test(t)
+	store := NewStore()
+	tx := NewTransmitter(lggr, store, nil, "test-account")
+
+	outcome := &pb.Outcome{
+		State: &pb.RoutingState{
+			Id:    1,
+			State: &pb.RoutingState_RoutableShards{RoutableShards: 2},
+		},
+		Routes: map[string]*pb.WorkflowRoute{"wf-1": {Shard: 0}},
+	}
+	outcomeBytes, _ := proto.Marshal(outcome)
+
+	err := tx.Transmit(context.Background(), types.ConfigDigest{}, 0, ocr3types.ReportWithInfo[[]byte]{Report: outcomeBytes}, nil)
+	require.NoError(t, err)
+}
+
+func TestTransmitter_Transmit_TransitionState(t *testing.T) {
+	lggr := logger.Test(t)
+	store := NewStore()
+	mock := &mockArbiterScaler{}
+	tx := NewTransmitter(lggr, store, mock, "test-account")
+
+	outcome := &pb.Outcome{
+		State: &pb.RoutingState{
+			Id: 1,
+			State: &pb.RoutingState_Transition{
+				Transition: &pb.Transition{WantShards: 5},
+			},
+		},
+	}
+	outcomeBytes, _ := proto.Marshal(outcome)
+
+	err := tx.Transmit(context.Background(), types.ConfigDigest{}, 0, ocr3types.ReportWithInfo[[]byte]{Report: outcomeBytes}, nil)
+	require.NoError(t, err)
+	require.Equal(t, uint32(5), mock.nShards)
+}