private async Task <StorageQueue> QueueSetup()
{
var storage = new StorageQueue(GetQueueName(), TestHelpers.DevConnectionString);
await storage.CreateIfNotExists();
return(storage);
}
public async Task GetAllStorageQueues()
{
//create two blob containers
string queueName1 = Recording.GenerateAssetName("testqueue1");
string queueName2 = Recording.GenerateAssetName("testqueue2");
StorageQueue queue1 = (await _storageQueueContainer.CreateOrUpdateAsync(queueName1, new StorageQueueData())).Value;
StorageQueue queue2 = (await _storageQueueContainer.CreateOrUpdateAsync(queueName2, new StorageQueueData())).Value;
//validate if there are two queues
StorageQueue queue3 = null;
StorageQueue queue4 = null;
int count = 0;
await foreach (StorageQueue queue in _storageQueueContainer.GetAllAsync())
{
count++;
if (queue.Id.Name == queueName1)
{
queue3 = queue;
}
if (queue.Id.Name == queueName2)
{
queue4 = queue;
}
}
Assert.AreEqual(count, 2);
Assert.IsNotNull(queue3);
Assert.IsNotNull(queue4);
}
public async Task PeekGeneric()
{
StorageQueue storage = await QueueSetup();
var expected = new TestCustomObject {
FooInt = 42, FooString = "The Answer"
};
var expected2 = new TestCustomObject {
FooInt = 43, FooString = "The Answer 2"
};
var expectedList = new List <TestCustomObject> {
expected, expected2
};
foreach (var item in expectedList)
{
await storage.SendAsync(item);
}
var peeked = (await storage.PeekAsync <TestCustomObject>(2)).ToList();
Assert.AreEqual(expectedList.Count, peeked.Count);
Assert.IsTrue(expectedList.Any(m => m.FooInt == expected.FooInt && m.FooString == expected.FooString));
Assert.IsTrue(expectedList.Any(m => m.FooInt == expected2.FooInt && m.FooString == expected2.FooString));
var returned = (await storage.GetManyAsync <TestCustomObject>()).ToList();
Assert.AreEqual(expectedList.Count, returned.Count);
Assert.IsTrue(returned.Any(m => m.FooInt == expected.FooInt && m.FooString == expected.FooString));
Assert.IsTrue(returned.Any(m => m.FooInt == expected2.FooInt && m.FooString == expected2.FooString));
await storage.Delete();
}
public void SaveNull()
{
var name = Guid.NewGuid().ToString();
var t = new StorageQueue(name, ConnectionString);
Assert.That(() => t.Send((object)null), Throws.TypeOf <ArgumentNullException>());
}
public async Task <Response <StorageQueue> > CreateAsync(string resourceGroupName, string accountName, string queueName, StorageQueue queue, CancellationToken cancellationToken = default)
{
if (resourceGroupName == null)
{
throw new ArgumentNullException(nameof(resourceGroupName));
}
if (accountName == null)
{
throw new ArgumentNullException(nameof(accountName));
}
if (queueName == null)
{
throw new ArgumentNullException(nameof(queueName));
}
if (queue == null)
{
throw new ArgumentNullException(nameof(queue));
}
using var message = CreateCreateRequest(resourceGroupName, accountName, queueName, queue);
await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
switch (message.Response.Status)
{
case 200:
{
StorageQueue value = default;
using var document = await JsonDocument.ParseAsync(message.Response.ContentStream, default, cancellationToken).ConfigureAwait(false);
value = StorageQueue.DeserializeStorageQueue(document.RootElement);
return(Response.FromValue(value, message.Response));
}
public async Task ApproixmateMessageCountNone()
{
var storage = new StorageQueue(QueueName, ConnectionString);
var result = await storage.ApproixmateMessageCount();
Assert.AreEqual(0, result);
}
public void Reference()
{
var name = Guid.NewGuid().ToString();
var t = new StorageQueue(name, ConnectionString);
Assert.IsNotNull(t.Reference);
}
public void Client()
{
var name = Guid.NewGuid().ToString();
var t = new StorageQueue(name, ConnectionString);
Assert.IsNotNull(t.Client);
}
public void Name()
{
var name = Guid.NewGuid().ToString();
var t = new StorageQueue(name, ConnectionString);
Assert.AreEqual(name, t.Name);
}
public async Task CreateDeleteStorageQueue()
{
//create storage queue
string storageQueueName = Recording.GenerateAssetName("testqueue");
StorageQueue queue1 = (await _storageQueueContainer.CreateOrUpdateAsync(storageQueueName, new StorageQueueData())).Value;
Assert.IsNotNull(queue1);
Assert.AreEqual(queue1.Id.Name, storageQueueName);
//validate if successfully created
StorageQueue queue2 = await _storageQueueContainer.GetAsync(storageQueueName);
AssertStorageQueueEqual(queue1, queue2);
Assert.IsTrue(await _storageQueueContainer.CheckIfExistsAsync(storageQueueName));
Assert.IsFalse(await _storageQueueContainer.CheckIfExistsAsync(storageQueueName + "1"));
StorageQueueData queueData = queue2.Data;
Assert.IsEmpty(queueData.Metadata);
//delete storage queue
await queue1.DeleteAsync();
//validate if successfully deleted
Assert.IsFalse(await _storageQueueContainer.CheckIfExistsAsync(storageQueueName));
StorageQueue queue3 = await _storageQueueContainer.GetIfExistsAsync(storageQueueName);
Assert.IsNull(queue3);
}
static int Main(string[] args)
{
if (args.Length == 0)
{
return(-1);
}
string storageUrl = args[0];
var queue = new StorageQueue(storageUrl);
while (true)
{
string message = Console.ReadLine();
if (message == null)
{
break;
}
queue.Send(message);
}
return(0);
}
public async Task CreateIfNotExists()
{
var name = 'a' + Guid.NewGuid().ToString().ToLowerInvariant().Replace('-', 'a');
var storage = new StorageQueue(name, ConnectionString);
var created = await storage.CreateIfNotExists();
Assert.IsTrue(created);
}
public async Task CreateIfNotExists()
{
var name = GetQueueName();
var storage = new StorageQueue(name, TestHelpers.DevConnectionString);
var created = await storage.CreateIfNotExists();
Assert.IsTrue(created);
await storage.Delete();
}
public async Task ApproixmateMessageCountNone()
{
StorageQueue storage = await QueueSetup();
var result = await storage.ApproixmateMessageCount();
Assert.AreEqual(0, result);
await storage.Delete();
}
public async Task ConstructorAccount()
{
var name = 'a' + Guid.NewGuid().ToString().ToLowerInvariant().Replace('-', 'a');
var account = CloudStorageAccount.Parse(ConnectionString);
var storage = new StorageQueue(name, account, TimeSpan.FromSeconds(34));
var created = await storage.CreateIfNotExists();
Assert.IsTrue(created);
}
public async Task ConstructorAccount()
{
var name = GetQueueName();
var account = CloudStorageAccount.Parse(TestHelpers.DevConnectionString);
var storage = new StorageQueue(name, account, TimeSpan.FromSeconds(34));
var created = await storage.CreateIfNotExists();
Assert.IsTrue(created);
await storage.Delete();
}
public async Task Execute(string message)
{
var providerMessage = JsonConvert.DeserializeObject <RefreshIlrsProviderMessage>(message);
var nextPageProviderMessage = await _refreshIlrsLearnerService.ProcessLearners(providerMessage);
if (nextPageProviderMessage != null)
{
StorageQueue.Add(JsonConvert.SerializeObject(nextPageProviderMessage));
}
}
public async Task RoundTripMsgAsObj()
{
var storage = new StorageQueue(QueueName, ConnectionString);
var msg = new CloudQueueMessage(Guid.NewGuid().ToByteArray());
await storage.Send((object)msg);
var returned = await storage.Get();
Assert.AreEqual(msg.AsBytes, returned.AsBytes);
}
public async Task Delete()
{
var storage = new StorageQueue(QueueName, ConnectionString);
var msg = new CloudQueueMessage(Guid.NewGuid().ToByteArray());
await storage.Send(msg);
var returned = await storage.Get();
await storage.Delete(returned);
}
public async Task QueueNames()
{
var name = 'a' + Guid.NewGuid().ToString().ToLowerInvariant().Replace('-', 'a');
var storage = new StorageQueue(name, ConnectionString);
var created = await storage.CreateIfNotExists();
var resources = new AzureStorageResources(ConnectionString);
var queues = resources.QueueNames();
Assert.IsTrue(queues.Contains(name));
}
public async Task RoundTripObject()
{
var storage = new StorageQueue(QueueName, ConnectionString);
var expected = Guid.NewGuid();
await storage.Send(expected);
var returned = await storage.Get();
var guid = JsonConvert.DeserializeObject <Guid>(returned.AsString);
Assert.AreEqual(expected, guid);
}
public async Task RoundTripMsgAsObj()
{
StorageQueue storage = await QueueSetup();
var msg = new CloudQueueMessage(Guid.NewGuid().ToByteArray());
await storage.Send((object)msg);
var returned = await storage.Get();
Assert.AreEqual(msg.AsBytes, returned.AsBytes);
await storage.Delete();
}
public async Task Delete()
{
StorageQueue storage = await QueueSetup();
var msg = new CloudQueueMessage(Guid.NewGuid().ToByteArray());
await storage.Send(msg);
var returned = await storage.Get();
await storage.Delete(returned);
await storage.Delete();
}
public async Task Execute()
{
var output = await _refreshIlrsProviderService.ProcessProviders();
if (output != null)
{
foreach (var message in output)
{
StorageQueue.Add(JsonConvert.SerializeObject(message));
}
await _refreshIlrsProviderService.SetLastRunDateTime(_dateTimeHelper.DateTimeNow);
}
}
public async Task RoundTripObject()
{
StorageQueue storage = await QueueSetup();
var expected = Guid.NewGuid();
await storage.Send(expected);
var returned = await storage.Get();
var guid = JsonConvert.DeserializeObject <Guid>(returned.AsString);
Assert.AreEqual(expected, guid);
await storage.Delete();
}
public async Task ApproixmateMessageCount()
{
var random = new Random();
var count = random.Next(1, 1000);
var storage = new StorageQueue(QueueName, ConnectionString);
for (var i = 0; i < count; i++)
{
await storage.Send(Guid.NewGuid());
}
var result = await storage.ApproixmateMessageCount();
Assert.AreEqual(count, result);
}
public async Task GenericGet()
{
StorageQueue storage = await QueueSetup();
var expected = new TestCustomObject {
FooInt = 42, FooString = "The Answer"
};
await storage.SendAsync(expected);
var returned = await storage.GetAsync <TestCustomObject>();
Assert.AreEqual(expected.FooString, returned.FooString);
Assert.AreEqual(expected.FooInt, returned.FooInt);
await storage.Delete();
}
public async Task UpdatedQueueMessage_RetainsOriginalProperties()
{
TraceWriter trace = new TestTraceWriter(TraceLevel.Verbose);
CloudQueue queue = Fixture.CreateNewQueue();
CloudQueue poisonQueue = Fixture.CreateNewQueue();
JobHostQueuesConfiguration queuesConfig = new JobHostQueuesConfiguration {
MaxDequeueCount = 2
};
StorageQueue storageQueue = new StorageQueue(new StorageQueueClient(Fixture.QueueClient), queue);
StorageQueue storagePoisonQueue = new StorageQueue(new StorageQueueClient(Fixture.QueueClient), poisonQueue);
Mock <ITriggerExecutor <IStorageQueueMessage> > mockTriggerExecutor = new Mock <ITriggerExecutor <IStorageQueueMessage> >(MockBehavior.Strict);
string messageContent = Guid.NewGuid().ToString();
CloudQueueMessage message = new CloudQueueMessage(messageContent);
await queue.AddMessageAsync(message, null, null, null, null, CancellationToken.None);
CloudQueueMessage messageFromCloud = await queue.GetMessageAsync();
QueueListener listener = new QueueListener(storageQueue, storagePoisonQueue, mockTriggerExecutor.Object, new WebJobsExceptionHandler(), trace,
null, null, queuesConfig);
mockTriggerExecutor
.Setup(m => m.ExecuteAsync(It.IsAny <IStorageQueueMessage>(), CancellationToken.None))
.ReturnsAsync(new FunctionResult(false));
await listener.ProcessMessageAsync(new StorageQueueMessage(messageFromCloud), TimeSpan.FromMinutes(10), CancellationToken.None);
// pull the message and process it again (to have it go through the poison queue flow)
messageFromCloud = await queue.GetMessageAsync();
Assert.Equal(2, messageFromCloud.DequeueCount);
await listener.ProcessMessageAsync(new StorageQueueMessage(messageFromCloud), TimeSpan.FromMinutes(10), CancellationToken.None);
// Make sure the message was processed and deleted.
await queue.FetchAttributesAsync();
Assert.Equal(0, queue.ApproximateMessageCount);
// The Listener has inserted a message to the poison queue.
await poisonQueue.FetchAttributesAsync();
Assert.Equal(1, poisonQueue.ApproximateMessageCount);
mockTriggerExecutor.Verify(m => m.ExecuteAsync(It.IsAny <IStorageQueueMessage>(), CancellationToken.None), Times.Exactly(2));
}
public async Task ApproixmateMessageCount()
{
var random = new Random();
var count = random.Next(1, 1000);
StorageQueue storage = await QueueSetup();
for (var i = 0; i < count; i++)
{
await storage.SendAsync(Guid.NewGuid());
}
var result = await storage.ApproixmateMessageCount();
Assert.AreEqual(count, result);
await storage.Delete();
}
public async Task Peek()
{
StorageQueue storage = await QueueSetup();
var msg = new CloudQueueMessage(Guid.NewGuid().ToByteArray());
await storage.Send(msg);
var peeked = await storage.PeekAsync();
Assert.AreEqual(msg.AsBytes, peeked.First().AsBytes);
var returned = await storage.Get();
Assert.AreEqual(msg.AsBytes, returned.AsBytes);
await storage.Delete();
}
