Stephen A. Fuqua (SAF) is a Bahá'í, software developer, and conservation and interfaith advocate in the DFW area of Texas.

Node.js, Web API, and RabbitMQ. Part 1

July 29, 2014

* "Simplicity – the art of maximizing the amount of work not done – is essential," to quote the Principles behind the Agile Manifesto. This is just demo code!

In test-driven fashion, I decided to start with an automated test harness that would run each API, send a message to the bus, and consume the message in order to verify that it was received correctly. The test harness is using a Visual Studio Test Project. Admittedly, I did not know enough about the tools to write this in a full TDD fashion, but let's just pretend that the tests were fully written before the real code.

I'm going to throw out a lot of sample code here. Hopefully it is well-written enough that it doesn't need extensive commentary. First, the node.js test:

[TestClass]
public class NodejsTest
{
    private IServiceBus _serviceBus;
    private const string RABBIT_URL = "rabbitmq://localhost:5672/apitest_webapi";
    private const string NODEJS_URL = "http://localhost:10025/";
    private const string MESSAGE_REQUEST = "Message/{0}";
    private const string NODEJS_PACKAGE = @"""somepath\RabbitMqAPI\app.js""";
    private const string NODE_EXECUTABLE = @"""C:\Program Files\nodejs\node.exe""";
    private Process _webServer;
 
    [TestInitialize]
    public void Initialize()
    {
        _serviceBus = Helper.SetupBusMonitoring(RABBIT_URL);
    }
 
 
    [TestMethod]
    public void SendAMessageToRabbitMQUsingNodeJs()
    {
        var messageContent = "one small step for a man...";
 
        GivenNodeJsApiIsRunning();
        Helper.WhenTheApiIsCalled(messageContent, MESSAGE_REQUEST, NODEJS_URL);
 
        Helper.ThenTheMessageShouldHaveBeenSentToTheBus(messageContent);
    }
 
    [TestCleanup]
    public void TestCleanup()
    {
        _serviceBus.Dispose();
 
        if (!_webServer.HasExited)
        {
            _webServer.Kill();
            _webServer.Dispose();
        }
    }
 
    private void GivenNodeJsApiIsRunning()
    {
        var processStartInfo = new ProcessStartInfo
        {
            Arguments = NODEJS_PACKAGE,
            FileName = NODE_EXECUTABLE,
            ErrorDialog = true,
            UseShellExecute = true
        };
 
        try
        {
            _webServer = Process.Start(processStartInfo);
        }
        catch (Win32Exception exception)
        {
            Assert.Fail(exception.ToString());
        }
    } 
}

And now the ASP.Net test:

[TestClass]
public class WebAPITest
{
    private const string RABBIT_URL = "rabbitmq://localhost:5672/apitest_webapi";
    private const string WEBAPI_BASE_ADDRESS = "http://localhost:10026/";
    private const string MESSAGE_ROUTE = "/Message/{0}";
    private WebApiRunner _webServer;
    private IServiceBus _serviceBus;
 
    [TestInitialize]
    public void Initialize()
    {
        _serviceBus = Helper.SetupBusMonitoring(RABBIT_URL);
    }
 
    [TestMethod]
    public void SendAMessageToRabbitMQUsingWebAPI()
    {
        var messageContent = "Hola mundial";
 
        GivenWebApiIsRunning();
 
        Helper.WhenTheApiIsCalled(messageContent, MESSAGE_ROUTE, WEBAPI_BASE_ADDRESS);
 
        Helper.ThenTheMessageShouldHaveBeenSentToTheBus(messageContent);
    }
 
    [TestCleanup]
    public void Cleanup()
    {
        _webServer.Stop();
        _serviceBus.Dispose();
    }
 
    private void GivenWebApiIsRunning()
    {
        // Unlike service bus, I moved this out of Initialize to help clarify the essential test conditions - 
        // that is, to clarify that the API is running. The fact that we're monitoring the bus is a little
        // more incidental and showing that directly in the test (as opposed ot the Initialize() method)
        // does aid in understanding what is being tested.
 
        _webServer = new WebApiRunner();
 
        _webServer.Start();
    }
}

And now the Helper class:

    public static void WhenTheApiIsCalled(string messageContent, string routing, string baseAddress)
    {
        using (var client = new HttpClient())
        {
            client.BaseAddress = new Uri(baseAddress);
            client.DefaultRequestHeaders.Accept.Clear();
            client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
 
            var response = client.GetAsync(string.Format(routing, System.Net.WebUtility.UrlEncode(messageContent)));
 
            Assert.AreEqual(HttpStatusCode.Accepted, response.Result.StatusCode, "expected code 202");
        }
 
        Thread.Sleep(500);
    }
 
 
    public static IServiceBus SetupBusMonitoring(string queueAddress)
    {
        var bus = ServiceBusFactory.New(x =>
        {
            x.UseRabbitMq();
            x.ReceiveFrom(queueAddress);
            x.DisablePerformanceCounters();
 
            x.Subscribe(s =>
            {
                s.Consumer(() => new ApiTestConsumer());
            });
        });
 
        return bus;
    }
 
    public static void ThenTheMessageShouldHaveBeenSentToTheBus(string messageContent)
    {
        Assert.AreEqual(messageContent, ApiTestConsumer.ReceivedMessage, "proper message was not received");
    }
}

The ApiTestConsumer class is relatively straight-forward and ellided for brevity. Note that the service bus is being accessed with the help of MassTransit. While MassTransit is rather helpful in .Net to .Net messaging across either RabbitMQ or MSMQ, it turned out that it introduces some interesting challenges with respect to using anything other than MassTransit to publish a message. In other words, fast forwarding to a future post here, I had to be very particular about the way I sent my message to the bus using Node.js, in order for it to be consumed by ApiTestConsumer.

At this point, the code compiles – WebApiRunner is a real class implementing IDisposable, and app.js really does exist. But they don't do anything and the tests are Red. In the next post, I'll explore the Web API code.