Dominic Burford - Professional Profile

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Microsoft.ServiceBus.Messaging;

public static void Run(BrokeredMessage message, TraceWriter log)
{
    log.Info($"C# ServiceBus queue trigger function processed message: {message.MessageId}");

    try
    {
        if (message != null)
        {
            //do something with the message here

            log.Info("Completing message.");
            message.Complete();
        }
    }
    catch (Exception ex)
    {
        message.Abandon();
        log.Info($"Exception occurred: {ex.Message}");
    }
}

/// <summary>
/// POCO class used for message exchange with the Azure Service Bus
/// </summary>
[DataContract]
[KnownType(typeof(MessageObjectEntity))]
public class MessageObjectEntity
{
    [DataMember]
    public string MessageType { get; set; }
    [DataMember]
    public object MessageContent { get; set; }
}

[KnownType(typeof(MyNewClass))]

/// <summary>
/// Creates a message for the service bus
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="message"></param>
/// <returns></returns>
private static MessageObjectEntity CreateMessageForServiceBus<T>(T message)
{
    return new MessageObjectEntity
    {
        MessageType = message.GetType().AssemblyQualifiedName,
        MessageContent = message
    };
}

using Microsoft.ServiceBus.Messaging;

MessageObjectEntity messageToSend = CreateMessageForServiceBus(message);
BrokeredMessage brokeredMessage = new BrokeredMessage(messageToSend);
await this._client.SendAsync(brokeredMessage);

private QueueClient GetServiceBusClient(string connection, string queuename)
{
    return this._client ??
           (this._client = QueueClient.CreateFromConnectionString(connection, queuename, ReceiveMode.PeekLock));
}

namespace CoreLibrary
{
    /// <summary>
    /// We use this interface for contructor injection in our unit tests. 
    /// We are essentially mocking the DateTime.Now property for unit testing.
    /// </summary>
    public interface IDateTime
    {
        DateTime Now { get; set; }
    }

    /// <summary>
    /// Library functions used by the application
    /// </summary>
    public class ReportLibrary
    {
        private readonly IDateTime _datetime;

        private class ActualDateTime : IDateTime
        {
            public DateTime Now { get; set; }
        }

        //If no reference to IDateTime is passed to the constructor then default to 
        //using the actual DateTime.Now property
        public ReportLibrary()
        {
            this._datetime = new ActualDateTime { Now = DateTime.Now};
        }

        //We will inject a reference to IDateTime from our unit tests with the required value for DateTime.Now specified
        public ReportLibrary(IDateTime datetime)
        {
            this._datetime = datetime;
        }
        public int MyFunction()
        {
          int result;

          //The original line of code below
          //DateTime today = DateTime.Now;

          //This is the updated line of code
          DateTime today = this._datetime.Now;

          //rest of the calculation goes here
          return result;
        }
    }
}

ReportLibrary reportLibrary = new ReportLibrary();
int result = reportLibrary.MyFunction();

[TestClass]
public class ReportLibraryTests
{
  //this goes at the top of our unit test class
  private class MockDateTime : IDateTime
  {
    public DateTime Now { get; set; }
  }
  //rest of the test methods go here
}

[TestMethod]
public void MyFunctionTests()
{
  IDateTime dateTime = new MockDateTime();
  //set the DateTime.Now property and inject this into the ReportLibrary constructor
  DateTime today = new DateTime(2016, 8, 3);
  dateTime.Now = today;
  ReportLibrary reportLibrary = new ReportLibrary(dateTime);
  int result = reportLibrary.MyFunction();
  Assert.AreEqual(999, result, "Invalid result for 'MyFunction'");
}