コード例 #1
0
ファイル: queue_test.go プロジェクト: FireEater64/gamq
func TestQueue_EvenNumberOfPushesAndPops_GivesZeroFinalLength(t *testing.T) {
	underTest := NewQueue("Test")
	numberOfRounds := 200

	for i := 0; i < numberOfRounds; i++ {
		dummyMessagePayLoad := []byte{byte(i)}
		dummyMessage := message.NewHeaderlessMessage(&dummyMessagePayLoad)
		underTest.InputChannel <- dummyMessage
	}

	gomega.Eventually(func() int {
		return underTest.length
	}).Should(gomega.Equal(numberOfRounds))

	for i := 0; i < numberOfRounds; i++ {
		message := <-underTest.OutputChannel
		if int((*message.Body)[0]) != i {
			t.Logf("Expected %d, got %d", i, int((*message.Body)[0]))
			t.FailNow()
		}
	}

	gomega.Eventually(func() int {
		return underTest.length
	}).Should(gomega.Equal(0))
}
コード例 #2
0
ファイル: messagequeue_test.go プロジェクト: FireEater64/gamq
// A unsubscribing client should not be considered for message delivery
func TestQueue_sendMessageAfterUnsubscribe_messageReceivedSuccessfully(t *testing.T) {
	// Need gomega for async testing
	gomega.RegisterTestingT(t)

	testMessagePayload := []byte("Testing!")
	expectedMessagePayload := []byte("Testing!\r\n.\r\n")
	testMessage := message.NewHeaderlessMessage(&testMessagePayload)

	dummyMetricsPipe := make(chan<- *Metric, 10)
	dummyClosingPipe := make(chan<- *string)

	underTest := newMessageQueue(TEST_QUEUE_NAME, dummyMetricsPipe, dummyClosingPipe)

	writerBuffer1 := new(bytes.Buffer)
	dummyWriter1 := bufio.NewWriter(writerBuffer1)
	closedChannel1 := make(chan bool)
	dummyClient1 := Client{Name: "Test1", Writer: dummyWriter1, Closed: &closedChannel1}

	writerBuffer2 := new(bytes.Buffer)
	dummyWriter2 := bufio.NewWriter(writerBuffer2)
	closedChannel2 := make(chan bool)
	dummyClient2 := Client{Name: "Test2", Writer: dummyWriter2, Closed: &closedChannel2}

	// Add the subscription
	underTest.AddSubscriber(&dummyClient1)
	underTest.AddSubscriber(&dummyClient2)

	// Queue the message
	underTest.Publish(testMessage)

	// Bit of a hack - only one of the subscribers will get the message,
	// and we don't know which one
	gomega.Eventually(func() []byte {
		if writerBuffer1.String() == "" {
			return writerBuffer2.Bytes()
		} else {
			return writerBuffer1.Bytes()
		}
	}).Should(gomega.Equal(expectedMessagePayload))

	// We'll be reusing these buffers
	writerBuffer1.Reset()
	writerBuffer2.Reset()

	// Close one client
	*dummyClient1.Closed <- true

	// Should remove the client from the map
	gomega.Eventually(func() bool {
		return underTest.subscribers[dummyClient1.Name] == nil
	}).Should(gomega.BeTrue())

	// Now send a message - the remaining client should receive it without issue
	underTest.Publish(testMessage)

	gomega.Eventually(func() []byte {
		return writerBuffer2.Bytes()
	}).Should(gomega.Equal(expectedMessagePayload))

}
コード例 #3
0
ファイル: messagequeue_test.go プロジェクト: FireEater64/gamq
// Check that messages sent to a queue are eventually sent to consumers
func TestQueue_sendMessage_messageReceivedSuccessfully(t *testing.T) {
	// Need gomega for async testing
	gomega.RegisterTestingT(t)

	testMessagePayload := []byte("Testing!")
	expectedMessagePayload := []byte("Testing!\r\n.\r\n")
	testMessage := message.NewHeaderlessMessage(&testMessagePayload)

	dummyMetricsPipe := make(chan<- *Metric)
	dummyClosingPipe := make(chan<- *string)
	underTest := newMessageQueue(TEST_QUEUE_NAME, dummyMetricsPipe, dummyClosingPipe)

	writerBuffer := new(bytes.Buffer)
	dummyWriter := bufio.NewWriter(writerBuffer)
	closedChannel := make(chan bool)
	dummyClient := Client{Name: "Test", Writer: dummyWriter, Closed: &closedChannel}

	// Add the subscription
	underTest.AddSubscriber(&dummyClient)

	// Queue the message
	underTest.Publish(testMessage)

	gomega.Eventually(func() []byte {
		return writerBuffer.Bytes()
	}).Should(gomega.Equal(expectedMessagePayload))
}
コード例 #4
0
ファイル: messagequeue_test.go プロジェクト: FireEater64/gamq
func TestQueue_xPendingMetrics_producesCorrectMetric(t *testing.T) {
	// Need gomega for async testing
	gomega.RegisterTestingT(t)

	numberOfMessagesToSend := 10

	testMessagePayload := []byte("Testing!")
	testMessage := message.NewHeaderlessMessage(&testMessagePayload)

	dummyMetricsPipe := make(chan *Metric)
	dummyClosingPipe := make(chan *string)
	underTest := newMessageQueue(TEST_QUEUE_NAME, dummyMetricsPipe, dummyClosingPipe)

	for i := 0; i < numberOfMessagesToSend; i++ {
		underTest.Publish(testMessage)
	}

	// Eventually, we should see `numberOfMessagesToSend` pending messages
	gomega.Eventually(func() int {
		metric := <-dummyMetricsPipe
		if strings.Contains(metric.Name, "pending") {
			return int(metric.Value)
		} else {
			return -1
		}
	}, "5s").Should(gomega.Equal(numberOfMessagesToSend))
}
コード例 #5
0
ファイル: connectionmanager.go プロジェクト: FireEater64/gamq
func (manager *ConnectionManager) parseClientCommand(commandTokens []string, messageBody *[]byte, client *Client) {
	if len(commandTokens) == 0 {
		return
	}

	commandTokens[0] = strings.ToUpper(commandTokens[0])

	switch commandTokens[0] {
	case "HELP":
		manager.sendStringToClient(helpString, client)
	case "PUB":
		// TODO: Handle headers
		message := message.NewHeaderlessMessage(messageBody)
		manager.qm.Publish(commandTokens[1], message)
		if client.AckRequested {
			manager.sendStringToClient("PUBACK\n", client)
		}
	case "SUB":
		manager.qm.Subscribe(commandTokens[1], client)
	case "DISCONNECT":
		*client.Closed <- true
	case "PINGREQ":
		manager.sendStringToClient("PINGRESP", client)
	case "SETACK":
		if strings.ToUpper(commandTokens[1]) == "ON" {
			client.AckRequested = true
		} else {
			client.AckRequested = false
		}
	case "CLOSE":
		manager.qm.CloseQueue(commandTokens[1])
	default:
		manager.sendStringToClient(unrecognisedCommandText, client)
	}
}
コード例 #6
0
ファイル: queue_test.go プロジェクト: FireEater64/gamq
func TestQueue_CanSendAndReceiveBasicMessages(t *testing.T) {
	underTest := NewQueue("TestQueue")

	testMessagePayload := []byte("TestMessage")
	underTest.InputChannel <- (message.NewHeaderlessMessage(&testMessagePayload))

	receivedMessage := <-underTest.OutputChannel

	if !bytes.Equal(*receivedMessage.Body, testMessagePayload) {
		t.Fail()
	}
}
コード例 #7
0
ファイル: queue_test.go プロジェクト: FireEater64/gamq
func BenchmarkQueueSendRecv(b *testing.B) {
	dummyMessagePayLoad := []byte("Test")
	dummyMessage := message.NewHeaderlessMessage(&dummyMessagePayLoad)

	underTest := NewQueue("Test")

	for i := 0; i < b.N; i++ {
		underTest.InputChannel <- dummyMessage
	}

	for i := 0; i < b.N; i++ {
		_ = <-underTest.OutputChannel
	}
}
コード例 #8
0
func TestMessageShipper_SuccessfullyForwardsMessages(t *testing.T) {
	gomega.RegisterTestingT(t)

	inputChannel := make(chan *message.Message, 0)

	writerBuffer := new(bytes.Buffer)
	dummyWriter := bufio.NewWriter(writerBuffer)
	closedChannel := make(chan bool)
	dummyClient := Client{Name: "Test", Writer: dummyWriter, Closed: &closedChannel}
	dummyMetricsChannel := make(chan *Metric)

	underTest := newMessageShipper(inputChannel, &dummyClient, dummyMetricsChannel, "test")

	testMessagePayload := []byte("This is a test!")
	expectedMessagePayload := []byte("This is a test!\r\n.\r\n")
	testMessage := message.NewHeaderlessMessage(&testMessagePayload)
	underTest.messageChannel <- testMessage

	gomega.Eventually(func() []byte {
		return writerBuffer.Bytes()
	}).Should(gomega.Equal(expectedMessagePayload))
}
コード例 #9
0
ファイル: queue_test.go プロジェクト: FireEater64/gamq
func TestQueue_ReceiveBeforeSend_ReturnsExpectedResult(t *testing.T) {
	gomega.RegisterTestingT(t)

	underTest := NewQueue("TestQueue")

	var receivedMessage *message.Message
	go func() {
		receivedMessage = <-underTest.OutputChannel
	}()

	time.Sleep(time.Millisecond * 10)

	testMessagePayload := []byte("TestMessage")
	underTest.InputChannel <- (message.NewHeaderlessMessage(&testMessagePayload))

	gomega.Eventually(func() *message.Message {
		return receivedMessage
	}).Should(gomega.Not(gomega.BeNil()))

	if !bytes.Equal(*receivedMessage.Body, testMessagePayload) {
		t.Fail()
	}
}