Function TestSyncDesync

engine/sync_test.go:177–247

(t *testing.T)

}

func TestSyncDesync(t *testing.T) {
	ln, client, server, dispatcher, err := newSyncTest()
	if err != nil {
		t.Fatal(err)
	}
	defer ln.Close()

	// Switch the dispatcher to a blocking channel.
	dispatcher.notes = make(chan *SyncNote)

	go client.runOnce()
	defer func() {
		close(client.quit)
		for {
			// Drain the notes to unblock the quit reader.
			if _, err := dispatcher.nextNote(); err != nil {
				break
			}
		}
		<-client.stopped
	}()

	// The server should send a desync at the start of the session.
	n, err := dispatcher.nextNote()
	if err != nil {
		t.Fatalf("Expected desync, got error: %v", err)
	}
	if n.Type != SNTDesync {
		t.Fatalf("Got %v, want %v", n.Type, SNTDesync)
	}

	// Send a single notification to complete the poll.
	server.notify(&SyncNote{Type: SNTHeartbeat})
	time.Sleep(250 * time.Millisecond)
	// syncClient.poll should now be blocked writing that Note to
	// testNoteDispatcher's notes chan.

	// Send enough notifications to fill the session channel buffer.
	server.notify(&SyncNote{Type: SNTHeartbeat})
	server.notify(&SyncNote{Type: SNTConfigUpdate})
	for i := 0; i < (sessionNotesQueueSize * 1.1); i++ {
		server.notify(&SyncNote{Type: SNTHealthcheck})
	}

	// Now we unblock syncClient.poll by reading the initial notification from
	// the local chan. At that point, it should do another Poll and see the
	// desync.
	received := make(map[SyncNoteType]int)
noteLoop:
	for i := 0; i < (sessionNotesQueueSize * 1.1); i++ {
		n, err := dispatcher.nextNote()
		if err != nil {
			t.Fatalf("nextNote() failed: %v; expected note", err)
		}
		received[n.Type]++

		switch n.Type {
		case SNTHeartbeat, SNTHealthcheck: // ok