public async Task IfSpecifiedDeleteIndexAfterReindexing()
{
CreateIndexWithConfig("initialindex", "{}");
var alias = _fixture.Create <string>();
await AssignToAlias(alias, "initialindex");
var sqsMessage = new SqsMessage();
_sqsClientMock.Setup(s => s.SendMessageAsync(It.Is <SendMessageRequest>(
s => StoreMessage(s, out sqsMessage)), default))
.ReturnsAsync(new SendMessageResponse());
await _classUnderTest.ReindexAlias(new ReindexRequest { alias = alias }, null);
System.Threading.Thread.Sleep(1000);
sqsMessage.deleteAfterReindex = true;
sqsMessage.timeCreated = DateTime.Now.AddSeconds(-600);
await _classUnderTest.SwitchAlias(SqsEvent(sqsMessage), null);
var index = await ElasticsearchClient.Indices.GetAsync(Indices.Index("initialindex"));
index.Indices.Count.Should().Be(0);
}
public void Send(Company pCompany)
{
try
{
SqsMessage _sqsmessage = new SqsMessage();
_sqsmessage.QueueUrl = this.QueueUrl;
_sqsmessage.MessageBody = "Company data information";
Dictionary <string, MessageAttributeValue> _data = new Dictionary <string, MessageAttributeValue>();
_data.Add("Id", new MessageAttributeValue()
{
StringValue = pCompany.Id.ToString(), DataType = "String"
});
_data.Add("Name", new MessageAttributeValue()
{
StringValue = pCompany.Name, DataType = "String"
});
_data.Add("Email", new MessageAttributeValue()
{
StringValue = pCompany.Email, DataType = "String"
});
_sqsmessage.MessageAttributes = _data;
base.Send(_sqsmessage);
}
catch (Exception oException)
{
throw oException;
}
}
public async Task RemovesAliasFromOldIndexAndAddsToNewIndex()
{
CreateIndexWithConfig("initialindex", "{}");
var alias = _fixture.Create <string>();
await AssignToAlias(alias, "initialindex");
var sqsMessage = new SqsMessage();
_sqsClientMock.Setup(s => s.SendMessageAsync(It.Is <SendMessageRequest>(
s => StoreMessage(s, out sqsMessage)), default))
.ReturnsAsync(new SendMessageResponse());
await _classUnderTest.ReindexAlias(new ReindexRequest { alias = alias }, null);
sqsMessage.alias.Should().Be(alias);
System.Threading.Thread.Sleep(1000);
sqsMessage.timeCreated = DateTime.Now.AddSeconds(-600);
await _classUnderTest.SwitchAlias(SqsEvent(sqsMessage), null);
var indices = await ElasticsearchClient.GetIndicesPointingToAliasAsync(alias);
indices.Count.Should().Be(1);
indices.First().Should().Contain(sqsMessage.newIndex);
}
private void QueueReadTimer_Tick(object sender, EventArgs e)
{
foreach (var message in sqsCaller.GetMessages())
{
SqsMessage localMessage = message;
QueueTextBox.UIThread(() =>
QueueTextBox.AppendText(string.Format("[{0:hh:MM}] {1}\r\n", DateTime.Now, localMessage.Message)));
sqsCaller.DeleteMessage(message.ReceiptHandle);
}
}
public void MessageTimingIsValid_ValidTimings_ReturnsTrue(int timeDelaySeconds)
{
var message = new SqsMessage()
{
taskId = "test",
newIndex = "test",
alias = "test",
timeCreated = DateTime.Now.AddSeconds(-timeDelaySeconds)
};
var handler = HandlerTestDouble.HandlerTestDoubleFactory();
handler.MessageTimingIsValid(message).Should().Be(true);
}
private static SQSEvent SqsEvent(SqsMessage sqsMessage)
{
var sqsEvent = new SQSEvent
{
Records = new List <SQSEvent.SQSMessage>
{
new SQSEvent.SQSMessage {
Body = JsonConvert.SerializeObject(sqsMessage)
}
}
};
return(sqsEvent);
}
public void ReceiveMessageMultipleTimes_UsingDeadLetterQueue_MessageShouldBePlacedInDeadLetterQueue()
{
const string sourceQueueName = "SourceQueue_RedrivePolicy_StandardQueue";
const string deadLetterQueueName = "DeadLetterQueue_StandardQueue";
var message = new SqsMessage("Test");
var createQueueResponse = _sqs.CreateQueue(sourceQueueName);
var deadLetterQueueResponse = _sqs.CreateQueue(deadLetterQueueName);
var queueAttrs = _sqs.GetQueueAttributes(new GetQueueAttributesRequest(deadLetterQueueResponse.QueueUrl, new List <string> {
"QueueArn"
}));
var sqsRequest = new SetQueueAttributesRequest()
{
Attributes = new Dictionary <string, string>()
{
{ QueueAttributeName.RedrivePolicy, "{\"maxReceiveCount\":\"5\", \"deadLetterTargetArn\":\"" + queueAttrs.QueueARN + "\"}" }
},
QueueUrl = createQueueResponse.QueueUrl
};
_sqs.SetQueueAttributes(sqsRequest);
_queueUrl = createQueueResponse.QueueUrl;
// Send a message for the source queue
var response = _sqs.SendMessage(new SendMessageRequest(_queueUrl, message.Body));
var receiveMessageRequest = new ReceiveMessageRequest()
{
QueueUrl = _queueUrl
};
// Read from the source queue multiple times
for (int i = 0; i < 6; i++)
{
var receiveMessageResponse = _sqs.ReceiveMessage(receiveMessageRequest);
}
var deadLetterQueueMessageResponse = _sqs.ReceiveMessage(deadLetterQueueResponse.QueueUrl);
// Verify that the message has moved to the dead-letter queue
Assert.Equal(message.Body, deadLetterQueueMessageResponse.Messages.First().Body);
// Cleanup
SqsQueueUtils.DeleteQueue(deadLetterQueueResponse.QueueUrl, _sqs);
}
public IList <Message> List()
{
try
{
SqsMessage _sqsmessage = new SqsMessage();
_sqsmessage.QueueUrl = this.QueueUrl;
IList <Message> _olMessage = base.List(_sqsmessage, true);
return(_olMessage);
}
catch (Exception oException)
{
throw oException;
}
}
private SendMessageResponse SendMessage(SqsMessage message)
{
var sendMessageRequest = new SendMessageRequest
{
QueueUrl = _queueUrl,
MessageBody = message.Body,
MessageAttributes = new Dictionary <string, MessageAttributeValue>
{
{ "Custom", new MessageAttributeValue {
DataType = "String", StringValue = "Custom Data"
} }
}
};
return(_sqs.SendMessage(sendMessageRequest));
}
public async Task IfTaskNoLongerExistsSwitchAliasReturnsWithoutReaddingMessageToTheQueue()
{
CreateIndexWithConfig("initialindex", "{}");
var alias = _fixture.Create <string>();
await AssignToAlias(alias, "initialindex");
var sqsMessage = new SqsMessage
{
alias = alias,
taskId = "HSYFGEWUIFGEWUIFG:34256",
deleteAfterReindex = true
};
await _classUnderTest.SwitchAlias(SqsEvent(sqsMessage), null);
_sqsClientMock.Verify(x => x.SendMessageAsync(It.IsAny <SendMessageRequest>(), It.IsAny <CancellationToken>()),
Times.Never);
}
public static IEnumerable <SqsMessage> Parse(string xmlText)
{
var rootEl = XElement.Parse(xmlText); // <ReceiveMessageResponse>
var receiveMessageResultEl = rootEl.Element(SqsClient.NS + "ReceiveMessageResult");
foreach (var messageEl in receiveMessageResultEl.Elements(SqsClient.NS + "Message"))
{
var message = new SqsMessage {
Id = messageEl.Element(SqsClient.NS + "MessageId").Value,
Receipt = new MessageReceipt(messageEl.Element(SqsClient.NS + "ReceiptHandle").Value),
Body = messageEl.Element(SqsClient.NS + "Body").Value,
SequenceNumber = messageEl.Element(SqsClient.NS + "SequenceNumber")?.Value
};
yield return(message);
}
}
public void ReceiveMessage_WithWaitTimeSet_ShouldEnableLongPolling()
{
const string queueName = "MessageWaitTime_StandardQueue";
const int waitTimeSeconds = 10;
var message = new SqsMessage("Test");
var sqsRequest = new CreateQueueRequest(queueName);
var createQueueResponse = _sqs.CreateQueue(sqsRequest);
_queueUrl = createQueueResponse.QueueUrl;
var secondSqsClient = LocalSQSClientBuilder.CreateClient();
var receiveMessageRequest = new ReceiveMessageRequest()
{
QueueUrl = _queueUrl,
WaitTimeSeconds = waitTimeSeconds
};
var stopwatch = new System.Diagnostics.Stopwatch();
stopwatch.Start();
var receiveMessageResponseWithinTimeout = secondSqsClient.ReceiveMessage(receiveMessageRequest);
stopwatch.Stop();
Assert.True(stopwatch.ElapsedMilliseconds < (waitTimeSeconds * 1000) + 1000);
Assert.Empty(receiveMessageResponseWithinTimeout.Messages);
var response = _sqs.SendMessage(new SendMessageRequest(_queueUrl, message.Body));
stopwatch.Reset();
stopwatch.Start();
var receiveMessageResponseAfterTimeout = secondSqsClient.ReceiveMessage(_queueUrl);
stopwatch.Stop();
// The ReceiveMessage call should be quick as there is a message in the queue to receive
Assert.True(stopwatch.ElapsedMilliseconds < waitTimeSeconds * 1000);
Assert.Equal(message.Body, receiveMessageResponseAfterTimeout.Messages.First().Body);
}
public void EndToEndCreateQueueSendMessageReceiveMessageDeleteMessage_WithMessageAttributes_ShouldHaveEmptyQueueAfterDeleting()
{
const string queueName = "StandardQueue-CoreEndToEndTest";
var createQueueResponse = CreateQueue(queueName);
ValidateQueueCreated(createQueueResponse, queueName);
var message = new SqsMessage("This is a simple message");
var messageResponse = SendMessage(message);
ValidateMessageSent(messageResponse);
var receiveMessageResponse = ReceiveMessage();
ValidateMessageReceived(receiveMessageResponse, message);
DeleteMessageFromQueue(receiveMessageResponse);
ValidateMessageDeletedFromQueue();
}
public void ReceiveMessage_WithVisibilityTimeout_ShouldPreventConsumerFromRetrievingMessageDuringTheVisibilityTimeout()
{
const string queueName = "MessageVisibility_StandardQueue";
const int visibilityTimeoutSeconds = 15;
var message = new SqsMessage("Test");
var sqsRequest = new CreateQueueRequest(queueName)
{
Attributes = new Dictionary <string, string>()
{
{ QueueAttributeName.VisibilityTimeout, visibilityTimeoutSeconds.ToString() }
}
};
var createQueueResponse = _sqs.CreateQueue(sqsRequest);
_queueUrl = createQueueResponse.QueueUrl;
var response = _sqs.SendMessage(new SendMessageRequest(_queueUrl, message.Body));
var receiveMessageRequest = new ReceiveMessageRequest()
{
QueueUrl = _queueUrl
};
var receiveMessageResponse = _sqs.ReceiveMessage(receiveMessageRequest);
Assert.Equal(message.Body, receiveMessageResponse.Messages.First().Body);
var secondSqsClient = LocalSQSClientBuilder.CreateClient();
var receiveMessageResponseWithinTimeout = secondSqsClient.ReceiveMessage(_queueUrl);
Assert.Empty(receiveMessageResponseWithinTimeout.Messages);
Thread.Sleep((visibilityTimeoutSeconds) * 1000);
var receiveMessageResponseAfterTimeout = secondSqsClient.ReceiveMessage(_queueUrl);
Assert.Equal(message.Body, receiveMessageResponseAfterTimeout.Messages.First().Body);
}
public async Task RemovesTheTaskDocument()
{
CreateIndexWithConfig("initialindex", "{}");
var alias = _fixture.Create <string>();
await AssignToAlias(alias, "initialindex");
var sqsMessage = new SqsMessage();
_sqsClientMock.Setup(s => s.SendMessageAsync(It.Is <SendMessageRequest>(
s => StoreMessage(s, out sqsMessage)), default))
.ReturnsAsync(new SendMessageResponse());
await _classUnderTest.ReindexAlias(new ReindexRequest { alias = alias }, null);
System.Threading.Thread.Sleep(1000);
sqsMessage.timeCreated = DateTime.Now.AddSeconds(-600);
await _classUnderTest.SwitchAlias(SqsEvent(sqsMessage), null);
var task = await ElasticsearchClient.Tasks.GetTaskAsync(new TaskId(sqsMessage.taskId));
task.ApiCall.HttpStatusCode.Should().Be(404);
}
private void ValidateMessageReceived(ReceiveMessageResponse receiveMessageResponse, SqsMessage message)
{
Assert.True(receiveMessageResponse.HttpStatusCode == HttpStatusCode.OK);
Assert.True(receiveMessageResponse.Messages.Count == 1);
var receivedMessage = receiveMessageResponse.Messages.First();
Assert.True(receivedMessage.Body == message.Body);
Assert.True(receivedMessage.MD5OfBody == message.Md5Hash);
Assert.True(receivedMessage.MessageAttributes.Count() == 1);
Assert.True(receivedMessage.MessageAttributes.First().Value.StringValue == "Custom Data");
}
public QueueReaderService(ILogger <QueueReaderService> logger, SqsMessage sqsMessage)
{
_logger = logger;
_sqsMessage = sqsMessage;
}
private static bool StoreMessage(SendMessageRequest sqsRequest, out SqsMessage message)
{
message = JsonConvert.DeserializeObject <SqsMessage>(sqsRequest.MessageBody);
return(true);
}
public AwsController(SnsMessage snsMessage, SqsMessage sqsMessage)
{
_snsMessage = snsMessage;
_sqsMessage = sqsMessage;
}
