public async Task MultipleDisableQueueSuccessTestApi()
{
var context = _workContext.WithTag(_tag);
IEnumerable <string> queueNames = new string[] { "test-queue1", "test-queue2", "test-queue3" };
foreach (var item in queueNames)
{
var request = new SetQueueContractV1
{
QueueName = item,
CurrentSizeLimit = 10,
CurrentRetryLimit = 11,
LockValidForSec = 12,
};
await _client.Management.SetQueue(context, request);
}
IEnumerable <QueueDetailContractV1> rows = (await _client.Management.GetQueueList(context)).Value.Items;
rows.Should().NotBeNull();
rows.Count().Should().Be(queueNames.Count());
rows
.OrderBy(x => x.QueueName)
.Zip(queueNames.OrderBy(x => x), (f, s) => new Tuple <string, string>(f.QueueName, s))
.All(x => x.Item1 == x.Item2)
.Should().BeTrue();
foreach (var item in queueNames)
{
await _client.Management.DisableQueue(context, item);
}
rows = (await _client.Management.GetQueueList(context)).Value.Items;
rows.Should().NotBeNull();
rows.Count().Should().Be(0);
rows = (await _client.Management.GetQueueList(context, disable: true)).Value.Items;
rows.Should().NotBeNull();
rows.Count().Should().Be(3);
foreach (var item in queueNames)
{
await _client.Management.EnableQueue(context, item);
}
rows = (await _client.Management.GetQueueList(context)).Value.Items;
rows.Should().NotBeNull();
rows.Count().Should().Be(queueNames.Count());
rows
.OrderBy(x => x.QueueName)
.Zip(queueNames.OrderBy(x => x), (f, s) => new Tuple <string, string>(f.QueueName, s))
.All(x => x.Item1 == x.Item2)
.Should().BeTrue();
}
private async Task SetupQueue(IWorkContext context)
{
var contract = new SetQueueContractV1
{
QueueName = _options.QueueName,
};
await _client.Management.SetQueue(context, contract);
}
public async Task DisableQueueSuccessTestApi()
{
QueueDetailContractV1 result;
IEnumerable <QueueDetailContractV1> list;
var context = _workContext.WithTag(_tag);
list = (await _client.Management.GetQueueList(context, false)).Value.Items;
list.Should().NotBeNull();
list.Count().Should().Be(0);
list = (await _client.Management.GetQueueList(context, true)).Value.Items;
list.Should().NotBeNull();
list.Count().Should().Be(0);
const string queueName = "test-queue";
var request = new SetQueueContractV1
{
QueueName = queueName,
CurrentSizeLimit = 10,
CurrentRetryLimit = 11,
LockValidForSec = 12,
};
await _client.Management.SetQueue(context, request);
list = (await _client.Management.GetQueueList(context, false)).Value.Items;
list.Should().NotBeNull();
list.Count().Should().Be(1);
result = (await _client.Management.GetQueue(context, queueName)).Value;
result.Should().NotBeNull();
result.QueueName.Should().Be(queueName);
await _client.Management.DisableQueue(context, queueName);
await Verify.AssertExceptionAsync <RestNotFoundException>(async() => await _client.Management.GetQueue(context, queueName));
list = (await _client.Management.GetQueueList(context, true)).Value.Items;
list.Should().NotBeNull();
list.Count().Should().Be(1);
result = list.First();
result.QueueName.Should().Be(queueName);
result.Disable.Should().BeTrue();
await _client.Management.EnableQueue(context, queueName);
result = (await _client.Management.GetQueue(context, queueName)).Value;
result.Should().NotBeNull();
result.QueueName.Should().Be(queueName);
list = (await _client.Management.GetQueueList(context, false)).Value.Items;
list.Should().NotBeNull();
list.Count().Should().Be(1);
}
public async Task <IActionResult> SetQueue(string queueName, [FromBody] SetQueueContractV1 contract)
{
Verify.IsNotEmpty(nameof(queueName), queueName);
Verify.IsNotNull(nameof(contract), contract);
RequestContext requestContext = HttpContext.GetRequestContext();
var context = requestContext.Context.WithTag(_tag);
contract.SetDefaults();
await _management.SetQueue(context, queueName, (int)contract.CurrentSizeLimit, (int)contract.CurrentRetryLimit, (int)contract.LockValidForSec);
return(new StandardActionResult(context));
}
/// <summary>
/// Create or update queue
/// </summary>
/// <param name="context">context</param>
/// <param name="contract">request details</param>
/// <returns>status</returns>
public async Task <RestResponse> SetQueue(IWorkContext context, SetQueueContractV1 contract)
{
Verify.IsNotNull(nameof(context), context);
Verify.IsNotNull(nameof(contract), contract);
Verify.IsNotEmpty(nameof(contract.QueueName), contract.QueueName);
context = context.WithTag(_tag);
return(await CreateClient()
.AddPath(contract.QueueName)
.SetContent(contract)
.PutAsync(context)
.ToRestResponseAsync(context)
.EnsureSuccessStatusCodeAsync(context));
}
public async Task SetDuplicateQueueFailedTestsApi()
{
IEnumerable <QueueDetailContractV1> rows;
var context = _workContext.WithTag(_tag);
rows = (await _client.Management.GetQueueList(context)).Value.Items;
rows.Should().NotBeNull();
rows.Count().Should().Be(0);
const string queueName = "test-queue";
var request = new SetQueueContractV1
{
QueueName = queueName,
CurrentSizeLimit = 10,
CurrentRetryLimit = 11,
LockValidForSec = 12,
};
await _client.Management.SetQueue(context, request);
QueueDetailContractV1 result = (await _client.Management.GetQueue(context, queueName)).Value;
result.Should().NotBeNull();
result.QueueName.Should().Be(queueName);
rows = (await _client.Management.GetQueueList(context)).Value.Items;
rows.Should().NotBeNull();
rows.Count().Should().Be(1);
await _client.Management.SetQueue(context, request);
rows = (await _client.Management.GetQueueList(context)).Value.Items;
rows.Should().NotBeNull();
rows.Count().Should().Be(1);
await _client.Management.DeleteQueue(context, queueName);
rows = (await _client.Management.GetQueueList(context)).Value.Items;
rows.Should().NotBeNull();
rows.Count().Should().Be(0);
await Verify.AssertExceptionAsync <RestNotFoundException>(async() => await _client.Management.GetQueue(context, queueName));
}
public async Task <AgentContractV1> SetupAgentAndQueue(
string queueName,
string agentName,
int queueSize = 1000,
int currentRetryLimit = 3,
int lockValidForSec = 300)
{
var context = _workContext.WithTag(_tag);
var contract = new SetQueueContractV1
{
QueueName = queueName,
CurrentSizeLimit = queueSize,
CurrentRetryLimit = currentRetryLimit,
LockValidForSec = lockValidForSec,
};
await _client.Management.SetQueue(context, contract);
return((await _client.Message.GetAgentId(context, queueName, agentName)).Value);
}
public async Task GetQueueStatusTestApi()
{
var context = _workContext.WithTag(_tag);
const string queueName = "test-queue";
var request = new SetQueueContractV1
{
QueueName = queueName,
CurrentSizeLimit = 10,
CurrentRetryLimit = 11,
LockValidForSec = 12,
};
await _client.Management.SetQueue(context, request);
IEnumerable <QueueStatusContractV1> result = (await _client.Management.GetQueueStatus(context)).Value.Items;
result.Should().NotBeNull();
result.Count().Should().Be(1);
result.First().QueueName.Should().Be(queueName);
const string queueName2 = "test-queue-2";
request = new SetQueueContractV1
{
QueueName = queueName2,
CurrentSizeLimit = 10,
CurrentRetryLimit = 11,
LockValidForSec = 12,
};
await _client.Management.SetQueue(context, request);
result = (await _client.Management.GetQueueStatus(context)).Value.Items;
result.Should().NotBeNull();
result.Count().Should().Be(2);
result.Count(x => x.QueueName == queueName || x.QueueName == queueName2).Should().Be(2);
}
/// <summary>
/// Enable queue, insure the queue exist
/// </summary>
/// <param name="context">context</param>
/// <returns>task</returns>
private async Task EnableQueue(IWorkContext context)
{
if (_enabledQueue)
{
return;
}
RestResponse <QueueDetailContractV1> result = await Client.Management.GetQueue(context, QueueName, new HttpStatusCode[] { HttpStatusCode.NotFound });
if (result.StatusCode == HttpStatusCode.OK)
{
return;
}
var contract = new SetQueueContractV1
{
QueueName = QueueName,
};
await Client.Management.SetQueue(context, contract);
_enabledQueue = true;
}
public async Task SetQueueSuccessTestsApi()
{
var context = _workContext.WithTag(_tag);
const string queueName = "test-queue";
await Verify.AssertExceptionAsync <RestNotFoundException>(async() => await _client.Management.GetQueue(context, queueName));
RestResponse <QueueDetailContractV1> check = await _client.Management.GetQueue(context, queueName, new HttpStatusCode[] { HttpStatusCode.NotFound });
check.StatusCode.Should().Be(HttpStatusCode.NotFound);
var request = new SetQueueContractV1
{
QueueName = queueName,
CurrentSizeLimit = 10,
CurrentRetryLimit = 11,
LockValidForSec = 12,
};
await _client.Management.SetQueue(context, request);
QueueDetailContractV1 result = (await _client.Management.GetQueue(context, queueName)).Value;
result.Should().NotBeNull();
result.QueueName.Should().Be(queueName);
result.CurrentSizeLimit.Should().Be(10);
result.CurrentRetryLimit.Should().Be(11);
result.LockValidForSec.Should().Be(12);
result.Disable.Should().BeFalse();
result.QueueLength.Should().Be(0);
await _client.Management.DeleteQueue(context, queueName);
await Verify.AssertExceptionAsync <RestNotFoundException>(async() => await _client.Management.GetQueue(context, queueName));
}
