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 }