public AdminController()
{
categoryService = new CategoryService();
goodService = new GoodService();
blobService = new BlobService();
queueService = new QueueService();
}
public async Task NackOnException()
{
var queueConfig = new QueueConfiguration
{
QueueName = QueueName,
PrefetchCount = 1,
OnErrorAction = QueueConfiguration.ErrorAction.NackOnException,
ConsumerTag = "consumer",
RetryIntervalInSeconds = 1
};
var queue = new QueueService(ExposedRabbitService.validConfig, subscriberlogger.Object);
queue.Start(queueConfig, handler);
var initialConsumerCount = basicService.ExposedChannel.ConsumerCount(QueueName);
basicService.ExposedChannel.BasicPublish(ExchangeName, "", true, null, Encoding.UTF8.GetBytes(TestMessages.Redeliver));
await Task.Delay(RoundTripWaitTime);
var inbetweenConsumerCount = basicService.ExposedChannel.ConsumerCount(QueueName);
await Task.Delay(1000 + RoundTripWaitTime);
var finalConsumerCount = basicService.ExposedChannel.ConsumerCount(QueueName);
queue.Dispose();
successCount.Should().Be(1, "because item is not excepted twice");
processCount.Should().Be(2, "because first time exception, second time succesful process");
initialConsumerCount.Should().Be(1);
inbetweenConsumerCount.Should().Be(1, "because only the message is nacked");
errorCount.Should().Be(1, "because error should be thrown first time");
finalConsumerCount.Should().Be(1);
}
public void Create(Notification notification)
{
var queueService = new QueueService();
queueService.Enqueue(notification.Recipient.Id.ToString(),
notification.ToString());
}
public async Task DropMessage()
{
var queueConfig = new QueueConfiguration
{
QueueName = QueueName,
PrefetchCount = 1,
OnErrorAction = QueueConfiguration.ErrorAction.DropMessage,
ConsumerTag = "consumer",
RetryIntervalInSeconds = 1
};
var queue = new QueueService(ExposedRabbitService.validConfig, subscriberlogger.Object);
queue.Start(queueConfig, handler);
var initialConsumerCount = basicService.ExposedChannel.ConsumerCount(QueueName);
basicService.ExposedChannel.BasicPublish(ExchangeName, "", true, null, Encoding.UTF8.GetBytes(TestMessages.Redeliver));
await Task.Delay(RoundTripWaitTime);
var finalConsumerCount = basicService.ExposedChannel.ConsumerCount(QueueName);
queue.Dispose();
processCount.Should().Be(1, "because the message is dropped");
initialConsumerCount.Should().Be(1);
errorCount.Should().Be(1);
finalConsumerCount.Should().Be(1, "because consumer shouldn't have stopped");
}
/// <summary>
/// Initiates a call to pull available gateways from Air Mesh. All found gateways will be placed on an Azure Queue to be picked up by
/// the Controllers Web Job
/// </summary>
/// <param name="timer"></param>
/// <param name="log"></param>
public static void PollGateways([TimerTrigger("00:15:00", RunOnStartup = true, UseMonitor = true)] TimerInfo timer, TextWriter log)
{
try
{
// Fire up Air Mesh API...
var airMesh = new AirMeshService(log);
// Get the available sites
var siteIDs = airMesh.GetSiteIDs();
// Get the Gateways for each site
var gateways = airMesh.GetGateways(siteIDs);
// Get the Azure Queue...
var queue = QueueService.GetQueue(Constants.REAL_TIME_DEVICE_QUEUE);
// Push the Gateways onto the queue
foreach (var gateway in gateways)
{
queue.AddMessageAsync(new CloudQueueMessage(JsonConvert.SerializeObject(gateway)));
}
}
catch (Exception ex)
{
// TODO: Format logging
log.WriteAsync(ex.ToString());
}
}
public async Task Play([Remainder, Summary("The query or the URL of the youtube video.")] string urlOrQuery)
{
SocketGuild guild = Context.Guild;
QueueService queue = Queues.GetOrCreateService(guild.Id);
string youtubeLink;
string title = null;
// Query, select first video found, works for links too.
// If param looks like a valid Uri, don't search for title similarities.
var result = Search(urlOrQuery, 1, Uri.IsWellFormedUriString(urlOrQuery, UriKind.Absolute) ? (Func <VideoInformation, int>)(x => (x.Url == urlOrQuery) ? 0 : 1) : null)[0];
youtubeLink = result.Url;
title = result.Title;
Enqueue(youtubeLink, title, guild.Id);
await ReplyAsync(Enqueued(title));
if (IsInVoiceChannel(guild, Context.Message.Author) && !IAmInVoiceChannel(FindVoiceChannel(guild, Context.Message.Author)))
{
await JoinAndPlay(queue, FindVoiceChannel(guild, Context.Message.Author));
}
else if (!queue.IsPlaying)
{
PlayQueue(queue, AudioClients.GetClient(guild.Id));
}
}
public void AccessFilledQueue()
{
QueueService.setMessage("test1");
var response = QueueService.getMessage();
Assert.AreEqual("test1", response, "Oops...");
}
protected async Task InvokeAsync()
{
var sqsClient = AwsClientsSingletonsProvider.GetSqsClient();
var queueService = new QueueService(sqsClient);
await queueService.AddMessageAsync(new ItemMessage(Guid.NewGuid()), GetQueueUrl());
}
///Create two threads and assert they both get equal IDs
public void QueueGameTest()
{
QueueService queueService = QueueService.Instance;
Guid id1 = Guid.Empty;
Player p1 = Player.RED;
Guid id2 = Guid.Empty;
Player p2 = Player.RED;
var t1 = new Thread(() =>
{
(id1, p1) = queueService.MatchGame();
});
var t2 = new Thread(() =>
{
(id2, p2) = queueService.MatchGame();
});
t1.Start();
t2.Start();
t1.Join(50);
t2.Join(50);
Assert.NotEqual(id1, Guid.Empty);
Assert.NotEqual(id2, Guid.Empty);
Assert.Equal(id1, id2);
Assert.NotEqual(p1, p2);
}
public static async Task Run(
// At 20 seconds past the minute every 3 minutes, between 7:00 PM and 7:59 AM every day except
// from 4 AM to 5 AM when site maintenance seems like it might be happening--matching SyncGames.
[TimerTrigger("20 */3 0-3,5-7,19-23 * * *")] TimerInfo timer,
ILogger log)
{
var queueService = new QueueService(Environment.GetEnvironmentVariable("AzureWebJobsStorage"));
string playerID = await queueService.GetNextPlayerFromBuildGamesBlobQueue();
log.LogInformation($"Got next player from BuildGamesBlob queue: {playerID ?? "N/A"}.");
if (playerID == null)
{
return;
}
var tableService = new TableService(Environment.GetEnvironmentVariable("AzureWebJobsStorage"));
var games = (await tableService.GetGameRows(playerID))
.Select(r => new GameBlobObject(r))
.OrderBy(r => r.Date)
.ToArray();
log.LogInformation($"Queried games table for {playerID}: {games.Length} games found.");
var blobService = new BlobService(Environment.GetEnvironmentVariable("AzureWebJobsStorage"));
await blobService.UploadGamesBlobContent(playerID, JsonConvert.SerializeObject(games));
log.LogInformation($"{playerID}'s games blob updated.");
await queueService.RemovePlayerFromBuildGamesBlobQueue(playerID);
log.LogInformation($"Removed {playerID} from BuildGamesBlob queue.");
}
public BugService(IBugRepository bugRepository)
{
_bugRepository = bugRepository;
var config = new MapperConfiguration(cfg =>
{
cfg.CreateMap <User, UserViewModel>()
.ForMember(uvm => uvm.Role, opt => opt.MapFrom(u => (UserRole)u.UserRoleID));
cfg.CreateMap <Project, ProjectViewModel>();
cfg.CreateMap <Bug, BaseBugViewModel>();
cfg.CreateMap <Bug, BugViewModel>()
.ForMember(bvm => bvm.AssignedUser, opt => opt.MapFrom(b => b.User))
.ForMember(bgm => bgm.Status, opt => opt.MapFrom(b => (BugStatus)b.StatusID))
.ForMember(bgm => bgm.Priority, opt => opt.MapFrom(b => (BugPriority)b.PriorityID));
cfg.CreateMap <Bug, FullBugViewModel>()
.ForMember(fbvm => fbvm.AssignedUser, opt => opt.MapFrom(b => b.User))
.ForMember(fbvm => fbvm.Status, opt => opt.MapFrom(b => (BugStatus)b.StatusID))
.ForMember(fbvm => fbvm.Priority, opt => opt.MapFrom(b => (BugPriority)b.PriorityID))
.ForMember(fbvm => fbvm.Comments, opt => opt.Ignore());
cfg.CreateMap <CommentModel, CommentViewModel>();
cfg.CreateMap <BugFormViewModel, Bug>();
});
_mapper = config.CreateMapper();
_queueService = new QueueService();
}
public void TestQueueService_CTOR_ChannelNull()
{
Assert.That(() =>
{ var qs = new QueueService(null); },
Throws.TypeOf <ArgumentNullException>()
);
}
public void ShouldReuseExistingQueue()
{
var result = new QueueService().GetPrivateQueues(ComputerName);
Assert.That(result.Count(q => q.QueueName.ToLower().Contains(NameOfNewQueue.ToLower())),
Is.EqualTo(1));
}
public void ProcessMessage()
{
var logger = new Mock <ILogger>();
var loggerFactory = new Mock <ILoggerFactory>();
loggerFactory.Setup(c => c.CreateLogger(It.IsAny <string>())).Returns(logger.Object);
var metricsRepo = new Mock <IMetricsRepository>();
var model = new Mock <IModel>();
var connection = new Mock <IConnection>();
connection.Setup(c => c.CreateModel()).Returns(model.Object);
var connectonFactory = new Mock <ConnectionFactory>();
connectonFactory.Setup(c => c.CreateConnection()).Returns(connection.Object);
var queueConsumerService = new Mock <IQueueConsumerService>();
var queueService = new QueueService(queueConsumerService.Object, connectonFactory.Object, loggerFactory.Object);
Assert.NotNull(queueService);
var handler = new Mock <IMessageHandler>();
queueService.RegisterHandler(handler.Object);
queueService.ProcessMessage("the message body", queueConsumerService.Object, It.IsAny <ulong>(), new QueueMetric());
}
public void CreateInstance()
{
var logger = new Mock <ILogger>();
var loggerFactory = new Mock <ILoggerFactory>();
loggerFactory.Setup(c => c.CreateLogger(It.IsAny <string>())).Returns(logger.Object);
var metricsRepo = new Mock <IMetricsRepository>();
var model = new Mock <IModel>();
var connection = new Mock <IConnection>();
connection.Setup(c => c.CreateModel()).Returns(model.Object);
var connectonFactory = new Mock <ConnectionFactory>();
connectonFactory.Setup(c => c.CreateConnection()).Returns(connection.Object);
var queueConsumerService = new Mock <IQueueConsumerService>();
var queueService = new QueueService(queueConsumerService.Object, connectonFactory.Object, loggerFactory.Object);
Assert.NotNull(queueService);
}
public JsonResult Register(char qType)
{
QueueService qService = new QueueService();
Queue qNo = qService.Register((QueueType)qType);
return(new JsonResult(qNo));
}
public WatcherService(ILogger <WatcherService> loggingService)
{
logger = loggingService;
logger.LogInformation("Loading watchers");
ConfPath = (RuntimeInformation.IsOSPlatform(OSPlatform.Linux)) ? "/etc/" + CONFNAME : Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) + Path.DirectorySeparatorChar + CONFNAME;
if (!File.Exists(ConfPath))
{
var defConf = Assembly.GetExecutingAssembly().GetManifestResourceStream("HandBrake_daemon.default.conf");
using var sr = new StreamReader(defConf);
File.WriteAllText(ConfPath, sr.ReadToEnd());
}
_QueueService = QueueService.Instance;
var unprocessedPresets = Process.Start(new ProcessStartInfo
{
FileName = ("HandBrakeCLI"),
Arguments = "--preset-list",
RedirectStandardOutput = true,
RedirectStandardError = true
}).StandardError.ReadToEnd();
var reg = @"\n[\s]{4}([^\s].*)$";
Presets.AddRange(from Match m in Regex.Matches(unprocessedPresets, reg, RegexOptions.Multiline)
select m.Groups[1].ToString().Trim());
LoadWatchlist();
CheckPermissions();
ScanWatchDirs();
}
public void SendNotifications()
{
IDBManager dBManager = new MSSQLDBManager();
QueueService qs = new QueueService(dBManager);
qs.DequeueAndProcess();
}
static void Main(string[] args)
{
CharacterGenerator generator = new CharacterGenerator();
IQueueService service = new QueueService();
service.QueueTick += DungeonQueueEventHandler;
Console.WriteLine("Add players to the queue. W for Warrior, P for Priest");
string input = "";
while ((input = Console.ReadLine()) != "x")
{
if (input.ToLower() == "w")
{
Character c = generator.Warrior();
service.AddCharacter(c);
Console.WriteLine("Added new Warrior: " + c.Name);
}
if (input.ToLower() == "p")
{
Character c = generator.Priest();
service.AddCharacter(c);
Console.WriteLine("Added new Priest: " + c.Name);
service.AddCharacter(generator.Priest());
}
}
}
public static MessageQueue CreatePrivateQueue(string computerName, string queueName, bool isTransactional)
{
var queuePath = CreateQueuePathForPrivateQueue(computerName, queueName, isTransactional);
var queueService = new QueueService();
return(queueService.CreateQueue(queuePath, isTransactional));
}
public static async Task Main(string[] args)
{
Console.CancelKeyPress += Console_CancelKeyPress;
Console.Clear();
Console.ForegroundColor = ConsoleColor.Cyan;
Console.WriteLine("Consumer - reading messages, processing and deleting from Azure queue 500 ms.");
Console.WriteLine();
Console.ForegroundColor = ConsoleColor.White;
Console.Write("Press 1 to read One message at a time, or any other key to read Five messages at a time: ");
var key = Console.ReadKey(true);
singleMessage = key.Key == ConsoleKey.D1;
// Using a SAS Key that is valid for a fixed period only.
// "Connection String" value when Generare SAS and connection string button in Azure
// OR - use from app.config "appSettings" -> AzureQueueStorageConnectionString
var connectionString = CloudConfigurationManager.GetSetting("AzureQueueStorageConnectionString");
IQueueService queueService = new QueueService(connectionString, "samplequeue");
if (key.Key == ConsoleKey.D1)
{
await ProcessOneMessage(queueService);
}
else
{
await ProcessFiveMessages(queueService);
}
Console.ForegroundColor = ConsoleColor.White;
Console.WriteLine();
Console.WriteLine("Completed. Press a key to exit.");
Console.ReadKey();
}
public async Task DripFeedMessages(uint prefetch, int numberofMessages)
{
var queueConfig = new QueueConfiguration
{
QueueName = QueueName,
PrefetchCount = (ushort)prefetch,
OnErrorAction = QueueConfiguration.ErrorAction.RestartConnection,
ConsumerTag = "consumer",
RetryIntervalInSeconds = 10
};
var queue = new QueueService(ExposedRabbitService.validConfig, subscriberlogger.Object);
queue.Start(queueConfig, handler);
for (uint messagecount = 1; messagecount < numberofMessages + 1; messagecount++)
{
basicService.ExposedChannel.BasicPublish(ExchangeName, "", true, null, Encoding.UTF8.GetBytes("message"));
await Task.Delay(RoundTripWaitTime);
var queueMessageCount = basicService.ExposedChannel.MessageCount(QueueName);
if (prefetch > messagecount)
{
queueMessageCount.Should().Be(0, "because there are {0} messages with {1} prefetch", messagecount, prefetch);
processCount.Should().Be(messagecount, "because the prefetch is {0}", prefetch);
}
// if prefetch is greater than message number, then the final count should be 0.
else
{
queueMessageCount.Should().Be(messagecount - prefetch, "because there are messages in queue exceeds prefetch");
processCount.Should().Be(prefetch, "because the prefetch exceeds number of messages");
}
}
queue.Dispose();
}
public QueueVM()
{
User = new User()
{
Id = 112,
Login = "******",
isActive = true,
isSendingData = false
};
QueueView = new QueueViewData();
QueueData = new QueueData();
QueueService = new QueueService(QueueData, User);
_connectCommand = new ConnectCommand(this);
_disconnectCommand = new DisconnectCommand(this);
//QueueView.AdditionalMessage = "Lorem ipsum loros dalej nie pamietam jak to leciało, ale potrzebuje troche wiecej tekstu";
QueueData.PropertyChanged += QueueData_PropertyChanged;
//QueueView.AdditionalMessage = "Lorem ipsum loros dalej nie pamietam jak to leciało, ale potrzebuje troche wiecej tekstu";
if (DesignerProperties.GetIsInDesignMode(new System.Windows.DependencyObject()))
{
QueueView.QueueNoMessage = "PB123456";
QueueView.AdditionalMessage = "Lorem ipsum loros dalej nie pamietam jak to leciało, ale potrzebuje troche wiecej tekstu";
}
}
public static void ProduceTasks()
{
Random random = new Random();
for (int i = 1; i <= 1; i++)
{
var queue = new QueuedObject
{
QueueID = i,
ProducerThreadID = Thread.CurrentThread.ManagedThreadId,
EnqueueDateTime = DateTime.Now,
// Used to Generate Random String
RandomString = new string(Enumerable.Repeat("ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789", 5).Select(s => s[random.Next(s.Length)]).ToArray())
};
#region Queueing using Queue Collection
// Uncomment QueueService.Enqueue(() => { ProcessQueue(queue); }) to use .Net Queue Object to Queue Tasks.
// And Comment ConcurrentQueueService.Enqueue
QueueService.Enqueue(() => { ProcessQueue(queue); });
#endregion
#region Queueing using ConcurrentQueue
//ConcurrentQueueService.Enqueue(() => { ProcessQueue(queue); });
#endregion
Console.WriteLine
(
"Enqueued: " + queue.QueueID +
"\t" + "Producer ThreadID :" + queue.ProducerThreadID +
"\t" + queue.EnqueueDateTime.ToLongTimeString() +
"\t" + "RandomString :" + queue.RandomString
);
}
}
private void ValidateQueueService(QueueService queueService)
{
Assert.NotNull(queueService);
Assert.NotNull(queueService.FrontEndCallbackThreadsCount);
Assert.NotNull(queueService.FrontEndCpuBasedKeepAliveThrottlingCpuMonitorIntervalInSeconds);
Assert.NotNull(queueService.FrontEndCpuBasedKeepAliveThrottlingEnabled);
Assert.NotNull(queueService.FrontEndCpuBasedKeepAliveThrottlingPercentCpuThreshold);
Assert.NotNull(queueService.FrontEndCpuBasedKeepAliveThrottlingPercentRequestsToThrottle);
Assert.NotNull(queueService.FrontEndHttpListenPort);
Assert.NotNull(queueService.FrontEndHttpsListenPort);
Assert.NotNull(queueService.FrontEndMaxMillisecondsBetweenMemorySamples);
Assert.NotNull(queueService.FrontEndMemoryThrottleThresholdSettings);
Assert.NotNull(queueService.FrontEndMemoryThrottlingEnabled);
Assert.NotNull(queueService.FrontEndMinThreadPoolThreads);
Assert.NotNull(queueService.FrontEndThreadPoolBasedKeepAliveIOCompletionThreshold);
Assert.NotNull(queueService.FrontEndThreadPoolBasedKeepAliveMonitorIntervalInSeconds);
Assert.NotNull(queueService.FrontEndThreadPoolBasedKeepAlivePercentage);
Assert.NotNull(queueService.FrontEndThreadPoolBasedKeepAliveWorkerThreadThreshold);
Assert.NotNull(queueService.FrontEndUseSlaTimeInAvailability);
//Assert.NotNull(queueService.HealthStatus);
Assert.NotNull(queueService.Id);
Assert.NotNull(queueService.Location);
Assert.NotNull(queueService.Name);
Assert.NotNull(queueService.Type);
Assert.NotNull(queueService.Version);
}
public async Task ReleaseHeldMessages()
{
var queueConfig = new QueueConfiguration
{
QueueName = QueueName,
PrefetchCount = 1,
OnErrorAction = QueueConfiguration.ErrorAction.RestartConnection,
ConsumerTag = "consumer",
RetryIntervalInSeconds = 10
};
var queue = new QueueService(ExposedRabbitService.validConfig, subscriberlogger.Object);
queue.Start(queueConfig, handler);
basicService.ExposedChannel.BasicPublish(ExchangeName, "", true, null, Encoding.UTF8.GetBytes(TestMessages.Exception));
await Task.Delay(RoundTripWaitTime);
var freeMessages = basicService.ExposedChannel.MessageCount(QueueName);
queue.Dispose();
var finalMessageCount = basicService.ExposedChannel.MessageCount(QueueName);
processCount.Should().Be(1, "because 1 messages were sent");
successCount.Should().Be(0, "because 0 successful messages were sent");
errorCount.Should().Be(1);
freeMessages.Should().Be(1, "because excepted messages should be released");
finalMessageCount.Should().Be(1, "because only one message caused exception");
}
public async Task VerifyQueueService_Get35Messages()
{
// Arrange
IQueueService queueService = new QueueService("UseDevelopmentStorage=true", "testqueue");
// Act
var messages = await queueService.GetMessagesAsync(35, TimeSpan.FromHours(1));
}
public void VerifyQueueService_Creation_Returns_Valid_Instance()
{
// Arrange
IQueueService queueService = new QueueService("UseDevelopmentStorage=true", "testqueue");
// Assert
Assert.IsNotNull(queueService);
}
public DocRenderFunction(BlobService blob, TableService table, QueueService queue, JobService jobService, MpowerClient renderService)
{
_blob = blob;
_table = table;
_queue = queue;
_jobService = jobService;
_renderService = renderService;
}
public void crearcola()
{
string queueName = "MyQueue";
string queueDescription = "Cola para turnos de partida.";
queueService = sp.BuildQueueService();
queueService.CreatePullQueue(queueName, queueDescription, MessageBack);
}
protected override void Arrange()
{
Cleanup();
_queueService = new QueueService();
_queuePath = QueueTestHelper.CreateQueuePathForPrivateQueue(ComputerName, TestQueueName, _isTransactional);
_queueService.CreateQueue(_queuePath, _isTransactional);
_messageData = new TestClass1 { IntValue1 = 1, StringValue1 = "string1" };
}
public static void CleanupPrivateTestQueues(string computerName, string partialTestQueueName)
{
var queueService = new QueueService();
var privateQueues = queueService.GetPrivateQueues(computerName);
var testQueues = privateQueues
.Where(q => q.QueueName.ToLower().Contains(@"private$\" + partialTestQueueName.ToLower()));
foreach (var queue in testQueues)
{
queueService.DeleteQueue(queue.Path);
}
}
protected override void Arrange()
{
Cleanup();
_queueService = new QueueService();
_queuePath = QueueTestHelper.CreateQueuePathForPrivateQueue(ComputerName, TestQueueName, _isTransactional);
_queueService.CreateQueue(_queuePath, _isTransactional);
for (int i = 1; i <= MessageCount; i++)
{
var messageData = new TestClass1 { IntValue1 = i, StringValue1 = "string" + i };
_queueService.CreateMessage(_queuePath, messageData, TestMessagesLabel);
}
}
protected override void Arrange()
{
Cleanup();
_queueService = new QueueService();
_queuePath = QueueTestHelper.CreateQueuePathForPrivateQueue(ComputerName, TestQueueName, _isTransactional);
_queueService.CreateQueue(_queuePath, _isTransactional);
_queueService.CreateMessage(_queuePath, new TestClass1 { StringValue1 = "Should not be deleted" }, TestMessagesLabelForMessageWhichShouldNotBeDeleted);
_messageData = new TestClass1 { IntValue1 = 1, StringValue1 = "string1" };
_queueService.CreateMessage(_queuePath, _messageData, TestMessagesLabel);
_messageToDelete = _queueService.GetMessageInfos(_queuePath, TestMessagesLabel).Single();
}
public void Test()
{
//string chuck = "chuck";
var service = new QueueService();
service.Process();
//TestMethod("chuck", "chuck2", null);
//var demo = new DemoMessage {FirstName = "Chuck", LastName = "Conway"};
//IQueue q = new AzureQueue();
////q.Send("media", demo);
//int messageCount = 0;
//q.ProcessAllMessages<DemoMessage>("media", r => messageCount++);
}
public static MessageQueue CreatePrivateQueue(string computerName, string queueName, bool isTransactional)
{
var queuePath = CreateQueuePathForPrivateQueue(computerName, queueName, isTransactional);
var queueService = new QueueService();
return queueService.CreateQueue(queuePath, isTransactional);
}
protected override void Act()
{
Result = new QueueService().GetJournalQueue(_journalQueueParent);
}
protected override void Act()
{
Result = new QueueService().GetPrivateQueues(ComputerName);
}
protected override void Arrange()
{
Cleanup();
_queueService = new QueueService();
_queuePath = QueueTestHelper.CreateQueuePathForPrivateQueue(ComputerName, TestQueueName, _isTransactional);
_queueService.CreateQueue(_queuePath, _isTransactional);
}
public void ShouldReuseExistingQueue()
{
var result = new QueueService().GetPrivateQueues(ComputerName);
Assert.That(result.Count(q => q.QueueName.ToLower().Contains(NameOfNewQueue.ToLower())),
Is.EqualTo(1));
}
