github.com/kayoticsully/syncthing@v0.8.9-0.20140724133906-c45a2fdc03f8/events/events_test.go (about)

     1  package events_test
     2  
     3  import (
     4  	"fmt"
     5  	"testing"
     6  	"time"
     7  
     8  	"github.com/calmh/syncthing/events"
     9  )
    10  
    11  var timeout = 100 * time.Millisecond
    12  
    13  func TestNewLogger(t *testing.T) {
    14  	l := events.NewLogger()
    15  	if l == nil {
    16  		t.Fatal("Unexpected nil Logger")
    17  	}
    18  }
    19  
    20  func TestSubscriber(t *testing.T) {
    21  	l := events.NewLogger()
    22  	s := l.Subscribe(0)
    23  	if s == nil {
    24  		t.Fatal("Unexpected nil Subscription")
    25  	}
    26  }
    27  
    28  func TestTimeout(t *testing.T) {
    29  	l := events.NewLogger()
    30  	s := l.Subscribe(0)
    31  	_, err := s.Poll(timeout)
    32  	if err != events.ErrTimeout {
    33  		t.Fatal("Unexpected non-Timeout error:", err)
    34  	}
    35  }
    36  
    37  func TestEventBeforeSubscribe(t *testing.T) {
    38  	l := events.NewLogger()
    39  
    40  	l.Log(events.NodeConnected, "foo")
    41  	s := l.Subscribe(0)
    42  
    43  	_, err := s.Poll(timeout)
    44  	if err != events.ErrTimeout {
    45  		t.Fatal("Unexpected non-Timeout error:", err)
    46  	}
    47  }
    48  
    49  func TestEventAfterSubscribe(t *testing.T) {
    50  	l := events.NewLogger()
    51  
    52  	s := l.Subscribe(events.AllEvents)
    53  	l.Log(events.NodeConnected, "foo")
    54  
    55  	ev, err := s.Poll(timeout)
    56  
    57  	if err != nil {
    58  		t.Fatal("Unexpected error:", err)
    59  	}
    60  	if ev.Type != events.NodeConnected {
    61  		t.Error("Incorrect event type", ev.Type)
    62  	}
    63  	switch v := ev.Data.(type) {
    64  	case string:
    65  		if v != "foo" {
    66  			t.Error("Incorrect Data string", v)
    67  		}
    68  	default:
    69  		t.Errorf("Incorrect Data type %#v", v)
    70  	}
    71  }
    72  
    73  func TestEventAfterSubscribeIgnoreMask(t *testing.T) {
    74  	l := events.NewLogger()
    75  
    76  	s := l.Subscribe(events.NodeDisconnected)
    77  	l.Log(events.NodeConnected, "foo")
    78  
    79  	_, err := s.Poll(timeout)
    80  	if err != events.ErrTimeout {
    81  		t.Fatal("Unexpected non-Timeout error:", err)
    82  	}
    83  }
    84  
    85  func TestBufferOverflow(t *testing.T) {
    86  	l := events.NewLogger()
    87  
    88  	_ = l.Subscribe(events.AllEvents)
    89  
    90  	t0 := time.Now()
    91  	for i := 0; i < events.BufferSize*2; i++ {
    92  		l.Log(events.NodeConnected, "foo")
    93  	}
    94  	if time.Since(t0) > timeout {
    95  		t.Fatalf("Logging took too long")
    96  	}
    97  }
    98  
    99  func TestUnsubscribe(t *testing.T) {
   100  	l := events.NewLogger()
   101  
   102  	s := l.Subscribe(events.AllEvents)
   103  	l.Log(events.NodeConnected, "foo")
   104  
   105  	_, err := s.Poll(timeout)
   106  	if err != nil {
   107  		t.Fatal("Unexpected error:", err)
   108  	}
   109  
   110  	l.Unsubscribe(s)
   111  	l.Log(events.NodeConnected, "foo")
   112  
   113  	_, err = s.Poll(timeout)
   114  	if err != events.ErrClosed {
   115  		t.Fatal("Unexpected non-Closed error:", err)
   116  	}
   117  }
   118  
   119  func TestIDs(t *testing.T) {
   120  	l := events.NewLogger()
   121  
   122  	s := l.Subscribe(events.AllEvents)
   123  	l.Log(events.NodeConnected, "foo")
   124  	l.Log(events.NodeConnected, "bar")
   125  
   126  	ev, err := s.Poll(timeout)
   127  	if err != nil {
   128  		t.Fatal("Unexpected error:", err)
   129  	}
   130  	if ev.Data.(string) != "foo" {
   131  		t.Fatal("Incorrect event:", ev)
   132  	}
   133  	id := ev.ID
   134  
   135  	ev, err = s.Poll(timeout)
   136  	if err != nil {
   137  		t.Fatal("Unexpected error:", err)
   138  	}
   139  	if ev.Data.(string) != "bar" {
   140  		t.Fatal("Incorrect event:", ev)
   141  	}
   142  	if !(ev.ID > id) {
   143  		t.Fatalf("ID not incremented (%d !> %d)", ev.ID, id)
   144  	}
   145  }
   146  
   147  func TestBufferedSub(t *testing.T) {
   148  	l := events.NewLogger()
   149  
   150  	s := l.Subscribe(events.AllEvents)
   151  	bs := events.NewBufferedSubscription(s, 10*events.BufferSize)
   152  
   153  	go func() {
   154  		for i := 0; i < 10*events.BufferSize; i++ {
   155  			l.Log(events.NodeConnected, fmt.Sprintf("event-%d", i))
   156  			if i%30 == 0 {
   157  				// Give the buffer routine time to pick up the events
   158  				time.Sleep(20 * time.Millisecond)
   159  			}
   160  		}
   161  	}()
   162  
   163  	recv := 0
   164  	for recv < 10*events.BufferSize {
   165  		evs := bs.Since(recv, nil)
   166  		for _, ev := range evs {
   167  			if ev.ID != recv+1 {
   168  				t.Fatalf("Incorrect ID; %d != %d", ev.ID, recv+1)
   169  			}
   170  			recv = ev.ID
   171  		}
   172  	}
   173  
   174  }