github.com/myafeier/fabric@v1.0.1-0.20170722181825-3a4b1f2bce86/events/producer/events_test.go (about)

     1  /*
     2  Copyright IBM Corp. 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 producer
    18  
    19  import (
    20  	"context"
    21  	"io"
    22  	"testing"
    23  	"time"
    24  
    25  	"github.com/hyperledger/fabric/core/comm"
    26  	"github.com/hyperledger/fabric/protos/peer"
    27  	ehpb "github.com/hyperledger/fabric/protos/peer"
    28  	"github.com/hyperledger/fabric/protos/utils"
    29  	"github.com/spf13/viper"
    30  	"github.com/stretchr/testify/assert"
    31  	"google.golang.org/grpc"
    32  )
    33  
    34  var peerAddress = "0.0.0.0:60303"
    35  
    36  type client struct {
    37  	conn   *grpc.ClientConn
    38  	stream peer.Events_ChatClient
    39  }
    40  
    41  func newClient() *client {
    42  	conn, err := comm.NewClientConnectionWithAddress(peerAddress, true, false, nil)
    43  	if err != nil {
    44  		panic(err)
    45  	}
    46  
    47  	stream, err := peer.NewEventsClient(conn).Chat(context.Background())
    48  	if err != nil {
    49  		panic(err)
    50  	}
    51  
    52  	cl := &client{
    53  		conn:   conn,
    54  		stream: stream,
    55  	}
    56  	go cl.processEvents()
    57  	return cl
    58  }
    59  
    60  func (c *client) register(ies []*peer.Interest) error {
    61  	emsg := &peer.Event{Event: &peer.Event_Register{Register: &peer.Register{Events: ies}}, Creator: signerSerialized}
    62  	se, err := utils.GetSignedEvent(emsg, signer)
    63  	if err != nil {
    64  		return err
    65  	}
    66  	return c.stream.Send(se)
    67  }
    68  
    69  func (c *client) unregister(ies []*peer.Interest) error {
    70  	emsg := &peer.Event{Event: &peer.Event_Unregister{Unregister: &peer.Unregister{Events: ies}}, Creator: signerSerialized}
    71  	se, err := utils.GetSignedEvent(emsg, signer)
    72  	if err != nil {
    73  		return err
    74  	}
    75  	return c.stream.Send(se)
    76  }
    77  
    78  func (c *client) processEvents() error {
    79  	defer c.stream.CloseSend()
    80  	for {
    81  		_, err := c.stream.Recv()
    82  		if err == io.EOF {
    83  			return nil
    84  		}
    85  		if err != nil {
    86  			return err
    87  		}
    88  	}
    89  }
    90  
    91  func TestEvents(t *testing.T) {
    92  	test := func(duration time.Duration) {
    93  		t.Log(duration)
    94  		f := func() {
    95  			Send(nil)
    96  		}
    97  		assert.Panics(t, f)
    98  		Send(&peer.Event{})
    99  		gEventProcessorBck := gEventProcessor
   100  		gEventProcessor = nil
   101  		e, err := createEvent()
   102  		assert.NoError(t, err)
   103  		Send(e)
   104  		gEventProcessor = gEventProcessorBck
   105  		Send(e)
   106  	}
   107  	prevTimeout := gEventProcessor.timeout
   108  	for _, timeout := range []time.Duration{0, -1, 1} {
   109  		gEventProcessor.timeout = timeout
   110  		test(timeout)
   111  	}
   112  	gEventProcessor.timeout = prevTimeout
   113  }
   114  
   115  func TestDeRegister(t *testing.T) {
   116  	f := func() {
   117  		deRegisterHandler(nil, nil)
   118  	}
   119  	assert.Panics(t, f)
   120  	assert.Error(t, deRegisterHandler(&peer.Interest{EventType: 100}, nil))
   121  	assert.Error(t, deRegisterHandler(&peer.Interest{EventType: peer.EventType_BLOCK}, nil))
   122  }
   123  
   124  func TestRegister(t *testing.T) {
   125  	f := func() {
   126  		registerHandler(nil, nil)
   127  	}
   128  	assert.Panics(t, f)
   129  
   130  	// attempt to register handlers (invalid type or nil handlers)
   131  	assert.Error(t, registerHandler(&peer.Interest{EventType: 100}, nil))
   132  	assert.Error(t, registerHandler(&peer.Interest{EventType: peer.EventType_BLOCK}, nil))
   133  	assert.Error(t, registerHandler(&peer.Interest{EventType: peer.EventType_CHAINCODE}, nil))
   134  
   135  	// attempt to register valid handler
   136  	recvChan := make(chan *streamEvent)
   137  	stream := &mockstream{c: recvChan}
   138  	handler, err := newEventHandler(stream)
   139  	assert.Nil(t, err, "error should have been nil")
   140  	assert.NoError(t, registerHandler(&peer.Interest{EventType: peer.EventType_BLOCK}, handler))
   141  }
   142  
   143  func TestProcessEvents(t *testing.T) {
   144  	cl := newClient()
   145  	interests := []*peer.Interest{
   146  		{EventType: peer.EventType_BLOCK},
   147  		{EventType: peer.EventType_CHAINCODE, RegInfo: &peer.Interest_ChaincodeRegInfo{ChaincodeRegInfo: &peer.ChaincodeReg{ChaincodeId: "0xffffffff", EventName: "event1"}}},
   148  		{EventType: peer.EventType_CHAINCODE, RegInfo: &peer.Interest_ChaincodeRegInfo{ChaincodeRegInfo: &peer.ChaincodeReg{ChaincodeId: "0xffffffff", EventName: "event2"}}},
   149  	}
   150  	cl.register(interests)
   151  	e, err := createEvent()
   152  	assert.NoError(t, err)
   153  	go Send(e)
   154  	time.Sleep(time.Second * 2)
   155  	cl.unregister(interests)
   156  	time.Sleep(time.Second * 2)
   157  }
   158  
   159  func TestInitializeEvents_twice(t *testing.T) {
   160  	initializeEventsTwice := func() {
   161  		initializeEvents(
   162  			uint(viper.GetInt("peer.events.buffersize")),
   163  			viper.GetDuration("peer.events.timeout"))
   164  	}
   165  	assert.Panics(t, initializeEventsTwice)
   166  }
   167  
   168  func TestAddEventType_alreadyDefined(t *testing.T) {
   169  	assert.Error(t, AddEventType(ehpb.EventType_CHAINCODE), "chaincode type already defined")
   170  }