For those of you not familiar with it, Nuntium is an open-source tool we developed together with InSTEDD for easily building applications that rely on SMS for communication. Even though several other kinds of channels are supported, such as email or twitter, text messaging has been one of its most important features.

A common scenario that we face is how to easily test the flow of text messages in a development or manual testing environment. While using a local gateway is a possibility, most likely you won't want to spend actual text messages while developing; it is costly in the long run, and cumbersome to switch between the development station and a test cellphone.

One possibility to get around this is to use Nuntium's very interface for generating AT messages, and check the AO queue for responses.

Create Application Terminated Message in Nuntium

This interface can be a bit unsuited, however, for sending messages and receiving their responses instantly on the same page. It also requires access to the Nuntium account, so if you are looking forward to using it for testing, it implies granting access to everyone who is to test it to the account. An elegant solution, provided by my colleague Adrian Romero, is to use an XMPP channel for mocking the SMS flow.

Setting up the XMPP channel

Step one is to create a new account that you will use for testing the application and an application within the account. Now you are ready to set up the XMPP channel. For this, you will need an XMPP account to act as the channel; creating a test account in gmail is always a good candidate, in which case configuration is pretty straightforward:

Configuration for xmpp channel with google talk

Make sure you change the protocol of the channel from XMPP to SMS. This will make Nuntium use this XMPP channel for routing SMS messages.

Configuring AT Rules

The trickiest part is setting up the message rules for mocking the SMS channel. The main challenge is that you want to simulate, from a single xmpp account, multiple SMS phones. In other words, you want to use your account for pretending you are sending a text message from 555-1000, but also from 555-2000, 555-3000, and so on.

A nice solution to this is to actually specify the phone number as part of the message, and have Nuntium interpret it accordingly. So, if we send the message:

5551000 Hello world

We want Nuntium to convert it to a text message from sms://5551000 with the content "Hello world". To do this, we need to set up the following AT rules:

Condition: Body regex (d+)(s+)(.+)
Action:    From sms://${body.1}
           Body ${body.3}

Let's take a look at them more closely:

Having these rules in place, we can use a single channel, xmpp in this case, to fake that we are multiple different senders.

Configuring AO Rules

Next step is to setup the AO rules now. Nuntium, instructed by your application, will attempt to send messages to phone numbers, and your xmpp channel will have a difficult time trying to send an IM to sms://5552000. So we want to divert these messages to our test jabber account, but still letting us know who was the original recipient for testing purposes.

So, if the application is trying to send a Hello user! message to sms://5552000, we want a message delivered to our jabber account with the content:

To: 5552000 Message: Hello user!

To do this, we will set up the following set of rules that affect the To and the Body fields of the application originated message.

Condition: To regex sms://(.+)
           Body regex (.*)
Actions:   To
           Body To: ${to.1} Message: ${body.1}

These rules are simpler than the previous ones. The conditions simply extract the phone number and body of the message; whereas the actions replace the target of the message with a hardcoded one, and condense the original target and the content in the body of the new message.

To sum up...

Nuntium offers greats flexibility by the usage of AT and AO rules, by granting the possibility to alter the flow of messages or their content. These tools, originally designed for connecting systems in real-world situations, can be also used for simplifying the development of a Nuntium-based application.