/// <summary>
/// Run the activity.
/// It updates the export data.
/// </summary>
/// <param name="context">Durable orchestration context.</param>
/// <param name="exportDataEntity">export data entity.</param>
/// <param name="log">Logging service.</param>
/// <returns>instance of metadata.</returns>
public async Task RunAsync(
IDurableOrchestrationContext context,
ExportDataEntity exportDataEntity,
ILogger log)
{
await context.CallActivityWithRetryAsync <Task>(
nameof(UpdateExportDataActivity.UpdateExportDataActivityAsync),
ActivitySettings.CommonActivityRetryOptions,
exportDataEntity);
}
public async Task UpdateExportDataActivityAsyncNullArgumentTest()
{
// Arrange
var activityInstance = this.GetUpdateExportDataActivity();
ExportDataEntity exportDataEntity = new ExportDataEntity();
// Act
Func <Task> task = async() => await activityInstance.UpdateExportDataActivityAsync(null /*exportDataEntity*/);
// Assert
await task.Should().ThrowAsync <ArgumentNullException>("exportDataEntity is null");
}
public async Task RunActivity_NullParameters_ThrowsAgrumentNullException(
NotificationDataEntity notificationDataEntity,
ExportDataEntity exportDataEntity)
{
// Arrange
var activityInstance = this.GetMetadataActivity();
// Act
Func <Task> task = async() => await activityInstance.GetMetadataActivityAsync((notificationDataEntity, exportDataEntity));
// Assert
await task.Should().ThrowAsync <ArgumentNullException>();
}
public async Task HandleFailureActivityAsync(
[ActivityTrigger] ExportDataEntity exportDataEntity)
{
if (exportDataEntity == null)
{
throw new ArgumentNullException(nameof(exportDataEntity));
}
await this.DeleteFileAsync(exportDataEntity.FileName);
await this.SendFailureMessageAsync(exportDataEntity.PartitionKey);
await this.exportDataRepository.DeleteAsync(exportDataEntity);
}
public async Task UpdateExportDataActivity_RunAsyncNullArgumentTest()
{
// Arrange
var activityInstance = this.GetUpdateExportDataActivity();
ExportDataEntity exportDataEntity = new ExportDataEntity();
// Act
Func <Task> task1 = async() => await activityInstance.RunAsync(null /*context*/, It.IsAny <ExportDataEntity>(), log.Object);
Func <Task> task2 = async() => await activityInstance.RunAsync(context.Object, null /*exportDataEntity*/, log.Object);
// Assert
await task1.Should().ThrowAsync <ArgumentNullException>("context is null");
await task2.Should().ThrowAsync <ArgumentNullException>("exportDataEntity is null");
}
public async Task RunAsyncSuccessTest()
{
// Arrange
var activityInstance = GetUpdateExportDataActivity();
ExportDataEntity exportDataEntity = new ExportDataEntity();
context.Setup(x => x.CallActivityWithRetryAsync <Task>(It.IsAny <string>(), It.IsAny <RetryOptions>(), It.IsAny <ExportDataEntity>()));
// Act
Func <Task> task = async() => await activityInstance.RunAsync(context.Object, exportDataEntity, log.Object);
// Assert
await task.Should().NotThrowAsync();
context.Verify(x => x.CallActivityWithRetryAsync <Task>(It.Is <string>(x => x.Equals(nameof(UpdateExportDataActivity.UpdateExportDataActivityAsync))), It.IsAny <RetryOptions>(), It.IsAny <ExportDataEntity>()), Times.Once);
}
public async Task GetNotication_CorrectMapping_ReturnsSentNotificationObject()
{
// Arrange
var controller = this.GetControllerInstance();
string id = "invalidId";
var notificationEntity = this.GetNotification();
var groupList = new List <Group>()
{
new Group()
{
DisplayName = "group1"
}, new Group()
{
DisplayName = "group2"
}
};
var exportDataEntity = new ExportDataEntity();
this.notificationDataRepository.Setup(x => x.GetAsync(It.IsAny <string>(), It.IsAny <string>())).ReturnsAsync(notificationEntity);
this.groupsService.Setup(x => x.GetByIdsAsync(It.IsAny <IEnumerable <string> >())).Returns(groupList.ToAsyncEnumerable());
this.exportDataRepository.Setup(x => x.GetAsync(It.IsAny <string>(), It.IsAny <string>())).ReturnsAsync(exportDataEntity);
this.teamDataRepository.Setup(x => x.GetTeamNamesByIdsAsync(It.IsAny <IEnumerable <string> >())).ReturnsAsync(notificationEntity.Teams);
// Act
var result = await controller.GetSentNotificationByIdAsync(id);
var sentNotification = (SentNotification)((ObjectResult)result).Value;
// Assert
Assert.Equal(notificationEntity.Id, sentNotification.Id);
Assert.Equal(notificationEntity.Title, sentNotification.Title);
Assert.Equal(notificationEntity.ImageLink, sentNotification.ImageLink);
Assert.Equal(notificationEntity.Summary, sentNotification.Summary);
Assert.Equal(notificationEntity.Author, sentNotification.Author);
Assert.Equal(notificationEntity.ButtonTitle, sentNotification.ButtonTitle);
Assert.Equal(notificationEntity.ButtonLink, sentNotification.ButtonLink);
Assert.Equal(notificationEntity.SentDate, sentNotification.SentDate);
Assert.Equal(notificationEntity.CreatedDate, sentNotification.CreatedDateTime);
Assert.Equal(notificationEntity.Teams, sentNotification.TeamNames);
Assert.Equal(notificationEntity.Rosters, sentNotification.RosterNames);
Assert.Equal(notificationEntity.Groups, sentNotification.GroupNames);
Assert.Equal(notificationEntity.AllUsers, sentNotification.AllUsers);
Assert.Equal(notificationEntity.SendingStartedDate, sentNotification.SendingStartedDate);
Assert.Equal(notificationEntity.ErrorMessage, sentNotification.ErrorMessage);
Assert.Equal(notificationEntity.WarningMessage, sentNotification.WarningMessage);
}
public async Task UpdateExportDataActivityAsyncSuccessTest()
{
// Arrange
var activityInstance = GetUpdateExportDataActivity();
ExportDataEntity exportDataEntity = new ExportDataEntity()
{
FileConsentId = "fileConsentId"
};
exportDataRepository.Setup(x => x.CreateOrUpdateAsync(It.IsAny <ExportDataEntity>())).Returns(Task.CompletedTask);
// Act
Func <Task> task = async() => await activityInstance.UpdateExportDataActivityAsync(exportDataEntity);
// Assert
await task.Should().NotThrowAsync();
exportDataRepository.Verify(x => x.CreateOrUpdateAsync(It.Is <ExportDataEntity>(x => x.FileConsentId == exportDataEntity.FileConsentId)), Times.Once);
}
/// <summary>
/// Run the activity.
/// It updates the export data.
/// </summary>
/// <param name="context">Durable orchestration context.</param>
/// <param name="exportDataEntity">Export data entity.</param>
/// <param name="log">Logging service.</param>
/// <returns>Instance of metadata.</returns>
public async Task RunAsync(
IDurableOrchestrationContext context,
ExportDataEntity exportDataEntity,
ILogger log)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (exportDataEntity == null)
{
throw new ArgumentNullException(nameof(exportDataEntity));
}
await context.CallActivityWithRetryAsync <Task>(
nameof(UpdateExportDataActivity.UpdateExportDataActivityAsync),
FunctionSettings.DefaultRetryOptions,
exportDataEntity);
}
public async Task Export_InvalidData_ShouldInvokeNever()
{
// Arrange
var activityInstance = this.GetExportFunction();
string messageContent = "{\"NotificationId\":\"notificationId\",\"UserId\" : \"userId\"}";
var exportDataEntity = new ExportDataEntity();
this.notificationDataRepository
.Setup(x => x.GetAsync(It.IsAny <string>(), It.IsAny <string>()))
.Returns(Task.FromResult(default(NotificationDataEntity)));
this.exportDataRepository
.Setup(x => x.GetAsync(It.IsAny <string>(), It.IsAny <string>()))
.ReturnsAsync(exportDataEntity);
this.starter.Setup(x => x.StartNewAsync(It.IsAny <string>(), It.IsAny <string>())).ReturnsAsync(It.IsAny <string>());
// Act
await activityInstance.Run(messageContent, this.starter.Object, this.logger.Object);
// Assert
this.starter.Verify(x => x.StartNewAsync(It.Is <string>(x => x.Equals(FunctionNames.ExportOrchestration)), It.IsAny <ExportDataRequirement>()), Times.Never());
}
public async Task ExportNotification_validInput_ReturnsStatusCodeOk()
{
// Arrange
var controller = this.GetControllerInstance();
var userDataEntity = new UserDataEntity();
var exportRequest = new ExportRequest()
{
Id = "Id"
};
var statusCodeOk = 200;
var exportDataEntity = new ExportDataEntity()
{
RowKey = exportRequest.Id,
SentDate = DateTime.UtcNow,
Status = ExportStatus.New.ToString(),
};
var userDataList = new List <UserDataEntity>()
{
new UserDataEntity()
{
AadId = null
}
};
this.userDataRepository.Setup(x => x.GetAsync(It.IsAny <string>(), It.IsAny <string>())).ReturnsAsync(userDataEntity);
this.sentNotificationDataRepository.Setup(x => x.EnsureSentNotificationDataTableExistsAsync()).Returns(Task.CompletedTask);
this.exportDataRepository.Setup(x => x.EnsureExportDataTableExistsAsync()).Returns(Task.CompletedTask);
this.exportDataRepository.Setup(x => x.GetAsync(It.IsAny <string>(), It.IsAny <string>())).Returns(Task.FromResult(default(ExportDataEntity)));
this.exportDataRepository.Setup(x => x.CreateOrUpdateAsync(It.IsAny <ExportDataEntity>())).Returns(Task.CompletedTask);
this.exportQueue.Setup(x => x.SendAsync(It.IsAny <ExportQueueMessageContent>())).Returns(Task.CompletedTask);
// Act
var result = await controller.ExportNotificationAsync(exportRequest);
var statusCode = ((StatusCodeResult)result).StatusCode;
// Assert
Assert.Equal(statusCode, statusCodeOk);
}
public async Task ExportNotification_NotificationExistsInAzureStorage_ReturnsStatusCodeConflict()
{
// Arrange
var controller = this.GetControllerInstance();
var userDataEntity = new UserDataEntity();
var exportRequest = new ExportRequest();
var exportDataEntity = new ExportDataEntity();
var statusCodeConfict = 409;
this.userDataRepository.Setup(x => x.GetAsync(It.IsAny <string>(), It.IsAny <string>())).ReturnsAsync(userDataEntity);
this.sentNotificationDataRepository.Setup(x => x.EnsureSentNotificationDataTableExistsAsync()).Returns(Task.CompletedTask);
this.exportDataRepository.Setup(x => x.EnsureExportDataTableExistsAsync()).Returns(Task.CompletedTask);
this.exportDataRepository.Setup(x => x.GetAsync(It.IsAny <string>(), It.IsAny <string>())).ReturnsAsync(exportDataEntity);
// Act
var result = await controller.ExportNotificationAsync(exportRequest);
var statusCode = ((StatusCodeResult)result).StatusCode;
// Assert
Assert.Equal(statusCode, statusCodeConfict);
}
public async Task GetNotication_ValidIdParam_ReturnsOkResult()
{
// Arrange
var controller = this.GetControllerInstance();
string id = "invalidId";
var notificationDataEntity = this.GetNotification();
var groupList = new List <Group>()
{
new Group()
};
var exportDataEntity = new ExportDataEntity();
this.notificationDataRepository.Setup(x => x.GetAsync(It.IsAny <string>(), It.IsAny <string>())).ReturnsAsync(notificationDataEntity);
this.groupsService.Setup(x => x.GetByIdsAsync(It.IsAny <IEnumerable <string> >())).Returns(groupList.ToAsyncEnumerable());
this.exportDataRepository.Setup(x => x.GetAsync(It.IsAny <string>(), It.IsAny <string>())).ReturnsAsync(exportDataEntity);
this.teamDataRepository.Setup(x => x.GetTeamNamesByIdsAsync(It.IsAny <IEnumerable <string> >())).ReturnsAsync(notificationDataEntity.Teams);
// Act
var result = await controller.GetSentNotificationByIdAsync(id);
// Assert
Assert.IsType <OkObjectResult>(result);
}
public async Task Delete_ValidFile_DeleteIfExistsAsyncShouldNeveOnce()
{
// Arrange
var activityInstance = this.GetHandleExportFailureActivity();
var exportDataEntity = new ExportDataEntity()
{
FileName = "fileName", PartitionKey = "partitionKey"
};
var userDataEntity = new UserDataEntity()
{
ServiceUrl = "serviceUrl", ConversationId = "conversationId"
};
var blobContainerClientmock = GetBlobContainerClientMock();
this.storageClientFactory.Setup(x => x.CreateBlobContainerClient()).Returns(blobContainerClientmock.Object);
this.userDataRepository.Setup(x => x.GetAsync(It.IsAny <string>(), It.IsAny <string>())).ReturnsAsync(userDataEntity);
// Act
await activityInstance.HandleFailureActivityAsync(exportDataEntity);
// Assert
blobContainerClientmock.Verify(x => x.GetBlobClient(It.IsAny <string>()).DeleteIfExistsAsync(It.IsAny <DeleteSnapshotsOption>(), It.IsAny <BlobRequestConditions>(), It.IsAny <CancellationToken>()), Times.Once);
}
public async Task UpdateExportDataActivityAsync(
[ActivityTrigger] ExportDataEntity exportDataEntity)
{
await this.exportDataRepository.CreateOrUpdateAsync(exportDataEntity);
}
