public void given_a_messaging_factory()
		{
			mf = TestConfigFactory.CreateMessagingFactory();
			var nm = TestConfigFactory.CreateNamespaceManager(mf);

			nm.TopicExists("my.topic.here").ShouldBeFalse();
		}

 public BrokeredTransport(string connectionString, string inputQueueName)
 {
     this.connectionString = connectionString;
     this.inputQueueName = inputQueueName;
     this.factory = MessagingFactory.CreateFromConnectionString(connectionString);
     this.queues = new ConcurrentDictionary<string, QueueClient>();
 }

 internal ResponseMessagePump(MessagingFactory messagingFactory, string replyQueueName, RequestResponseCorrelator requestResponseCorrelator, ILogger logger, int batchSize)
     : base(logger, batchSize)
 {
     _messagingFactory = messagingFactory;
     _replyQueueName = replyQueueName;
     _requestResponseCorrelator = requestResponseCorrelator;
 }

        public ServiceBusConnection(ServiceBusScaleoutConfiguration configuration, TraceSource traceSource)
        {
            _trace = traceSource;
            _connectionString = configuration.BuildConnectionString();

            try
            {
                _namespaceManager = NamespaceManager.CreateFromConnectionString(_connectionString);
                _factory = MessagingFactory.CreateFromConnectionString(_connectionString);

                if (configuration.RetryPolicy != null)
                {
                    _factory.RetryPolicy = configuration.RetryPolicy;
                }
                else
                {
                    _factory.RetryPolicy = RetryExponential.Default;
                }
            }
            catch (ConfigurationErrorsException)
            {
                _trace.TraceError("The configured Service Bus connection string contains an invalid property. Check the exception details for more information.");
                throw;
            }

            _backoffTime = configuration.BackoffTime;
            _idleSubscriptionTimeout = configuration.IdleSubscriptionTimeout;    
            _configuration = configuration;
        }

        public async Task<string> OpenAsync(CancellationToken cancellationToken)
        {
            var builder = new ServiceBusConnectionStringBuilder(_connectionString)
            {
                TransportType = TransportType.Amqp
            };
            _messagingFactory = MessagingFactory.CreateFromConnectionString(builder.ToString());
            _eventHubClient = _messagingFactory.CreateEventHubClient(_eventHubName);
            _consumerGroup = !string.IsNullOrEmpty(_consumerGroupName)
                ? _eventHubClient.GetConsumerGroup(_consumerGroupName)
                : _eventHubClient.GetDefaultConsumerGroup();

            _eventProcessorFactory = new EventProcessorFactory();
            _leaseRepository = new ReliableStateLeaseRepository(_reliableStateManager);
            _checkpointManager = new CheckpointManager(_leaseRepository); 

            var allocatedPartitions = await new EventHubPartitionPartitionAllocationStrategy(_serviceName, _partitionId)
                .AllocateAsync(_eventHubClient, new FabricClient());

            foreach (var partition in allocatedPartitions)
            {
                var lease = await _leaseRepository.GetOrCreateAsync(_connectionString, _consumerGroupName, _eventHubName, partition);

                await _consumerGroup.RegisterProcessorFactoryAsync(lease, _checkpointManager, _eventProcessorFactory);
            }

            return string.Concat(_eventHubName, " @ ", _connectionString);
        }

 public RequestMessagePump(MessagingFactory messagingFactory, IRequestBroker requestBroker, Type messageType, ILogger logger)
     : base(logger)
 {
     _messagingFactory = messagingFactory;
     _requestBroker = requestBroker;
     _messageType = messageType;
 }

        protected static void AzureMessageConsumer(MessagingFactory f)
        {
            //use the already created messaging factory to create a msg receiver
            MessageReceiver testQueueReceiver = f.CreateMessageReceiver("colors");

            while (true)
            {
                using (BrokeredMessage retrievedMessage = testQueueReceiver.Receive())
                {

                    try
                    {
                        string msgResult = retrievedMessage.GetBody<string>();

                        //call SP to insert the data into the proper table
                        InsertSQL(msgResult);

                        Console.WriteLine("Message received: " + msgResult);
                        retrievedMessage.Complete();
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine(ex.ToString());
                        retrievedMessage.Abandon();
                    }
                }
            }
        }

        public async void Init(MessageReceived messageReceivedHandler) {
            this.random = new Random();

            //ServiceBusEnvironment.SystemConnectivity.Mode = ConnectivityMode.AutoDetect;
            
            // Tcp mode does not work when I run in a VM (VirtualBox) and the host 
            // is using a wireless connection. Hard coding to Http.
            ServiceBusEnvironment.SystemConnectivity.Mode = ConnectivityMode.Http;

            string connectionString = CloudConfigurationManager.GetSetting("Microsoft.ServiceBus.ConnectionString");
            this.factory = MessagingFactory.CreateFromConnectionString(connectionString);
            this.namespaceManager = NamespaceManager.CreateFromConnectionString(connectionString);

            if (!namespaceManager.TopicExists(topicName)) {
                namespaceManager.CreateTopic(topicName);
            }

            this.subscriptionName = Guid.NewGuid().ToString();

            // Not needed really, it's a GUID...
            if (!namespaceManager.SubscriptionExists(topicName, subscriptionName)) {
                namespaceManager.CreateSubscription(topicName, subscriptionName);
            }

            this.topicClient = factory.CreateTopicClient(topicName);

            this.subClient = factory.CreateSubscriptionClient(topicName, subscriptionName);

            while (true) {
                await ReceiveMessageTaskAsync(messageReceivedHandler);
            }
        }

        public DurableMessageSender(MessagingFactory messagingFactory, string serviceBusQueueOrTopicName)
        {
            this.messagingFactory = messagingFactory;
            this.sbusEntityName = serviceBusQueueOrTopicName;

            // Create a Service Bus queue client to send messages to the Service Bus queue.
            this.messageSender = this.messagingFactory.CreateMessageSender(this.sbusEntityName);

            // Create MSMQ queue if it doesn't exit. If it does, open the existing MSMQ queue.
            this.msmqQueueName = MsmqHelper.CreateMsmqQueueName(this.sbusEntityName, "SEND");
            this.msmqQueue = MsmqHelper.GetMsmqQueue(this.msmqQueueName);

            // Create MSMQ deadletter queue if it doesn't exit. If it does, open the existing MSMQ deadletter queue.
            this.msmqDeadletterQueueName = MsmqHelper.CreateMsmqQueueName(this.sbusEntityName, "SEND_DEADLETTER");
            this.msmqDeadletterQueue = MsmqHelper.GetMsmqQueue(this.msmqDeadletterQueueName);

            // Initialize wait time after durable client experienced a transient error.
            timerWaitTimeInMilliseconds = minTimerWaitTimeInMilliseconds;

            // FOR TESTING PURPOSE ONLY.
            this.faultInjector = new FaultInjector(enableFaultInjection);

            // Start receiving messages from the MSMQ queue.
            MsmqPeekBegin();
        }

        public void Connect()
        {
            Disconnect();

            _log.DebugFormat("Connecting '{0}'", _endpointAddress);

            if (_messagingFactory == null)
                _messagingFactory = _endpointAddress.MessagingFactoryFactory();

            // check if it's a queue or a subscription to subscribe either the queue or the subscription?
            if (_endpointAddress.QueueDescription != null)
            {
                _messageSender = _endpointAddress.CreateQueue()
                                                 .ContinueWith(t =>
                                                     {
                                                         t.Wait();
                                                         return
                                                             _messagingFactory.TryCreateMessageSender(
                                                                 _endpointAddress.QueueDescription, _prefetchCount)
                                                                              .Result;
                                                     })
                                                 .Result;
            }
            else
            {
                _messageSender = _messagingFactory.TryCreateMessageSender(_endpointAddress.TopicDescription)
                                                  .Result;
            }

            if (_messageSender == null)
                throw new TransportException(_endpointAddress.Uri,
                    "The create message sender on messaging factory returned null.");
        }

 public ServiceBusListener(MessagingFactory messagingFactory, string entityPath, ServiceBusTriggerExecutor triggerExecutor)
 {
     _messagingFactory = messagingFactory;
     _entityPath = entityPath;
     _triggerExecutor = triggerExecutor;
     _cancellationTokenSource = new CancellationTokenSource();
 }

 public ReliableClientBase(string sbNamespace, TokenProvider tokenProvider, string path, RetryPolicy<ServiceBusTransientErrorDetectionStrategy> policy)
 {
     mRetryPolicy = policy;
     Uri address = ServiceBusEnvironment.CreateServiceUri("sb", sbNamespace, string.Empty);
     mNamespaceManager = new NamespaceManager(address, tokenProvider);
     mMessagingFactory = MessagingFactory.Create(address, tokenProvider);
 }

 public MulticastRequestMessagePump(MessagingFactory messagingFactory, IMulticastRequestBroker multicastRequestBroker, Type requestType, string applicationSharedSubscriptionName, ILogger logger, int batchSize) : base(logger, batchSize)
 {
     _messagingFactory = messagingFactory;
     _multicastRequestBroker = multicastRequestBroker;
     _requestType = requestType;
     _applicationSharedSubscriptionName = applicationSharedSubscriptionName;
 }

 static void ReceiveAllMessagesFromSubscripions(MessagingFactory messagingFactory)
 {
     // Receive message from 3 subscriptions.
     Program.ReceiveAllMessageFromSubscription(messagingFactory, Conts.SubAllMessages);
     Program.ReceiveAllMessageFromSubscription(messagingFactory, Conts.YoungHorses);
     Program.ReceiveAllMessageFromSubscription(messagingFactory, Conts.OldHorses);
 }

 public CommandMessagePump(MessagingFactory messagingFactory, ICommandBroker commandBroker, Type messageType, ILogger logger)
     : base(logger)
 {
     _messagingFactory = messagingFactory;
     _commandBroker = commandBroker;
     _messageType = messageType;
 }

 public MulticastEventMessagePump(MessagingFactory messagingFactory, IMulticastEventBroker multicastEventBroker, Type eventType, string subscriptionName, ILogger logger, int batchSize)
     : base(logger, batchSize)
 {
     _messagingFactory = messagingFactory;
     _multicastEventBroker = multicastEventBroker;
     _eventType = eventType;
     _subscriptionName = subscriptionName;
 }

 private static void CreateCommandMessagePumps(BusBuilderConfiguration configuration, MessagingFactory messagingFactory, List<IMessagePump> messagePumps)
 {
     foreach (var commandType in configuration.CommandTypes)
     {
         var pump = new CommandMessagePump(messagingFactory, configuration.CommandBroker, commandType, configuration.Logger);
         messagePumps.Add(pump);
     }
 }

 public HeaterCommunication()
 {
     var topicNameSend = "businessrulestofieldgateway";
     _topicNameReceive = "fieldgatewaytobusinessrules";
     _namespaceMgr = NamespaceManager.CreateFromConnectionString(CloudConfigurationManager.GetSetting("ServiceBusConnectionString"));
     _factory = MessagingFactory.CreateFromConnectionString(CloudConfigurationManager.GetSetting("ServiceBusConnectionString"));
     _client = _factory.CreateTopicClient(topicNameSend);
 }

 public TaskOrchestrationClient(string connectionString, string orchestrationTopicName)
 {
     this.orchestrationTopicName = orchestrationTopicName;
     this.connectionString = connectionString;
     this.messagingFactory = MessagingFactory.CreateFromConnectionString(this.connectionString);
     this.oxQueueClient = this.messagingFactory.CreateQueueClient(this.orchestrationTopicName);
     this.defaultConverter = new JsonDataConverter();
 }

 public ServiceBusListener(MessagingFactory messagingFactory, string entityPath, ServiceBusTriggerExecutor triggerExecutor, ServiceBusConfiguration config)
 {
     _messagingFactory = messagingFactory;
     _entityPath = entityPath;
     _triggerExecutor = triggerExecutor;
     _cancellationTokenSource = new CancellationTokenSource();
     _messageProcessor = config.MessagingProvider.CreateMessageProcessor(entityPath);
 }