BytesMessage shortcut functions

Author: matrober-uk

README.md

@@ -113,7 +113,8 @@ your own error handling or logging.
 * Creating a ConnectionFactory that uses a client connection to a remote queue manager - [connectionfactory_test.go](connectionfactory_test.go)
 * Creating a ConnectionFactory that uses a bindings connection to a local queue manager - [local_bindings_test.go](local_bindings_test.go)
 * Create a connection using anonymous (one-way) TLS encryption or mutual TLS authentication - [tls_connections_test.go](tls_connections_test.go)
-* Send/receive (with no wait) a text string - [sample_sendreceive_test.go](sample_sendreceive_test.go)
+* Send/receive (with no wait) a text string (TextMessage) - [sample_sendreceive_test.go](sample_sendreceive_test.go)
+* Send/receive a slice of bytes (BytesMessage) - [bytesmessage_test.go](bytesmessage_test.go)
 * Receive with wait [receivewithwait_test.go](receivewithwait_test.go)
 * Send a message as Persistent or NonPersistent - [deliverymode_test.go](deliverymode_test.go)
 * Get by CorrelationID - [getbycorrelid_test.go](getbycorrelid_test.go)

bytesmessage_test.go

@@ -80,8 +80,8 @@ func TestBytesMessageNilBody(t *testing.T) {
 	}
 	assert.Nil(t, errCons)
 
-	rcvMsg, errRvc := consumer.ReceiveNoWait()
-	assert.Nil(t, errRvc)
+	rcvMsg, errRcv := consumer.ReceiveNoWait()
+	assert.Nil(t, errRcv)
 	assert.NotNil(t, rcvMsg)
 
 	switch msg2 := rcvMsg.(type) {
@@ -95,7 +95,7 @@ func TestBytesMessageNilBody(t *testing.T) {
 }
 
 /*
- * Test send and receive of a bytes message with no content.
+ * Test send and receive of a bytes message with some basic content.
  */
 func TestBytesMessageWithBody(t *testing.T) {
 
@@ -111,7 +111,7 @@ func TestBytesMessageWithBody(t *testing.T) {
 		defer context.Close()
 	}
 
-	// Create a BytesMessage, and check it has nil content.
+	// Create a BytesMessage
 	msgBody := []byte{'b', 'y', 't', 'e', 's', 'm', 'e', 's', 's', 'a', 'g', 'e'}
 	msg := context.CreateBytesMessage()
 	msg.WriteBytes(msgBody)
@@ -129,8 +129,56 @@ func TestBytesMessageWithBody(t *testing.T) {
 	}
 	assert.Nil(t, errCons)
 
-	rcvMsg, errRvc := consumer.ReceiveNoWait()
-	assert.Nil(t, errRvc)
+	rcvMsg, errRcv := consumer.ReceiveNoWait()
+	assert.Nil(t, errRcv)
+	assert.NotNil(t, rcvMsg)
+
+	switch msg2 := rcvMsg.(type) {
+	case jms20subset.BytesMessage:
+		assert.Equal(t, len(msgBody), msg2.GetBodyLength())
+		assert.Equal(t, msgBody, *msg2.ReadBytes())
+	default:
+		assert.Fail(t, "Got something other than a text message")
+	}
+
+}
+
+/*
+ * Test send and receive of a bytes message with init'd at create time.
+ */
+func TestBytesMessageInitWithBytes(t *testing.T) {
+
+	// Loads CF parameters from connection_info.json and apiKey.json in the Downloads directory
+	cf, cfErr := mqjms.CreateConnectionFactoryFromDefaultJSONFiles()
+	assert.Nil(t, cfErr)
+
+	// Creates a connection to the queue manager, using defer to close it automatically
+	// at the end of the function (if it was created successfully)
+	context, ctxErr := cf.CreateContext()
+	assert.Nil(t, ctxErr)
+	if context != nil {
+		defer context.Close()
+	}
+
+	// Create a BytesMessage, and check it has nil content.
+	msgBody := []byte{'b', 'y', 't', 'e', 's', 'm', 'e', 's', 's', 'a', 'g', 'e', 'A', 'B', 'C'}
+	msg := context.CreateBytesMessageWithBytes(msgBody)
+	assert.Equal(t, 15, msg.GetBodyLength())
+	assert.Equal(t, msgBody, *msg.ReadBytes())
+
+	// Now send the message and get it back again, to check that it roundtripped.
+	queue := context.CreateQueue("DEV.QUEUE.1")
+	errSend := context.CreateProducer().SetTimeToLive(5000).Send(queue, msg)
+	assert.Nil(t, errSend)
+
+	consumer, errCons := context.CreateConsumer(queue)
+	if consumer != nil {
+		defer consumer.Close()
+	}
+	assert.Nil(t, errCons)
+
+	rcvMsg, errRcv := consumer.Receive(2000) // also try receive with wait
+	assert.Nil(t, errRcv)
 	assert.NotNil(t, rcvMsg)
 
 	switch msg2 := rcvMsg.(type) {
@@ -142,3 +190,196 @@ func TestBytesMessageWithBody(t *testing.T) {
 	}
 
 }
+
+/*
+ * Test Producer SendBytes shortcut
+ */
+func TestBytesMessageProducerSendBytes(t *testing.T) {
+
+	// Loads CF parameters from connection_info.json and apiKey.json in the Downloads directory
+	cf, cfErr := mqjms.CreateConnectionFactoryFromDefaultJSONFiles()
+	assert.Nil(t, cfErr)
+
+	// Creates a connection to the queue manager, using defer to close it automatically
+	// at the end of the function (if it was created successfully)
+	context, ctxErr := cf.CreateContext()
+	assert.Nil(t, ctxErr)
+	if context != nil {
+		defer context.Close()
+	}
+
+	// Create a BytesMessage, and check it has nil content.
+	msgBody := []byte{'b', 'y', 't', 'e', 's', 'p', 'r', 'o', 'd', 'u', 'c', 'e', 'r'}
+
+	// Now send the message and get it back again, to check that it roundtripped.
+	queue := context.CreateQueue("DEV.QUEUE.1")
+	errSend := context.CreateProducer().SetTimeToLive(5000).SendBytes(queue, msgBody)
+	assert.Nil(t, errSend)
+
+	consumer, errCons := context.CreateConsumer(queue)
+	if consumer != nil {
+		defer consumer.Close()
+	}
+	assert.Nil(t, errCons)
+
+	rcvMsg, errRcv := consumer.ReceiveNoWait()
+	assert.Nil(t, errRcv)
+	assert.NotNil(t, rcvMsg)
+
+	switch msg2 := rcvMsg.(type) {
+	case jms20subset.BytesMessage:
+		assert.Equal(t, 13, msg2.GetBodyLength())
+		assert.Equal(t, msgBody, *msg2.ReadBytes())
+	default:
+		assert.Fail(t, "Got something other than a text message")
+	}
+
+}
+
+/*
+ * Test Consumer ReceiveBytesBodyNoWait shortcut
+ */
+func TestBytesMessageConsumerReceiveBytesBodyNoWait(t *testing.T) {
+
+	// Loads CF parameters from connection_info.json and apiKey.json in the Downloads directory
+	cf, cfErr := mqjms.CreateConnectionFactoryFromDefaultJSONFiles()
+	assert.Nil(t, cfErr)
+
+	// Creates a connection to the queue manager, using defer to close it automatically
+	// at the end of the function (if it was created successfully)
+	context, ctxErr := cf.CreateContext()
+	assert.Nil(t, ctxErr)
+	if context != nil {
+		defer context.Close()
+	}
+
+	queue := context.CreateQueue("DEV.QUEUE.1")
+	consumer, errCons := context.CreateConsumer(queue)
+	if consumer != nil {
+		defer consumer.Close()
+	}
+	assert.Nil(t, errCons)
+
+	// Check the behaviour if there is no message to receive.
+	var expectedNil *[]byte // uninitialized
+	rcvBytes, errRcv := consumer.ReceiveBytesBodyNoWait()
+	assert.Nil(t, errRcv)
+	assert.Equal(t, expectedNil, rcvBytes)
+
+	// Create a BytesMessage, and check it has nil content.
+	msgBody := []byte{'b', 'y', 't', 'e', 's', 'n', 'o', 'w', 'a', 'i', 't'}
+
+	// Now send the message and get it back again, to check that it roundtripped.
+	errSend := context.CreateProducer().SetTimeToLive(5000).SendBytes(queue, msgBody)
+	assert.Nil(t, errSend)
+
+	rcvBytes, errRcv = consumer.ReceiveBytesBodyNoWait()
+	assert.Nil(t, errRcv)
+	assert.Equal(t, msgBody, *rcvBytes)
+
+}
+
+/*
+ * Test Consumer ReceiveBytesBody shortcut
+ */
+func TestBytesMessageConsumerReceiveBytesBody(t *testing.T) {
+
+	// Loads CF parameters from connection_info.json and apiKey.json in the Downloads directory
+	cf, cfErr := mqjms.CreateConnectionFactoryFromDefaultJSONFiles()
+	assert.Nil(t, cfErr)
+
+	// Creates a connection to the queue manager, using defer to close it automatically
+	// at the end of the function (if it was created successfully)
+	context, ctxErr := cf.CreateContext()
+	assert.Nil(t, ctxErr)
+	if context != nil {
+		defer context.Close()
+	}
+
+	queue := context.CreateQueue("DEV.QUEUE.1")
+	consumer, errCons := context.CreateConsumer(queue)
+	if consumer != nil {
+		defer consumer.Close()
+	}
+	assert.Nil(t, errCons)
+
+	// Check the behaviour if there is no message to receive.
+	var expectedNil *[]byte // uninitialized
+	rcvBytes, errRcv := consumer.ReceiveBytesBody(250)
+	assert.Nil(t, errRcv)
+	assert.Equal(t, expectedNil, rcvBytes)
+
+	// Create a BytesMessage, and check it has nil content.
+	msgBody := []byte{'b', 'y', 't', 'e', 's', 'w', 'a', 'i', 't'}
+
+	// Now send the message and get it back again, to check that it roundtripped.
+	errSend := context.CreateProducer().SetTimeToLive(5000).SendBytes(queue, msgBody)
+	assert.Nil(t, errSend)
+
+	rcvBytes, errRcv = consumer.ReceiveBytesBody(500)
+	assert.Nil(t, errRcv)
+	assert.Equal(t, msgBody, *rcvBytes)
+
+}
+
+/*
+ * Test Consumer ReceiveBytesBody/ReceiveStringBody shortcuts when unexpected
+ * types of messages are received.
+ */
+func TestBytesMessageConsumerMixedMessageErrors(t *testing.T) {
+
+	// Loads CF parameters from connection_info.json and apiKey.json in the Downloads directory
+	cf, cfErr := mqjms.CreateConnectionFactoryFromDefaultJSONFiles()
+	assert.Nil(t, cfErr)
+
+	// Creates a connection to the queue manager, using defer to close it automatically
+	// at the end of the function (if it was created successfully)
+	context, ctxErr := cf.CreateContext()
+	assert.Nil(t, ctxErr)
+	if context != nil {
+		defer context.Close()
+	}
+
+	queue := context.CreateQueue("DEV.QUEUE.1")
+	consumer, errCons := context.CreateConsumer(queue)
+	if consumer != nil {
+		defer consumer.Close()
+	}
+	assert.Nil(t, errCons)
+
+	// Send a BytesMessage, try to receive as text with no wait.
+	msgBodyBytes := []byte{'b', 'y', 't', 'e', 's', '1', '2', '3', '4'}
+	errSend := context.CreateProducer().SetTimeToLive(5000).SendBytes(queue, msgBodyBytes)
+	assert.Nil(t, errSend)
+	rcvStr, errRcv := consumer.ReceiveStringBodyNoWait()
+	assert.Nil(t, rcvStr)
+	assert.Equal(t, "MQJMS6068", errRcv.GetErrorCode())
+	assert.Equal(t, "MQJMS_DIR_MIN_NOTTEXT", errRcv.GetReason())
+
+	// Send a BytesMessage, try to receive as text with wait.
+	errSend = context.CreateProducer().SetTimeToLive(5000).SendBytes(queue, msgBodyBytes)
+	assert.Nil(t, errSend)
+	rcvStr, errRcv = consumer.ReceiveStringBody(200)
+	assert.Nil(t, rcvStr)
+	assert.Equal(t, "MQJMS6068", errRcv.GetErrorCode())
+	assert.Equal(t, "MQJMS_DIR_MIN_NOTTEXT", errRcv.GetReason())
+
+	// Send a TextMessage, try to receive as bytes with no wait.
+	msgBodyStr := "TextMessage is not Bytes"
+	errSend = context.CreateProducer().SetTimeToLive(5000).SendString(queue, msgBodyStr)
+	assert.Nil(t, errSend)
+	rcvBytes, errRcv := consumer.ReceiveBytesBodyNoWait()
+	var expectedNil *[]byte // uninitialized
+	assert.Equal(t, expectedNil, rcvBytes)
+	assert.Equal(t, "MQJMS6068", errRcv.GetErrorCode())
+	assert.Equal(t, "MQJMS_DIR_MIN_NOTBYTES", errRcv.GetReason())
+
+	// Send a TextMessage, try to receive as bytes with wait.
+	errSend = context.CreateProducer().SetTimeToLive(5000).SendString(queue, msgBodyStr)
+	assert.Nil(t, errSend)
+	rcvBytes, errRcv = consumer.ReceiveBytesBody(200)
+	assert.Equal(t, expectedNil, rcvBytes)
+	assert.Equal(t, "MQJMS6068", errRcv.GetErrorCode())
+	assert.Equal(t, "MQJMS_DIR_MIN_NOTBYTES", errRcv.GetReason())
+
+}

jms20subset/JMSConsumer.go

@@ -22,23 +22,35 @@ type JMSConsumer interface {
 	// there is no message immediately available
 	ReceiveNoWait() (Message, JMSException)
 
-	// ReceiveStringBodyNoWait receives the next message for this JMSConsumer
-	// and returns its body as a string. If a message is not immediately
-	// available a nil is returned.
-	ReceiveStringBodyNoWait() (*string, JMSException)
-
 	// Receive(waitMillis) returns a message if one is available, or otherwise
 	// waits for up to the specified number of milliseconds for one to become
 	// available. A value of zero or less indicates to wait indefinitely.
 	Receive(waitMillis int32) (Message, JMSException)
 
+	// ReceiveStringBodyNoWait receives the next message for this JMSConsumer
+	// and returns its body as a string. If a message is not immediately
+	// available a nil is returned.
+	ReceiveStringBodyNoWait() (*string, JMSException)
+
 	// ReceiveStringBody returns the body of a message as a string if one is
 	// available. If a message is not immediately available the method will
 	// block for up to the specified number of milliseconds to wait for one
 	// to become available. A value of zero or less indicates to wait
 	// indefinitely.
 	ReceiveStringBody(waitMillis int32) (*string, JMSException)
 
+	// ReceiveBytesBodyNoWait receives the next message for this JMSConsumer
+	// and returns its body as a slice of bytes. If a message is not immediately
+	// available an uninitialized *[]byte is returned.
+	ReceiveBytesBodyNoWait() (*[]byte, JMSException)
+
+	// ReceiveBytesBody returns the body of a message as a slice of bytes if one is
+	// available. If a message is not immediately available the method will
+	// block for up to the specified number of milliseconds to wait for one
+	// to become available. A value of zero or less indicates to wait
+	// indefinitely.
+	ReceiveBytesBody(waitMillis int32) (*[]byte, JMSException)
+
 	// Closes the JMSConsumer in order to free up any resources that were
 	// allocated by the provider on behalf of this consumer.
 	Close()

jms20subset/JMSContext.go

@@ -64,6 +64,10 @@ type JMSContext interface {
 	// of bytes from one application to another.
 	CreateBytesMessage() BytesMessage
 
+	// CreateBytesMessageWithBytes creates a message object that is used to send a slice
+	// of bytes from one application to another.
+	CreateBytesMessageWithBytes(bytes []byte) BytesMessage
+
 	// Commit confirms all messages sent/received during this transaction.
 	Commit()
 

jms20subset/JMSProducer.go

@@ -27,6 +27,13 @@ type JMSProducer interface {
 	// name and different parameters we must use a different function name.
 	SendString(dest Destination, body string) JMSException
 
+	// Send a BytesMessage with the specified body to the specified Destination
+	// using any message options that are defined on this JMSProducer.
+	//
+	// Note that since Golang does not allow multiple functions with the same
+	// name and different parameters we must use a different function name.
+	SendBytes(dest Destination, body []byte) JMSException
+
 	// SetDeliveryMode sets the delivery mode of messages sent using this
 	// JMSProducer - for example whether a message is persistent or non-persistent.
 	//