public async Task TrySendEmailAsync_ShouldUseBaseTemplate_IfInvalidCultureProvided()
{
// arrange
var args = new EmailMessageParams
{
Culture = "zu-ZA",
ApplicationId = _fixture.ApplicationId,
TemplateId = _fixture.TemplateId,
To = new List <string> {
"*****@*****.**"
},
Data = new Dictionary <string, object> {
{ "Name", "Someone" }
}
};
var template = await _fixture.Database.FindTemplateAsync(_fixture.TemplateId);
var expected = await MustacheTemplateTransformer.Instance.TransformTemplateAsync(
new EmailTemplate(
template.SubjectTemplate,
template.BodyTemplate),
args.Data,
args.GetCulture());
// act
var success = await _target.TrySendEmailAsync(args);
// assert
_transport.Verify(m => m.SendAsync(It.Is <SenderParams>(p =>
p.Subject == expected.Subject && p.Body == expected.Body)));
}
public async Task <IActionResult> Test(
TestTemplateViewModel model,
[FromServices] IEmailQueueBlobStore blobStore,
[FromServices] IEmailQueueSender emailSender,
CancellationToken cancellationToken)
{
if (ModelState.IsValid)
{
var token = EmailQueueToken.Create(model.ApplicationId);
var param = new EmailMessageParams
{
ApplicationId = model.ApplicationId,
TemplateId = model.TemplateId,
To = new List <string> {
model.EmailAddress
},
Culture = model.Language,
Data = JObject.Parse(model.SampleData).ToObject <Dictionary <string, object> >()
};
await blobStore.AddAsync(token, param, cancellationToken);
await emailSender.SendAsync(token, cancellationToken);
Response.StatusCode = (int)HttpStatusCode.Accepted;
return(RedirectToAction(nameof(Details), new { id = model.TemplateId }));
}
// TODO: reload translations
return(View(model));
}
public async Task TrySendEmailAsync_ShouldUseSubjectAndBody_IfNoTemplateIdProvided()
{
// arrange
var args = new EmailMessageParams
{
ApplicationId = _fixture.ApplicationId,
To = new List <string> {
"*****@*****.**"
},
Data = new Dictionary <string, object> {
{ "Name", "Someone" }
},
Subject = "Hi {{Name}}",
BodyEncoded = EmailMessageParams.EncodeBody("Hi {{Name}}")
};
var template = await _fixture.Database.FindTemplateAsync(_fixture.TemplateId);
var expected = await MustacheTemplateTransformer.Instance.TransformTemplateAsync(
new EmailTemplate(
args.Subject,
args.GetBody()),
args.Data,
args.GetCulture());
// act
var success = await _target.TrySendEmailAsync(args);
// assert
_transport.Verify(m => m.SendAsync(It.Is <SenderParams>(p =>
p.Subject == expected.Subject && p.Body == expected.Body)));
}
public async Task SendMailAsync(EmailMessageParams param)
{
EmailTemplate messageTemplate;
if (string.IsNullOrEmpty(param.TemplateName))
{
messageTemplate = EmailTemplate.Default;
}
else
{
messageTemplate = await _templateRepository.FindByNameAsync(param.TemplateName);
}
await _emailSender.SendMailAsync(messageTemplate.CreateMessage(param));
}
public async Task AddAsync(EmailQueueToken token, EmailMessageParams message, CancellationToken cancellationToken)
{
_logger.LogTrace("Adding new blob to store for token {0}", token);
if (!_initialized)
{
await InitializeAsync(cancellationToken);
}
var serialized = EmailMessageParams.ToJson(message);
var blobName = GetBlobName(token);
var blob = _container.Value.GetBlockBlobReference(blobName);
await blob.UploadTextAsync(serialized, Encoding.UTF8, null, null, null, cancellationToken);
}
private EmailMessageParams BuildMessage(PostEmailRequest args)
{
const string EmptyData = "{}";
return(new EmailMessageParams
{
To = args.To,
CC = args.CC,
Bcc = args.Bcc,
LogLevel = args.LogLevel,
TemplateId = args.Template,
Subject = args.Subject,
BodyEncoded = EmailMessageParams.EncodeBody(args.Body),
Data = JObject.Parse(args.Data ?? EmptyData).ToObject <Dictionary <string, object> >()
});
}
public void ToJson_ShouldDeserializeDataObject()
{
// arrange
var data = new Dictionary <string, object> {
{ "Name", "Keith" }
};
var target = new EmailMessageParams {
Data = data
};
// act
var serialized = EmailMessageParams.ToJson(target);
var deserialized = EmailMessageParams.FromJson(serialized);
// assert
Assert.Equal(data, deserialized.Data);
}
public void ToJson_ShouldSerializeDataAsObject()
{
// arrange
var data = new Dictionary <string, object> {
{ "Name", "Keith" }
};
var expected = JsonConvert.SerializeObject(data, Formatting.None);
var target = new EmailMessageParams {
Data = data
};
// act
var actual = EmailMessageParams.ToJson(target, Formatting.None);
// assert
Assert.Contains(expected, actual);
}
public async Task ProcessMessage_Should_CompleteMessage_IfBlobNotFound()
{
// arrange
var token = new CancellationToken();
var message = new TestMessage {
Token = EmailQueueToken.Create(Guid.NewGuid())
};
EmailMessageParams nullBlob = null;
_blobStore.Setup(b => b.GetAsync(message.Token, token)).ReturnsAsync(nullBlob);
// act
await _target.ProcessMessage(message, token);
// assert
_receiver.Verify(t => t.CompleteAsync(message, token), Times.Once());
}
public async Task ProcessMessage_ShouldNot_SendEmail_IfBlobNotFound()
{
// arrange
var token = new CancellationToken();
var message = new TestMessage {
Token = EmailQueueToken.Create(Guid.NewGuid())
};
EmailMessageParams nullBlob = null;
_blobStore.Setup(b => b.GetAsync(message.Token, token)).ReturnsAsync(nullBlob);
// act
await _target.ProcessMessage(message, token);
// assert
_transport.Verify(t => t.SendAsync(It.IsAny <SenderParams>()), Times.Never());
}
public async Task TrySendEmailAsync_ThrowsInvalidOperation_IfApplicationNotFound()
{
// arrange
var args = new EmailMessageParams
{
ApplicationId = Guid.NewGuid(),
TemplateId = _fixture.TemplateId,
To = new List <string> {
"*****@*****.**"
},
Data = new Dictionary <string, object> {
{ "Name", "Someone" }
}
};
// act/assert
await Assert.ThrowsAsync <InvalidOperationException>(() => _target.TrySendEmailAsync(args));
}
public async Task TrySendEmailAsync_ShouldSendToAllRecipients()
{
// arrange
var args = new EmailMessageParams
{
ApplicationId = _fixture.ApplicationId,
TemplateId = _fixture.TemplateId,
To = new List <string> {
"*****@*****.**", "*****@*****.**"
},
CC = new List <string> {
"*****@*****.**", "*****@*****.**"
},
Bcc = new List <string> {
"*****@*****.**", "*****@*****.**"
},
Data = new Dictionary <string, object> {
{ "Name", "Someone" }
}
};
List <string> to = null;
List <string> cc = null;
List <string> bcc = null;
_transport
.Setup(m => m.SendAsync(It.IsAny <SenderParams>()))
.ReturnsAsync(true)
.Callback <SenderParams>(p =>
{
to = new List <string>(p.To);
cc = new List <string>(p.CC);
bcc = new List <string>(p.Bcc);
});
// act
var success = await _target.TrySendEmailAsync(args);
// assert
Assert.Equal(args.To, to);
Assert.Equal(args.CC, cc);
Assert.Equal(args.Bcc, bcc);
}
public async Task <EmailMessageParams> GetAsync(EmailQueueToken token, CancellationToken cancellationToken)
{
_logger.LogTrace("Getting blob from store for token {0}", token);
if (!_initialized)
{
await InitializeAsync(cancellationToken);
}
var blobName = GetBlobName(token);
var blob = _container.Value.GetBlockBlobReference(blobName);
if (await blob.ExistsAsync())
{
var json = await blob.DownloadTextAsync(Encoding.UTF8, null, null, null, cancellationToken);
return(EmailMessageParams.FromJson(json));
}
return(null);
}
public async Task TrySendEmailAsync_ShouldReturnTrue_IfSuccess()
{
// arrange
var args = new EmailMessageParams
{
ApplicationId = _fixture.ApplicationId,
TemplateId = _fixture.TemplateId,
To = new List <string> {
"*****@*****.**"
},
Data = new Dictionary <string, object> {
{ "Name", "Someone" }
}
};
// act
var outcome = await _target.TrySendEmailAsync(args);
// assert
Assert.NotNull(outcome);
}
public async Task ProcessMessage_ShouldNot_LogMessageSent_IfBlobNotFound()
{
// arrange
var token = new CancellationToken();
var message = new TestMessage {
Token = EmailQueueToken.Create(Guid.NewGuid())
};
EmailMessageParams nullBlob = null;
_blobStore.Setup(b => b.GetAsync(message.Token, token)).ReturnsAsync(nullBlob);
// act
await _target.ProcessMessage(message, token);
// assert
_logWriter.Verify(t => t.TryLogSentMessageAsync(
It.IsAny <EmailQueueToken>(),
It.IsAny <SentEmailInfo>(),
token),
Times.Never());
}
public async Task TrySendEmailAsync_ShouldUseRawSubjectAndBody_IfNoTemplateIdAndNoDataProvided()
{
// arrange
var args = new EmailMessageParams
{
ApplicationId = _fixture.ApplicationId,
To = new List <string> {
"*****@*****.**"
},
Subject = "Hi Bob",
BodyEncoded = EmailMessageParams.EncodeBody("Hi Bob")
};
var template = await _fixture.Database.FindTemplateAsync(_fixture.TemplateId);
var expected = new EmailTemplate(args.Subject, args.Subject);
// act
var success = await _target.TrySendEmailAsync(args);
// assert
_transport.Verify(m => m.SendAsync(It.Is <SenderParams>(p =>
p.Subject == expected.Subject && p.Body == expected.Body)));
}
public void ToJson_ShouldSerializeComplexDataAsObject()
{
// arrange
var data = new Dictionary <string, object>
{
{ "Name", "Keith" },
{ "Roles", new string[] { "Developer", "Manager" } },
{ "Computer", new
{
Make = "Microsoft",
Model = "Surface Book"
} }
};
var expected = JsonConvert.SerializeObject(data, Formatting.None);
var target = new EmailMessageParams {
Data = data
};
// act
var actual = EmailMessageParams.ToJson(target, Formatting.None);
// assert
Assert.Contains(expected, actual);
}
public Task AddAsync(EmailQueueToken token, EmailMessageParams message, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
Blobs[token] = message;
return(Task.FromResult(0));
}
