github.com/kchristidis/fabric@v1.0.4-0.20171028114726-837acd08cde1/peer/channel/join_test.go (about)

     1  /*
     2   Copyright Digital Asset Holdings, LLC 2017 All Rights Reserved.
     3  
     4   Licensed under the Apache License, Version 2.0 (the "License");
     5   you may not use this file except in compliance with the License.
     6   You may obtain a copy of the License at
     7  
     8        http://www.apache.org/licenses/LICENSE-2.0
     9  
    10   Unless required by applicable law or agreed to in writing, software
    11   distributed under the License is distributed on an "AS IS" BASIS,
    12   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    13   See the License for the specific language governing permissions and
    14   limitations under the License.
    15  */
    16  
    17  package channel
    18  
    19  import (
    20  	"io/ioutil"
    21  	"os"
    22  	"path/filepath"
    23  	"testing"
    24  
    25  	"github.com/hyperledger/fabric/peer/common"
    26  	pb "github.com/hyperledger/fabric/protos/peer"
    27  	"github.com/stretchr/testify/assert"
    28  )
    29  
    30  func TestMissingBlockFile(t *testing.T) {
    31  	resetFlags()
    32  
    33  	cmd := joinCmd(nil)
    34  	AddFlags(cmd)
    35  	args := []string{}
    36  	cmd.SetArgs(args)
    37  
    38  	assert.Error(t, cmd.Execute(), "expected join command to fail due to missing blockfilepath")
    39  }
    40  
    41  func TestJoin(t *testing.T) {
    42  	InitMSP()
    43  	resetFlags()
    44  
    45  	dir, err := ioutil.TempDir("/tmp", "jointest")
    46  	assert.NoError(t, err, "Could not create the directory %s", dir)
    47  	mockblockfile := filepath.Join(dir, "mockjointest.block")
    48  	err = ioutil.WriteFile(mockblockfile, []byte(""), 0644)
    49  	assert.NoError(t, err, "Could not write to the file %s", mockblockfile)
    50  	defer os.RemoveAll(dir)
    51  	signer, err := common.GetDefaultSigner()
    52  	assert.NoError(t, err, "Get default signer error: %v", err)
    53  
    54  	mockResponse := &pb.ProposalResponse{
    55  		Response:    &pb.Response{Status: 200},
    56  		Endorsement: &pb.Endorsement{},
    57  	}
    58  
    59  	mockEndorerClient := common.GetMockEndorserClient(mockResponse, nil)
    60  
    61  	mockCF := &ChannelCmdFactory{
    62  		EndorserClient:   mockEndorerClient,
    63  		BroadcastFactory: mockBroadcastClientFactory,
    64  		Signer:           signer,
    65  	}
    66  
    67  	cmd := joinCmd(mockCF)
    68  	AddFlags(cmd)
    69  
    70  	args := []string{"-b", mockblockfile}
    71  	cmd.SetArgs(args)
    72  
    73  	assert.NoError(t, cmd.Execute(), "expected join command to succeed")
    74  }
    75  
    76  func TestJoinNonExistentBlock(t *testing.T) {
    77  	InitMSP()
    78  	resetFlags()
    79  
    80  	signer, err := common.GetDefaultSigner()
    81  	if err != nil {
    82  		t.Fatalf("Get default signer error: %v", err)
    83  	}
    84  
    85  	mockResponse := &pb.ProposalResponse{
    86  		Response:    &pb.Response{Status: 200},
    87  		Endorsement: &pb.Endorsement{},
    88  	}
    89  
    90  	mockEndorerClient := common.GetMockEndorserClient(mockResponse, nil)
    91  
    92  	mockCF := &ChannelCmdFactory{
    93  		EndorserClient:   mockEndorerClient,
    94  		BroadcastFactory: mockBroadcastClientFactory,
    95  		Signer:           signer,
    96  	}
    97  
    98  	cmd := joinCmd(mockCF)
    99  
   100  	AddFlags(cmd)
   101  
   102  	args := []string{"-b", "mockchain.block"}
   103  	cmd.SetArgs(args)
   104  
   105  	err = cmd.Execute()
   106  	assert.Error(t, err, "expected join command to fail")
   107  	assert.IsType(t, GBFileNotFoundErr(err.Error()), err, "expected error type of GBFileNotFoundErr")
   108  }
   109  
   110  func TestBadProposalResponse(t *testing.T) {
   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  	mockEndorerClient := common.GetMockEndorserClient(mockResponse, nil)
   126  
   127  	mockCF := &ChannelCmdFactory{
   128  		EndorserClient:   mockEndorerClient,
   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  func TestJoinNilCF(t *testing.T) {
   145  	InitMSP()
   146  	resetFlags()
   147  
   148  	dir, err := ioutil.TempDir("/tmp", "jointest")
   149  	assert.NoError(t, err, "Could not create the directory %s", dir)
   150  	mockblockfile := filepath.Join(dir, "mockjointest.block")
   151  	defer os.RemoveAll(dir)
   152  	cmd := joinCmd(nil)
   153  	AddFlags(cmd)
   154  	args := []string{"-b", mockblockfile}
   155  	cmd.SetArgs(args)
   156  
   157  	err = cmd.Execute()
   158  	assert.Error(t, err)
   159  	assert.Contains(t, err.Error(), "Error trying to connect to local peer")
   160  }