github.com/lzy4123/fabric@v2.1.1+incompatible/internal/peer/common/deliverclient_test.go (about)

     1  /*
     2  Copyright IBM Corp. All Rights Reserved.
     3  
     4  SPDX-License-Identifier: Apache-2.0
     5  */
     6  
     7  package common
     8  
     9  import (
    10  	"errors"
    11  	"fmt"
    12  	"sync"
    13  	"testing"
    14  
    15  	cb "github.com/hyperledger/fabric-protos-go/common"
    16  	ab "github.com/hyperledger/fabric-protos-go/orderer"
    17  	"github.com/hyperledger/fabric/core/config/configtest"
    18  	"github.com/hyperledger/fabric/internal/peer/common/mock"
    19  	"github.com/hyperledger/fabric/internal/pkg/identity"
    20  	msptesttools "github.com/hyperledger/fabric/msp/mgmt/testtools"
    21  	"github.com/hyperledger/fabric/protoutil"
    22  	"github.com/spf13/viper"
    23  	"github.com/stretchr/testify/assert"
    24  )
    25  
    26  //go:generate counterfeiter -o mock/signer_serializer.go --fake-name SignerSerializer . signerSerializer
    27  
    28  type signerSerializer interface {
    29  	identity.SignerSerializer
    30  }
    31  
    32  //go:generate counterfeiter -o mock/deliverservice.go --fake-name DeliverService . deliverService
    33  
    34  type deliverService interface {
    35  	ab.AtomicBroadcast_DeliverClient
    36  }
    37  
    38  var once sync.Once
    39  
    40  // InitMSP init MSP
    41  func InitMSP() {
    42  	once.Do(initMSP)
    43  }
    44  
    45  func initMSP() {
    46  	err := msptesttools.LoadMSPSetupForTesting()
    47  	if err != nil {
    48  		panic(fmt.Errorf("Fatal error when reading MSP config: err %s", err))
    49  	}
    50  }
    51  
    52  func TestDeliverClientErrors(t *testing.T) {
    53  	InitMSP()
    54  
    55  	mockClient := &mock.DeliverService{}
    56  	o := &DeliverClient{
    57  		Service: mockClient,
    58  	}
    59  
    60  	// failure - recv returns error
    61  	mockClient.RecvReturns(nil, errors.New("monkey"))
    62  	block, err := o.readBlock()
    63  	assert.Nil(t, block)
    64  	assert.Error(t, err)
    65  	assert.Contains(t, err.Error(), "error receiving: monkey")
    66  
    67  	// failure - recv returns status
    68  	statusResponse := &ab.DeliverResponse{
    69  		Type: &ab.DeliverResponse_Status{Status: cb.Status_SUCCESS},
    70  	}
    71  	mockClient.RecvReturns(statusResponse, nil)
    72  	block, err = o.readBlock()
    73  	assert.Nil(t, block)
    74  	assert.Error(t, err)
    75  	assert.Contains(t, err.Error(), "can't read the block")
    76  
    77  	// failure - recv returns empty proto
    78  	mockClient.RecvReturns(&ab.DeliverResponse{}, nil)
    79  	block, err = o.readBlock()
    80  	assert.Nil(t, block)
    81  	assert.Error(t, err)
    82  	assert.Contains(t, err.Error(), "response error: unknown type")
    83  
    84  	// failures - send returns error
    85  	// getting specified block
    86  	mockClient.SendReturns(errors.New("gorilla"))
    87  	block, err = o.GetSpecifiedBlock(0)
    88  	assert.Nil(t, block)
    89  	assert.Error(t, err)
    90  	assert.Contains(t, err.Error(), "error getting specified block: gorilla")
    91  
    92  	// getting oldest block
    93  	block, err = o.GetOldestBlock()
    94  	assert.Nil(t, block)
    95  	assert.Error(t, err)
    96  	assert.Contains(t, err.Error(), "error getting oldest block: gorilla")
    97  
    98  	// getting newest block
    99  	block, err = o.GetNewestBlock()
   100  	assert.Nil(t, block)
   101  	assert.Error(t, err)
   102  	assert.Contains(t, err.Error(), "error getting newest block: gorilla")
   103  }
   104  
   105  func TestSeekHelper(t *testing.T) {
   106  	t.Run("Standard", func(t *testing.T) {
   107  		env := seekHelper("channel-id", &ab.SeekPosition{}, nil, nil, false)
   108  		assert.NotNil(t, env)
   109  		seekInfo := &ab.SeekInfo{}
   110  		_, err := protoutil.UnmarshalEnvelopeOfType(env, cb.HeaderType_DELIVER_SEEK_INFO, seekInfo)
   111  		assert.NoError(t, err)
   112  		assert.Equal(t, seekInfo.Behavior, ab.SeekInfo_BLOCK_UNTIL_READY)
   113  		assert.Equal(t, seekInfo.ErrorResponse, ab.SeekInfo_STRICT)
   114  	})
   115  
   116  	t.Run("BestEffort", func(t *testing.T) {
   117  		env := seekHelper("channel-id", &ab.SeekPosition{}, nil, nil, true)
   118  		assert.NotNil(t, env)
   119  		seekInfo := &ab.SeekInfo{}
   120  		_, err := protoutil.UnmarshalEnvelopeOfType(env, cb.HeaderType_DELIVER_SEEK_INFO, seekInfo)
   121  		assert.NoError(t, err)
   122  		assert.Equal(t, seekInfo.ErrorResponse, ab.SeekInfo_BEST_EFFORT)
   123  	})
   124  }
   125  
   126  func TestNewOrdererDeliverClient(t *testing.T) {
   127  	defer viper.Reset()
   128  	cleanup := configtest.SetDevFabricConfigPath(t)
   129  	defer cleanup()
   130  	InitMSP()
   131  
   132  	// failure - rootcert file doesn't exist
   133  	viper.Set("orderer.tls.enabled", true)
   134  	viper.Set("orderer.tls.rootcert.file", "ukelele.crt")
   135  	oc, err := NewDeliverClientForOrderer("ukelele", &mock.SignerSerializer{}, false)
   136  	assert.Nil(t, oc)
   137  	assert.Error(t, err)
   138  	assert.Contains(t, err.Error(), "failed to create deliver client for orderer: failed to load config for OrdererClient")
   139  }
   140  
   141  func TestNewDeliverClientForPeer(t *testing.T) {
   142  	defer viper.Reset()
   143  	cleanup := configtest.SetDevFabricConfigPath(t)
   144  	defer cleanup()
   145  	InitMSP()
   146  
   147  	// failure - rootcert file doesn't exist
   148  	viper.Set("peer.tls.enabled", true)
   149  	viper.Set("peer.tls.rootcert.file", "ukelele.crt")
   150  	pc, err := NewDeliverClientForPeer("ukelele", &mock.SignerSerializer{}, false)
   151  	assert.Nil(t, pc)
   152  	assert.Error(t, err)
   153  	assert.Contains(t, err.Error(), "failed to create deliver client for peer: failed to load config for PeerClient")
   154  }