github.com/cranelv/ethereum_mpc@v0.0.0-20191031014521-23aeb1415092/consensus_pbft/util/events/events_test.go (about)

     1  /*
     2  Copyright IBM Corp. 2016 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 events
    18  
    19  import (
    20  	"testing"
    21  	"time"
    22  	"github.com/ethereum/go-ethereum/log"
    23  )
    24  
    25  type mockEvent struct {
    26  	info string
    27  }
    28  
    29  type mockReceiver struct {
    30  	processEventImpl func(event Event) Event
    31  }
    32  
    33  func (mr *mockReceiver) ProcessEvent(event Event) Event {
    34  	if mr.processEventImpl != nil {
    35  		return mr.processEventImpl(event)
    36  	}
    37  	return nil
    38  }
    39  
    40  func newMockManager(processEvent func(event Event) Event) Manager {
    41  	manager := NewManagerImpl()
    42  	manager.SetReceiver(&mockReceiver{
    43  		processEventImpl: processEvent,
    44  	})
    45  	return manager
    46  }
    47  
    48  // Starts an event timer, waits for the event to be delivered
    49  func TestEventTimerStart(t *testing.T) {
    50  	log.InitLog(5)
    51  	events := make(chan Event)
    52  	mr := newMockManager(func(event Event) Event {
    53  		events <- event
    54  		return nil
    55  	})
    56  	mr.Start()
    57  	defer mr.Halt()
    58  	timer := newTimerImpl(mr)
    59  	defer timer.Halt()
    60  	me := &mockEvent{}
    61  	timer.Reset(300*time.Millisecond, me)
    62  
    63  	select {
    64  	case e := <-events:
    65  		if e != me {
    66  			t.Fatalf("Received wrong output from event timer")
    67  		}
    68  	case <-time.After(time.Second):
    69  		t.Fatalf("Timed out waiting for event to fire")
    70  	}
    71  }
    72  
    73  // Starts an event timer, resets it twice, expects second output
    74  func TestEventTimerHardReset(t *testing.T) {
    75  	log.InitLog(5)
    76  	events := make(chan Event)
    77  	mr := newMockManager(func(event Event) Event {
    78  		events <- event
    79  		return nil
    80  	})
    81  	timer := newTimerImpl(mr)
    82  	defer timer.Halt()
    83  	me1 := &mockEvent{"one"}
    84  	me2 := &mockEvent{"two"}
    85  	timer.Reset(time.Millisecond, me1)
    86  	timer.Reset(time.Millisecond, me2)
    87  
    88  	mr.Start()
    89  	defer mr.Halt()
    90  
    91  	select {
    92  	case e := <-events:
    93  		if e != me2 {
    94  			t.Fatalf("Received wrong output (%v) from event timer", e)
    95  		}
    96  	case <-time.After(time.Second):
    97  		t.Fatalf("Timed out waiting for event to fire")
    98  	}
    99  }
   100  
   101  // Starts an event timer, soft resets it twice, expects first output
   102  func TestEventTimerSoftReset(t *testing.T) {
   103  	log.InitLog(5)
   104  	events := make(chan Event)
   105  	mr := newMockManager(func(event Event) Event {
   106  		events <- event
   107  		return nil
   108  	})
   109  	timer := newTimerImpl(mr)
   110  	defer timer.Halt()
   111  	me1 := &mockEvent{"one"}
   112  	me2 := &mockEvent{"two"}
   113  	timer.SoftReset(time.Millisecond, me1)
   114  	timer.SoftReset(time.Millisecond, me2)
   115  
   116  	mr.Start()
   117  	defer mr.Halt()
   118  
   119  	select {
   120  	case e := <-events:
   121  		if e != me1 {
   122  			t.Fatalf("Received wrong output (%v) from event timer", e)
   123  		}
   124  	case <-time.After(time.Second):
   125  		t.Fatalf("Timed out waiting for event to fire")
   126  	}
   127  }
   128  
   129  // Starts an event timer, then stops it before delivery is possible, should not receive event
   130  func TestEventTimerStop(t *testing.T) {
   131  	events := make(chan Event)
   132  	mr := newMockManager(func(event Event) Event {
   133  		events <- event
   134  		return nil
   135  	})
   136  	timer := newTimerImpl(mr)
   137  	defer timer.Halt()
   138  	me := &mockEvent{}
   139  	timer.Reset(time.Millisecond, me)
   140  	time.Sleep(100 * time.Millisecond) // Allow the timer to fire
   141  	timer.Stop()
   142  
   143  	mr.Start()
   144  	defer mr.Halt()
   145  
   146  	select {
   147  	case <-events:
   148  		t.Fatalf("Received event output from event timer")
   149  	case <-time.After(100 * time.Millisecond):
   150  		// All good
   151  	}
   152  }
   153  
   154  // Replies to an event with a different event, should process both
   155  func TestEventManagerLoop(t *testing.T) {
   156  	success := make(chan struct{})
   157  	m2 := &mockEvent{}
   158  	mr := newMockManager(func(event Event) Event {
   159  		if event != m2 {
   160  			return m2
   161  		}
   162  		success <- struct{}{}
   163  		return nil
   164  	})
   165  	mr.Start()
   166  	defer mr.Halt()
   167  
   168  	mr.Queue() <- &mockEvent{}
   169  
   170  	select {
   171  	case <-success:
   172  		// All good
   173  	case <-time.After(2 * time.Second):
   174  		t.Fatalf("Did not succeed processing second event")
   175  	}
   176  }