Add chaincode-to-fsc PoC with full integration test

Signed-off-by: Shivam <shivam@obmondo.com>

Author: Rozerxshashank

platform/fabric/core/generic/finality/committerflm_test.go

@@ -0,0 +1,47 @@
+/*
+Copyright IBM Corp. All Rights Reserved.
+
+SPDX-License-Identifier: Apache-2.0
+*/
+
+package finality
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
+
+	"github.com/hyperledger-labs/fabric-smart-client/platform/fabric"
+	finalitymock "github.com/hyperledger-labs/fabric-smart-client/platform/fabric/core/generic/finality/mock"
+)
+
+func TestCommitterFLM(t *testing.T) {
+	t.Parallel()
+
+	setup := func() (*finalitymock.Committer, *committerListenerManager) {
+		mockCommitter := &finalitymock.Committer{}
+		mockChannel := &finalitymock.Channel{}
+		mockChannel.On("Committer").Return(mockCommitter)
+
+		committer := fabric.NewCommitter(mockChannel)
+		flm := NewCommitterFLM(committer)
+		return mockCommitter, flm
+	}
+
+	t.Run("AddFinalityListener", func(t *testing.T) {
+		t.Parallel()
+		mockCommitter, flm := setup()
+		mockCommitter.On("AddFinalityListener", "tx1", mock.Anything).Return(nil).Once()
+		err := flm.AddFinalityListener("", "tx1", &finalitymock.FinalityListener{})
+		assert.NoError(t, err)
+	})
+
+	t.Run("RemoveFinalityListener", func(t *testing.T) {
+		t.Parallel()
+		mockCommitter, flm := setup()
+		mockCommitter.On("RemoveFinalityListener", "tx1", mock.Anything).Return(nil).Once()
+		err := flm.RemoveFinalityListener("tx1", &finalitymock.FinalityListener{})
+		assert.NoError(t, err)
+	})
+}

platform/fabric/core/generic/finality/deliveryflm_test.go

@@ -0,0 +1,158 @@
+/*
+Copyright IBM Corp. All Rights Reserved.
+
+SPDX-License-Identifier: Apache-2.0
+*/
+
+package finality
+
+import (
+	"context"
+	"reflect"
+	"testing"
+
+	"github.com/hyperledger/fabric-protos-go-apiv2/common"
+	"github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/require"
+
+	"github.com/hyperledger-labs/fabric-smart-client/pkg/utils/proto"
+	driver2 "github.com/hyperledger-labs/fabric-smart-client/platform/common/driver"
+	"github.com/hyperledger-labs/fabric-smart-client/platform/common/services/logging"
+	"github.com/hyperledger-labs/fabric-smart-client/platform/fabric"
+	"github.com/hyperledger-labs/fabric-smart-client/platform/fabric/core/generic/events"
+	finalitymock "github.com/hyperledger-labs/fabric-smart-client/platform/fabric/core/generic/finality/mock"
+	"github.com/hyperledger-labs/fabric-smart-client/platform/fabric/driver"
+)
+
+func TestDeliveryFLM(t *testing.T) {
+	t.Parallel()
+
+	setup := func() (*mockListenerManager, *deliveryListenerManager) {
+		mockLM := &mockListenerManager{}
+		dlm := &deliveryListenerManager{flm: mockLM}
+		return mockLM, dlm
+	}
+
+	t.Run("AddFinalityListener", func(t *testing.T) {
+		t.Parallel()
+		mockLM, dlm := setup()
+		mockLM.On("AddEventListener", "tx1", mock.Anything).Return(nil).Once()
+		err := dlm.AddFinalityListener("tx1", &finalitymock.FinalityListener{})
+		require.NoError(t, err)
+	})
+
+	t.Run("RemoveFinalityListener", func(t *testing.T) {
+		t.Parallel()
+		mockLM, dlm := setup()
+		mockLM.On("RemoveEventListener", "tx1", mock.Anything).Return(nil).Once()
+		err := dlm.RemoveFinalityListener("tx1", &finalitymock.FinalityListener{})
+		require.NoError(t, err)
+	})
+
+	t.Run("deliveryListenerEntry", func(t *testing.T) {
+		t.Parallel()
+		mockFL := &finalitymock.FinalityListener{}
+		entry := &deliveryListenerEntry{l: mockFL}
+
+		require.Equal(t, driver2.Namespace(""), entry.Namespace())
+
+		ctx := context.Background()
+		info := txInfo{txID: "tx1", status: driver.Valid, message: "ok"}
+		mockFL.On("OnStatus", ctx, "tx1", driver.Valid, "ok").Once()
+		entry.OnStatus(ctx, info)
+		mockFL.AssertExpectations(t)
+
+		require.True(t, entry.Equals(&deliveryListenerEntry{l: mockFL}))
+		require.False(t, entry.Equals(nil))
+		require.False(t, entry.Equals(&deliveryListenerEntry{l: &finalitymock.FinalityListener{}}))
+	})
+
+	t.Run("txInfo_ID", func(t *testing.T) {
+		t.Parallel()
+		info := txInfo{txID: "tx1"}
+		require.Equal(t, events.EventID("tx1"), info.ID())
+	})
+}
+
+type mockListenerManager struct {
+	mock.Mock
+}
+
+func (m *mockListenerManager) AddEventListener(txID string, e events.ListenerEntry[txInfo]) error {
+	args := m.Called(txID, e)
+	return args.Error(0)
+}
+
+func (m *mockListenerManager) RemoveEventListener(txID string, e events.ListenerEntry[txInfo]) error {
+	args := m.Called(txID, e)
+	return args.Error(0)
+}
+
+func TestNewDeliveryFLM(t *testing.T) {
+	t.Parallel()
+	logger := logging.MustGetLogger("test")
+
+	mockChannelDriver := &finalitymock.Channel{}
+	mockD := &finalitymock.Delivery{}
+	mockChannelDriver.On("Delivery").Return(mockD)
+
+	fCh := &fabric.Channel{}
+	v := reflect.ValueOf(fCh).Elem()
+	f := v.FieldByName("ch")
+	ptr := reflect.NewAt(f.Type(), f.Addr().UnsafePointer()).Elem()
+	ptr.Set(reflect.ValueOf(mockChannelDriver))
+
+	config := events.DeliveryListenerManagerConfig{}
+	flm, err := NewDeliveryFLM(logger, config, "test-network", fCh)
+	if err == nil {
+		require.NotNil(t, flm)
+	}
+}
+
+func TestTxInfoMapper(t *testing.T) {
+	t.Parallel()
+	mapper := &txInfoMapper{network: "test", logger: nil}
+
+	t.Run("MapProcessedTx", func(t *testing.T) {
+		t.Parallel()
+		mockPT := &finalitymock.ProcessedTransaction{}
+		mockPT.On("TxID").Return("tx1")
+		mockPT.On("ValidationCode").Return(int32(0)) // Valid
+
+		pt := newProcessedTransaction(mockPT)
+		infos, err := mapper.MapProcessedTx(pt)
+		require.NoError(t, err)
+		require.Len(t, infos, 1)
+		require.Equal(t, "tx1", infos[0].txID)
+		require.Equal(t, driver.Valid, infos[0].status)
+	})
+
+	t.Run("MapTxData_UnmarshalError", func(t *testing.T) {
+		t.Parallel()
+		logger := logging.MustGetLogger("test")
+		mapper := &txInfoMapper{logger: logger}
+		_, err := mapper.MapTxData(context.Background(), []byte("invalid"), nil, 0, 0)
+		require.Error(t, err)
+		require.Contains(t, err.Error(), "failed unmarshaling tx")
+	})
+
+	t.Run("MapTxData_WrongHeaderType", func(t *testing.T) {
+		t.Parallel()
+		logger := logging.MustGetLogger("test")
+		mapper := &txInfoMapper{logger: logger}
+
+		chdrRaw, _ := proto.Marshal(&common.ChannelHeader{Type: int32(common.HeaderType_CONFIG)})
+		payloadRaw, _ := proto.Marshal(&common.Payload{
+			Header: &common.Header{
+				ChannelHeader: chdrRaw,
+			},
+		})
+		envRaw, _ := proto.Marshal(&common.Envelope{
+			Payload: payloadRaw,
+		})
+
+		infos, err := mapper.MapTxData(context.Background(), envRaw, nil, 0, 0)
+		require.NoError(t, err)
+		require.Nil(t, infos)
+	})
+}