github.com/leonlxy/hyperledger@v1.0.0-alpha.0.20170427033203-34922035d248/peer/channel/create_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  	"fmt"
    21  	"io/ioutil"
    22  	"os"
    23  	"path/filepath"
    24  	"sync"
    25  	"testing"
    26  
    27  	"github.com/golang/protobuf/proto"
    28  
    29  	"errors"
    30  
    31  	"github.com/hyperledger/fabric/msp/mgmt/testtools"
    32  	"github.com/hyperledger/fabric/peer/common"
    33  	cb "github.com/hyperledger/fabric/protos/common"
    34  )
    35  
    36  var once sync.Once
    37  
    38  /// mock deliver client for UT
    39  type mockDeliverClient struct {
    40  	err error
    41  }
    42  
    43  func (m *mockDeliverClient) readBlock() (*cb.Block, error) {
    44  	if m.err != nil {
    45  		return nil, m.err
    46  	}
    47  	return &cb.Block{}, nil
    48  }
    49  
    50  func (m *mockDeliverClient) getBlock() (*cb.Block, error) {
    51  	b, err := m.readBlock()
    52  	if err != nil {
    53  		return nil, err
    54  	}
    55  
    56  	return b, nil
    57  }
    58  
    59  // InitMSP init MSP
    60  func InitMSP() {
    61  	once.Do(initMSP)
    62  }
    63  
    64  func initMSP() {
    65  	err := msptesttools.LoadMSPSetupForTesting()
    66  	if err != nil {
    67  		panic(fmt.Errorf("Fatal error when reading MSP config: err %s\n", err))
    68  	}
    69  }
    70  
    71  func mockBroadcastClientFactory() (common.BroadcastClient, error) {
    72  	return common.GetMockBroadcastClient(nil), nil
    73  }
    74  
    75  func TestCreateChain(t *testing.T) {
    76  	InitMSP()
    77  
    78  	mockchain := "mockchain"
    79  
    80  	defer os.Remove(mockchain + ".block")
    81  
    82  	signer, err := common.GetDefaultSigner()
    83  	if err != nil {
    84  		t.Fatalf("Get default signer error: %v", err)
    85  	}
    86  
    87  	mockCF := &ChannelCmdFactory{
    88  		BroadcastFactory: mockBroadcastClientFactory,
    89  		Signer:           signer,
    90  		DeliverClient:    &mockDeliverClient{},
    91  	}
    92  
    93  	cmd := createCmd(mockCF)
    94  
    95  	AddFlags(cmd)
    96  
    97  	args := []string{"-c", mockchain, "-o", "localhost:7050"}
    98  	cmd.SetArgs(args)
    99  
   100  	if err := cmd.Execute(); err != nil {
   101  		t.Fail()
   102  		t.Errorf("expected join command to succeed")
   103  	}
   104  }
   105  
   106  func TestCreateChainWithDefaultAnchorPeers(t *testing.T) {
   107  	InitMSP()
   108  
   109  	mockchain := "mockchain"
   110  
   111  	defer os.Remove(mockchain + ".block")
   112  
   113  	signer, err := common.GetDefaultSigner()
   114  	if err != nil {
   115  		t.Fatalf("Get default signer error: %v", err)
   116  	}
   117  
   118  	mockCF := &ChannelCmdFactory{
   119  		BroadcastFactory: mockBroadcastClientFactory,
   120  		Signer:           signer,
   121  		DeliverClient:    &mockDeliverClient{},
   122  	}
   123  
   124  	cmd := createCmd(mockCF)
   125  
   126  	AddFlags(cmd)
   127  
   128  	args := []string{"-c", mockchain, "-o", "localhost:7050"}
   129  	cmd.SetArgs(args)
   130  
   131  	if err := cmd.Execute(); err != nil {
   132  		t.Fail()
   133  		t.Errorf("expected join command to succeed")
   134  	}
   135  }
   136  
   137  func TestCreateChainBCFail(t *testing.T) {
   138  	InitMSP()
   139  
   140  	mockchain := "mockchain"
   141  
   142  	defer os.Remove(mockchain + ".block")
   143  
   144  	signer, err := common.GetDefaultSigner()
   145  	if err != nil {
   146  		t.Fatalf("Get default signer error: %v", err)
   147  	}
   148  
   149  	sendErr := errors.New("send create tx failed")
   150  
   151  	mockCF := &ChannelCmdFactory{
   152  		BroadcastFactory: func() (common.BroadcastClient, error) {
   153  			return common.GetMockBroadcastClient(sendErr), nil
   154  		},
   155  		Signer:        signer,
   156  		DeliverClient: &mockDeliverClient{},
   157  	}
   158  
   159  	cmd := createCmd(mockCF)
   160  
   161  	AddFlags(cmd)
   162  
   163  	args := []string{"-c", mockchain, "-o", "localhost:7050"}
   164  	cmd.SetArgs(args)
   165  
   166  	expectedErrMsg := sendErr.Error()
   167  	if err := cmd.Execute(); err == nil {
   168  		t.Error("expected create chain to fail with broadcast error")
   169  	} else {
   170  		if err.Error() != expectedErrMsg {
   171  			t.Errorf("Run create chain get unexpected error: %s(expected %s)", err.Error(), expectedErrMsg)
   172  		}
   173  	}
   174  }
   175  
   176  func TestCreateChainDeliverFail(t *testing.T) {
   177  	InitMSP()
   178  
   179  	mockchain := "mockchain"
   180  
   181  	defer os.Remove(mockchain + ".block")
   182  
   183  	signer, err := common.GetDefaultSigner()
   184  	if err != nil {
   185  		t.Fatalf("Get default signer error: %v", err)
   186  	}
   187  
   188  	recvErr := fmt.Errorf("deliver create tx failed")
   189  
   190  	mockCF := &ChannelCmdFactory{
   191  		BroadcastFactory: mockBroadcastClientFactory,
   192  		Signer:           signer,
   193  		DeliverClient:    &mockDeliverClient{recvErr},
   194  	}
   195  
   196  	cmd := createCmd(mockCF)
   197  
   198  	AddFlags(cmd)
   199  
   200  	args := []string{"-c", mockchain, "-o", "localhost:7050"}
   201  	cmd.SetArgs(args)
   202  
   203  	expectedErrMsg := recvErr.Error()
   204  	if err := cmd.Execute(); err == nil {
   205  		t.Errorf("expected create chain to fail with deliver error")
   206  	} else {
   207  		if err.Error() != expectedErrMsg {
   208  			t.Errorf("Run create chain get unexpected error: %s(expected %s)", err.Error(), expectedErrMsg)
   209  		}
   210  	}
   211  }
   212  
   213  func createTxFile(filename string, typ cb.HeaderType, channelID string) (*cb.Envelope, error) {
   214  	ch := &cb.ChannelHeader{Type: int32(typ), ChannelId: channelID}
   215  	data, err := proto.Marshal(ch)
   216  	if err != nil {
   217  		return nil, err
   218  	}
   219  
   220  	p := &cb.Payload{Header: &cb.Header{ChannelHeader: data}}
   221  	data, err = proto.Marshal(p)
   222  	if err != nil {
   223  		return nil, err
   224  	}
   225  
   226  	env := &cb.Envelope{Payload: data}
   227  	data, err = proto.Marshal(env)
   228  	if err != nil {
   229  		return nil, err
   230  	}
   231  
   232  	if err = ioutil.WriteFile(filename, data, 0644); err != nil {
   233  		return nil, err
   234  	}
   235  
   236  	return env, nil
   237  }
   238  
   239  func TestCreateChainFromTx(t *testing.T) {
   240  	InitMSP()
   241  
   242  	mockchannel := "mockchannel"
   243  
   244  	dir, err := ioutil.TempDir("/tmp", "createtestfromtx-")
   245  	if err != nil {
   246  		t.Fatalf("couldn't create temp dir")
   247  	}
   248  
   249  	defer os.RemoveAll(dir) // clean up
   250  
   251  	//this could be created by the create command
   252  	defer os.Remove(mockchannel + ".block")
   253  
   254  	file := filepath.Join(dir, mockchannel)
   255  
   256  	signer, err := common.GetDefaultSigner()
   257  	if err != nil {
   258  		t.Fatalf("Get default signer error: %v", err)
   259  	}
   260  
   261  	mockCF := &ChannelCmdFactory{
   262  		BroadcastFactory: mockBroadcastClientFactory,
   263  		Signer:           signer,
   264  		DeliverClient:    &mockDeliverClient{},
   265  	}
   266  
   267  	cmd := createCmd(mockCF)
   268  
   269  	AddFlags(cmd)
   270  
   271  	args := []string{"-c", mockchannel, "-f", file, "-o", "localhost:7050"}
   272  	cmd.SetArgs(args)
   273  
   274  	if _, err = createTxFile(file, cb.HeaderType_CONFIG_UPDATE, mockchannel); err != nil {
   275  		t.Fatalf("couldn't create tx file")
   276  	}
   277  
   278  	if err := cmd.Execute(); err != nil {
   279  		t.Errorf("create chain failed")
   280  	}
   281  }
   282  
   283  func TestCreateChainInvalidTx(t *testing.T) {
   284  	InitMSP()
   285  
   286  	mockchannel := "mockchannel"
   287  
   288  	dir, err := ioutil.TempDir("/tmp", "createinvaltest-")
   289  	if err != nil {
   290  		t.Fatalf("couldn't create temp dir")
   291  	}
   292  
   293  	defer os.RemoveAll(dir) // clean up
   294  
   295  	//this is created by create command
   296  	defer os.Remove(mockchannel + ".block")
   297  
   298  	file := filepath.Join(dir, mockchannel)
   299  
   300  	signer, err := common.GetDefaultSigner()
   301  	if err != nil {
   302  		t.Fatalf("Get default signer error: %v", err)
   303  	}
   304  
   305  	mockCF := &ChannelCmdFactory{
   306  		BroadcastFactory: mockBroadcastClientFactory,
   307  		Signer:           signer,
   308  		DeliverClient:    &mockDeliverClient{},
   309  	}
   310  
   311  	cmd := createCmd(mockCF)
   312  
   313  	AddFlags(cmd)
   314  
   315  	args := []string{"-c", mockchannel, "-f", file, "-o", "localhost:7050"}
   316  	cmd.SetArgs(args)
   317  
   318  	//bad type CONFIG
   319  	if _, err = createTxFile(file, cb.HeaderType_CONFIG, mockchannel); err != nil {
   320  		t.Fatalf("couldn't create tx file")
   321  	}
   322  
   323  	defer os.Remove(file)
   324  
   325  	if err := cmd.Execute(); err == nil {
   326  		t.Errorf("expected error")
   327  	} else if _, ok := err.(InvalidCreateTx); !ok {
   328  		t.Errorf("invalid error")
   329  	}
   330  
   331  	//bad channel name - does not match one specified in command
   332  	if _, err = createTxFile(file, cb.HeaderType_CONFIG_UPDATE, "different_channel"); err != nil {
   333  		t.Fatalf("couldn't create tx file")
   334  	}
   335  
   336  	if err := cmd.Execute(); err == nil {
   337  		t.Errorf("expected error")
   338  	} else if _, ok := err.(InvalidCreateTx); !ok {
   339  		t.Errorf("invalid error")
   340  	}
   341  
   342  	//empty channel
   343  	if _, err = createTxFile(file, cb.HeaderType_CONFIG_UPDATE, ""); err != nil {
   344  		t.Fatalf("couldn't create tx file")
   345  	}
   346  
   347  	if err := cmd.Execute(); err == nil {
   348  		t.Errorf("expected error")
   349  	} else if _, ok := err.(InvalidCreateTx); !ok {
   350  		t.Errorf("invalid error")
   351  	}
   352  }