gistfile1.cs

/// <summary>
/// Tests that OpenConnection creates the proper MQQueueManager and accesses the
/// queue with the right set of options.
/// </summary>
[TestMethod]
public void Test_OpenConnection_GoesThrough()
{
    const string host = "some random host";
    const string channel = "some random channel";
    const string manager = "some random manager";
    const string queueName = "some random queue";
    const int port = 1234;

    var startListeningCall = false;

    using (ShimsContext.Create())
    {
        var configShim = new ShimConfigurationProvider
        {
            MQMessageListenerChannelNameGet = () => channel,
            MQMessageListenerHostNameGet = () => host,
            MQMessageListenerPortNumericGet = () => port,
            MQMessageListenerQueueManagerNameGet = () => manager
        };

        ShimMQQueueManager.ConstructorStringHashtable = (_, s, options) =>
        {
            Assert.AreEqual(manager, s);
            Assert.AreEqual(host, options[MQC.HOST_NAME_PROPERTY]);
            Assert.AreEqual(channel, options[MQC.CHANNEL_PROPERTY]);
            Assert.AreEqual(port, options[MQC.PORT_PROPERTY]);
            Assert.AreEqual(MQC.TRANSPORT_MQSERIES_MANAGED, options[MQC.TRANSPORT_PROPERTY]);
        };

        ShimMQQueueManager.AllInstances.AccessQueueStringInt32 = (_, s, options) =>
        {
            Assert.AreEqual(MQC.MQOO_INPUT_AS_Q_DEF + MQC.MQOO_FAIL_IF_QUIESCING, options);
            Assert.AreEqual(queueName, s);
            return null;
        };

        var mqShim = new ShimMQMessageQueue
        {
            InstanceBehavior = ShimBehaviors.Fallthrough,
            ConfigurationProviderGet = () => configShim.Instance,
            QueueNameGet = () => queueName,
            StreamGet = () => new Subject<IServiceMessage>(),
            StartListening = () => { startListeningCall = true; }
        };

        mqShim.Instance.OpenConnection(false);

        Assert.IsFalse(startListeningCall);
    }
}

/// <summary>
/// Tests the OpenConnection options in the queue access when the queue is setup to read.
/// It also ensures that StartListening is called if the queue is opened for reading.
/// </summary>
[TestMethod]
public void Test_OpenConnection_ForReading()
{
    const string queueName = "some random queue";

    var startListeningCall = false;

    using (ShimsContext.Create())
    {
        ShimMQQueueManager.ConstructorStringHashtable = (_, __, ___) => { };

        ShimMQQueueManager.AllInstances.AccessQueueStringInt32 = (_, s, options) =>
        {
            Assert.AreEqual(MQC.MQOO_INPUT_AS_Q_DEF + MQC.MQOO_FAIL_IF_QUIESCING + MQC.MQOO_BROWSE, options);
            Assert.AreEqual(queueName, s);
            return null;
        };

        var mqShim = new ShimMQMessageQueue
        {
            InstanceBehavior = ShimBehaviors.Fallthrough,
            ConfigurationProviderGet = () => new ShimConfigurationProvider().Instance,
            QueueNameGet = () => queueName,
            StreamGet = () => new Subject<IServiceMessage>(),
            StartListening = () => { startListeningCall = true; }
        };

        mqShim.Instance.OpenConnection();

        Assert.IsTrue(startListeningCall);
    }
}

/// <summary>
/// Tests the OpenConnection options in the queue access when the queue is setup to write.
/// </summary>
[TestMethod]
public void Test_OpenConnection_ForWriting()
{
    const string queueName = "some random queue";

    var startListeningCall = false;

    using (ShimsContext.Create())
    {
        ShimMQQueueManager.ConstructorStringHashtable = (_, __, ___) => { };

        ShimMQQueueManager.AllInstances.AccessQueueStringInt32 = (_, s, options) =>
        {
            Assert.AreEqual(MQC.MQOO_INPUT_AS_Q_DEF + MQC.MQOO_FAIL_IF_QUIESCING + MQC.MQOO_OUTPUT, options);
            Assert.AreEqual(queueName, s);
            return null;
        };

        var mqShim = new ShimMQMessageQueue
        {
            InstanceBehavior = ShimBehaviors.Fallthrough,
            ConfigurationProviderGet = () => new ShimConfigurationProvider().Instance,
            QueueNameGet = () => queueName,
            StreamGet = () => new Subject<IServiceMessage>(),
            StartListening = () => { startListeningCall = true; }
        };

        mqShim.Instance.OpenConnection(false, true);

        Assert.IsFalse(startListeningCall);
    }
}

/// <summary>
/// Tests the OpenConnection options in the queue access when the queue is setup to
/// read and write at the same time.
/// It also ensures that StartListening is called if the queue is opened for reading.
/// </summary>
[TestMethod]
public void Test_OpenConnection_ForReadingAndWriting()
{
    const string queueName = "some random queue";

    var startListeningCall = false;

    using (ShimsContext.Create())
    {
        ShimMQQueueManager.ConstructorStringHashtable = (_, __, ___) => { };

        ShimMQQueueManager.AllInstances.AccessQueueStringInt32 = (_, s, options) =>
        {
            Assert.AreEqual(MQC.MQOO_INPUT_AS_Q_DEF + MQC.MQOO_FAIL_IF_QUIESCING + MQC.MQOO_BROWSE + MQC.MQOO_OUTPUT, options);
            Assert.AreEqual(queueName, s);
            return null;
        };

        var mqShim = new ShimMQMessageQueue
        {
            InstanceBehavior = ShimBehaviors.Fallthrough,
            ConfigurationProviderGet = () => new ShimConfigurationProvider().Instance,
            QueueNameGet = () => queueName,
            StreamGet = () => new Subject<IServiceMessage>(),
            StartListening = () => { startListeningCall = true; }
        };

        mqShim.Instance.OpenConnection(true, true);

        Assert.IsTrue(startListeningCall);
    }
}

/// <summary>
/// Ensure that opening a connection with a Bad Queue Name will throw a proper
/// <see cref="ConfigurationErrorsException"/>.
/// </summary>
[TestMethod]
[ExpectedException(typeof(ConfigurationErrorsException))]
public void Ensure_OpenConnection_ThrowsBadQueueName()
{
    const int nameReasonCode = 2085;

    using (ShimsContext.Create())
    {
        ShimMQQueueManager.ConstructorStringHashtable = (_, __, ___) => { };

        ShimMQQueueManager.AllInstances.AccessQueueStringInt32 = (_, __, ___) =>
        {
            throw new MQException(1, nameReasonCode);
        };

        var mqShim = new ShimMQMessageQueue
        {
            InstanceBehavior = ShimBehaviors.Fallthrough,
            ConfigurationProviderGet = () => new ShimConfigurationProvider().Instance,
            QueueNameGet = () => "something",
            StreamGet = () => new Subject<IServiceMessage>(),
        };

        mqShim.Instance.OpenConnection();
    }
}

/// <summary>
/// Ensure that any exception besides Bad Queue Name will be re-thrown
/// and bubble out of the OpenConnection method.
/// </summary>
[TestMethod]
[ExpectedException(typeof(MQException))]
public void Ensure_OpenConnection_ThrowsOthersExceptBadName()
{
    using (ShimsContext.Create())
    {
        ShimMQQueueManager.ConstructorStringHashtable = (_, __, ___) => { };

        ShimMQQueueManager.AllInstances.AccessQueueStringInt32 = (_, __, ___) =>
        {
            throw new MQException(1, 1);
        };

        var mqShim = new ShimMQMessageQueue
        {
            InstanceBehavior = ShimBehaviors.Fallthrough,
            ConfigurationProviderGet = () => new ShimConfigurationProvider().Instance,
            QueueNameGet = () => "something",
            StreamGet = () => new Subject<IServiceMessage>(),
        };

        mqShim.Instance.OpenConnection();
    }
}