github.com/defanghe/fabric@v2.1.1+incompatible/internal/peer/channel/join_test.go (about)

     1  /*
     2  Copyright Digital Asset Holdings, LLC 2017 All Rights Reserved.
     3  
     4  SPDX-License-Identifier: Apache-2.0
     5  */
     6  
     7  package channel
     8  
     9  import (
    10  	"io/ioutil"
    11  	"os"
    12  	"path/filepath"
    13  	"testing"
    14  	"time"
    15  
    16  	pb "github.com/hyperledger/fabric-protos-go/peer"
    17  	"github.com/hyperledger/fabric/internal/peer/common"
    18  	"github.com/spf13/viper"
    19  	"github.com/stretchr/testify/assert"
    20  )
    21  
    22  func TestMissingBlockFile(t *testing.T) {
    23  	defer resetFlags()
    24  
    25  	resetFlags()
    26  
    27  	cmd := joinCmd(nil)
    28  	AddFlags(cmd)
    29  	args := []string{}
    30  	cmd.SetArgs(args)
    31  
    32  	assert.Error(t, cmd.Execute(), "expected join command to fail due to missing blockfilepath")
    33  }
    34  
    35  func TestJoin(t *testing.T) {
    36  	defer resetFlags()
    37  
    38  	InitMSP()
    39  	resetFlags()
    40  
    41  	dir, err := ioutil.TempDir("/tmp", "jointest")
    42  	assert.NoError(t, err, "Could not create the directory %s", dir)
    43  	mockblockfile := filepath.Join(dir, "mockjointest.block")
    44  	err = ioutil.WriteFile(mockblockfile, []byte(""), 0644)
    45  	assert.NoError(t, err, "Could not write to the file %s", mockblockfile)
    46  	defer os.RemoveAll(dir)
    47  	signer, err := common.GetDefaultSigner()
    48  	assert.NoError(t, err, "Get default signer error: %v", err)
    49  
    50  	mockResponse := &pb.ProposalResponse{
    51  		Response:    &pb.Response{Status: 200},
    52  		Endorsement: &pb.Endorsement{},
    53  	}
    54  
    55  	mockEndorserClient := common.GetMockEndorserClient(mockResponse, nil)
    56  
    57  	mockCF := &ChannelCmdFactory{
    58  		EndorserClient:   mockEndorserClient,
    59  		BroadcastFactory: mockBroadcastClientFactory,
    60  		Signer:           signer,
    61  	}
    62  
    63  	cmd := joinCmd(mockCF)
    64  	AddFlags(cmd)
    65  
    66  	args := []string{"-b", mockblockfile}
    67  	cmd.SetArgs(args)
    68  
    69  	assert.NoError(t, cmd.Execute(), "expected join command to succeed")
    70  }
    71  
    72  func TestJoinNonExistentBlock(t *testing.T) {
    73  	defer resetFlags()
    74  
    75  	InitMSP()
    76  	resetFlags()
    77  
    78  	signer, err := common.GetDefaultSigner()
    79  	if err != nil {
    80  		t.Fatalf("Get default signer error: %v", err)
    81  	}
    82  
    83  	mockResponse := &pb.ProposalResponse{
    84  		Response:    &pb.Response{Status: 200},
    85  		Endorsement: &pb.Endorsement{},
    86  	}
    87  
    88  	mockEndorserClient := common.GetMockEndorserClient(mockResponse, nil)
    89  
    90  	mockCF := &ChannelCmdFactory{
    91  		EndorserClient:   mockEndorserClient,
    92  		BroadcastFactory: mockBroadcastClientFactory,
    93  		Signer:           signer,
    94  	}
    95  
    96  	cmd := joinCmd(mockCF)
    97  
    98  	AddFlags(cmd)
    99  
   100  	args := []string{"-b", "mockchain.block"}
   101  	cmd.SetArgs(args)
   102  
   103  	err = cmd.Execute()
   104  	assert.Error(t, err, "expected join command to fail")
   105  	assert.IsType(t, GBFileNotFoundErr(err.Error()), err, "expected error type of GBFileNotFoundErr")
   106  }
   107  
   108  func TestBadProposalResponse(t *testing.T) {
   109  	defer resetFlags()
   110  
   111  	InitMSP()
   112  	resetFlags()
   113  
   114  	mockblockfile := "/tmp/mockjointest.block"
   115  	ioutil.WriteFile(mockblockfile, []byte(""), 0644)
   116  	defer os.Remove(mockblockfile)
   117  	signer, err := common.GetDefaultSigner()
   118  	assert.NoError(t, err, "Get default signer error: %v", err)
   119  
   120  	mockResponse := &pb.ProposalResponse{
   121  		Response:    &pb.Response{Status: 500},
   122  		Endorsement: &pb.Endorsement{},
   123  	}
   124  
   125  	mockEndorserClient := common.GetMockEndorserClient(mockResponse, nil)
   126  
   127  	mockCF := &ChannelCmdFactory{
   128  		EndorserClient:   mockEndorserClient,
   129  		BroadcastFactory: mockBroadcastClientFactory,
   130  		Signer:           signer,
   131  	}
   132  
   133  	cmd := joinCmd(mockCF)
   134  
   135  	AddFlags(cmd)
   136  
   137  	args := []string{"-b", mockblockfile}
   138  	cmd.SetArgs(args)
   139  
   140  	err = cmd.Execute()
   141  	assert.Error(t, err, "expected join command to fail")
   142  	assert.IsType(t, ProposalFailedErr(err.Error()), err, "expected error type of ProposalFailedErr")
   143  }
   144  
   145  func TestJoinNilCF(t *testing.T) {
   146  	defer viper.Reset()
   147  	defer resetFlags()
   148  
   149  	InitMSP()
   150  	resetFlags()
   151  
   152  	dir, err := ioutil.TempDir("/tmp", "jointest")
   153  	assert.NoError(t, err, "Could not create the directory %s", dir)
   154  	mockblockfile := filepath.Join(dir, "mockjointest.block")
   155  	defer os.RemoveAll(dir)
   156  	viper.Set("peer.client.connTimeout", 10*time.Millisecond)
   157  	cmd := joinCmd(nil)
   158  	AddFlags(cmd)
   159  	args := []string{"-b", mockblockfile}
   160  	cmd.SetArgs(args)
   161  
   162  	err = cmd.Execute()
   163  	assert.Error(t, err)
   164  	assert.Contains(t, err.Error(), "endorser client failed to connect to")
   165  }