public async Task GetDocumentLibraries_Returns_DocumentLibraries_When_Found()
{
// Arrange
var req = TestFactory.CreateHttpRequest();
var logger = TestFactory.CreateLogger(LoggerTypes.List);
var documentLibraries = new List <DocumentLibrary>
{
new DocumentLibrary {
Id = "Id1", Name = "DocumentLibrary1"
},
new DocumentLibrary {
Id = "Id2", Name = "DocumentLibrary2"
},
};
_fileServiceMock.Setup(x => x.GetDocumentLibrariesAsync(It.Is <string>(p => p == "siteId"))).ReturnsAsync(DocumentLibrariesResult.Success(documentLibraries));
// Act
var httpActionResult = await _controller.GetDocumentLibraries(req, logger);
// Assert
Assert.IsInstanceOf(typeof(OkObjectResult), httpActionResult);
_fileServiceMock.Verify(x => x.GetDocumentLibrariesAsync(It.Is <string>(p => p == "siteId")), Times.Once);
var result = ((OkObjectResult)httpActionResult).Value as DocumentLibraryModelInfo[];
Assert.IsNotNull(result);
Assert.AreEqual(2, result.Length);
Assert.AreEqual("Id1", result[0].Id);
Assert.AreEqual("DocumentLibrary1", result[0].Name);
Assert.AreEqual("Id2", result[1].Id);
Assert.AreEqual("DocumentLibrary2", result[1].Name);
}
public async Task Run_WithValidRequest_ReturnsCurrentStatus()
{
// arrange
var req = new DefaultHttpRequest(new DefaultHttpContext());
var logger = TestFactory.CreateLogger(LoggerTypes.List);
var now = DateTime.UtcNow;
DocumentDetails documentDetails = new DocumentDetails
{
Id = Guid.NewGuid(),
Body = "doc123.txt",
CreatedOn = now,
Status =
{
new DocumentStatus
{
Status = "ERROR",
Detail = "processing error",
CreatedOn = now.AddMinutes(10)
}
}
};
// act
var result = await DocumentStatusRequest.Run(req, documentDetails.Id.ToString(), documentDetails, logger);
// assert
result.Should().BeOfType <OkObjectResult>();
var documentStatusResponse = (DocumentStatusResponse)((OkObjectResult)result).Value;
documentStatusResponse.CreatedOn.Should().Be(now);
documentStatusResponse.Status.Should().Be("ERROR");
documentStatusResponse.UpdatedOn.Should().Be(now.AddMinutes(10));
}
public async void function_http_trigger_should_return_401_if_SonarqubeSecretValidator_rejects_request()
{
// Arrange
SetEnvironmentVariables();
var request = TestFactory.CreateHttpRequest();
var sonarqubeSecretValidator = new Mock <ISonarqubeSecretValidator>();
sonarqubeSecretValidator.Setup(x => x.IsValidSignature(
request,
It.IsAny <string>(),
Environment.GetEnvironmentVariable(SonarqubeMSTeamsBridge.Setting_SonarqubeWebhookSecret))
).Returns(false);
var sonarqubeMSTeamsBridgeFunction = new SonarqubeMSTeamsBridge(null, sonarqubeSecretValidator.Object, null, null);
ListLogger logger = (ListLogger)TestFactory.CreateLogger(LoggerTypes.List);
// Act
var response = (StatusCodeResult)await sonarqubeMSTeamsBridgeFunction.Run(request, logger);
// Assert
Assert.Equal(401, response.StatusCode);
Assert.Contains($"Sonarqube secret http header is missing or not valid. Config setting {SonarqubeMSTeamsBridge.Setting_SonarqubeWebhookSecret} must match secret in Sonarqube Webhook header {SonarqubeSecretValidator.SonarqubeAuthSignatureHeaderName}.", logger.Logs);
}
public async Task GetFiles_Returns_Files_When_Found()
{
// Arrange
var req = TestFactory.CreateHttpRequest();
var logger = TestFactory.CreateLogger(LoggerTypes.List);
var documentLibraryId = "documentLibraryId1";
var files = new List <File>
{
new File
{
Id = "Id1",
Name = "FileName1",
Description = "FileDescription1",
CreatedAt = new DateTimeOffset(new DateTime(2020, 3, 4)),
LastModifiedAt = new DateTimeOffset(new DateTime(2020, 3, 4)),
DownloadUrl = "https://downloadurl1",
Size = 250L
},
new File
{
Id = "Id2",
Name = "FileName2",
Description = "FileDescription2",
CreatedAt = new DateTimeOffset(new DateTime(2020, 3, 5)),
LastModifiedAt = new DateTimeOffset(new DateTime(2020, 3, 5)),
DownloadUrl = "https://downloadurl2",
Size = 500L
}
};
_fileServiceMock.Setup(x => x.GetFilesAsync(It.Is <string>(p => p == "siteId"), It.Is <string>(p => p == documentLibraryId))).ReturnsAsync(FilesResult.Success(files));
// Act
var httpActionResult = await _controller.GetFiles(req, documentLibraryId, logger);
// Assert
Assert.IsInstanceOf(typeof(OkObjectResult), httpActionResult);
_fileServiceMock.Verify(x => x.GetFilesAsync(It.Is <string>(p => p == "siteId"), It.Is <string>(p => p == documentLibraryId)), Times.Once);
var result = ((OkObjectResult)httpActionResult).Value as FileModelInfo[];
Assert.IsNotNull(result);
Assert.AreEqual(2, result.Length);
Assert.AreEqual("Id1", result[0].Id);
Assert.AreEqual("FileName1", result[0].Name);
Assert.AreEqual("FileDescription1", result[0].Description);
Assert.AreEqual(new DateTime(2020, 3, 4), result[0].CreatedAt);
Assert.AreEqual(new DateTime(2020, 3, 4), result[0].LastModifiedAt);
Assert.AreEqual("https://downloadurl1", result[0].DownloadUrl);
Assert.AreEqual(250L, result[0].Size);
Assert.AreEqual("Id2", result[1].Id);
Assert.AreEqual("FileName2", result[1].Name);
Assert.AreEqual("FileDescription2", result[1].Description);
Assert.AreEqual(new DateTime(2020, 3, 5), result[1].CreatedAt);
Assert.AreEqual(new DateTime(2020, 3, 5), result[1].LastModifiedAt);
Assert.AreEqual("https://downloadurl2", result[1].DownloadUrl);
Assert.AreEqual(500L, result[1].Size);
}
public async Task EmailStatusServiceMustKeepTheProviderIfItDidnotReachThreshold()
{
var emailProviderlogger = (ListLogger <FakeProviderService>)TestFactory.CreateLogger <FakeProviderService>(LoggerTypes.List);
var functionLogger = (ListLogger <EmailService>)TestFactory.CreateLogger <EmailService>(LoggerTypes.List);
var emailStatusLogger = (ListLogger <EmailProvidersStatus>)TestFactory.CreateLogger <EmailProvidersStatus>(LoggerTypes.List);
var emailProvider = TestFactory.CreateFakeEmailProvider(emailProviderlogger);
var serviceCollection = new ServiceCollection();
serviceCollection.AddSingleton <IEmailProvider>(emailProvider);
var options = Options.Create(new ConfigOptions()
{
Sentry = new Config.SentryOptions(),
EmailProviders = new EmailProviders {
SendGrid = new Config.SendGrid {
ApiKey = ""
}
},
EmailProvidersSettings = new EmailProvidersSettings
{
SupportedProviders = new List <string> {
"Fake", "Fake2"
},
Threshold = 5,
DisablePeriod = 10,
TimeWindowInSeconds = 5
}
});
var durableClient = new Mock <IDurableEntityClient>();
var emailproviderstatus = new EmailProvidersStatus(options, emailStatusLogger);
Assert.Equal(2, emailproviderstatus.emailProviders.Count);
durableClient.Setup(x => x.ReadEntityStateAsync <EmailProvidersStatus>(It.IsAny <EntityId>(), null, null))
.Returns(Task.FromResult(new EntityStateResponse <EmailProvidersStatus>
{
EntityExists = true,
EntityState = emailproviderstatus
}));
durableClient.Setup(x => x.SignalEntityAsync(It.IsAny <EntityId>(), "AddFailure", It.IsAny <FailureRequest>(), null, null))
.Callback((EntityId entityId, string operation, object body, string x, string y) => {
var ob = body as FailureRequest;
emailproviderstatus.AddFailure(ob);
})
.Returns(Task.CompletedTask);
var emailServiceFunction = new EmailService(emailProvider, functionLogger, serviceCollection.BuildServiceProvider(), options);
await emailServiceFunction.RunAsync(new Models.EmailQueueItem {
Sender = "*****@*****.**", Receiver = "*****@*****.**", Subject = "Subject", Body = "MyText"
}, durableClient.Object);
// Fake should be disabled
Assert.Single(emailproviderstatus.FailureWindow[emailproviderstatus.emailProviders.First()]);
Assert.Empty(emailproviderstatus.disabledProviders);
Assert.Equal(2, emailproviderstatus.emailProviders.Count);
}
protected void MockerSetup()
{
_mocker = AutoMock.GetLoose();
MockerAdditionalSetupBeforeSutCreation();
_sut = _mocker.Create <T>();
_logger = (LoggerFake)TestFactory.CreateLogger(LoggerTypes.List);
_timerInfo = new TimerInfo(new ScheduleStub(), new ScheduleStatus(), true);
}
public void LogAMessage()
{
var logger = (ListLogger)TestFactory.CreateLogger(LoggerTypes.List);
DefaultTimerTemplate.Run(null, logger);
var msg = logger.Logs[0];
Assert.Contains("C# Timer trigger function executed at", msg);
}
private static HttpRequestMessage CreateRequest(out ILogger logger, TelegramUpdate requestPayload)
{
var request = TestFactory.CreateHttpRequest(HttpMethod.Post, "");
logger = TestFactory.CreateLogger();
;
request.Content = new ObjectContent <TelegramUpdate>(requestPayload, new JsonMediaTypeFormatter());
return(request);
}
public async Task GetMatchingBallotsForPattern_BadRequestWhenNoPattern()
{
var request = TestFactory.CreateHttpRequest();
var logger = TestFactory.CreateLogger();
var svc = TestFactory.CreateElectionResultsService();
var response = (BadRequestObjectResult)await new BallotLookup(svc.Object).GetMatchingBallotsForPattern(request, null, logger);
Assert.IsNotNull(response);
Assert.AreEqual((int)HttpStatusCode.BadRequest, response.StatusCode);
}
public async Task ImportResultsOnBlobUpdate_ImportsData()
{
var fn = "somefilename.ext";
var stream = Stream.Null;
var logger = (ListLogger)TestFactory.CreateLogger(LoggerTypes.List);
var svc = TestFactory.CreateElectionResultsService();
await new ElectionDataManagement(svc.Object).ImportResultsOnBlobUpdate(stream, fn, logger);
svc.Verify(m => m.ImportElectionResults(stream), Times.Once);
}
public async Task GetElectionSummary_ReturnDefaultSummary()
{
var request = TestFactory.CreateHttpRequest();
var logger = TestFactory.CreateLogger();
var svc = TestFactory.CreateElectionResultsService();
var response = (JsonResult)await new Functions.Api.ElectionSummary(svc.Object).GetElectionSummary(request, logger);
var summary = response.Value as Models.ElectionSummary;
Assert.IsNotNull(summary);
Assert.IsFalse(summary.IsComplete);
}
public async void DarioBotCanHandleBadFormatRequest(string darioRequest, HttpStatusCode expectedStatus)
{
var request = TestFactory.CreateHttpRequest(HttpMethod.Post, "");
var logger = TestFactory.CreateLogger();
request.Content = new StringContent(darioRequest);
var response = await HappyDarioBot.HappyDarioBot.Run(request, logger);
Assert.Equal(expectedStatus, response.StatusCode);
}
public async Task Run_WithDocumentNotFound_ReturnsBadRequest()
{
// arrange
var req = new DefaultHttpRequest(new DefaultHttpContext());
var logger = TestFactory.CreateLogger(LoggerTypes.List);
// act
var result = await DocumentStatusRequest.Run(req, Guid.NewGuid().ToString(), null, logger);
// assert
result.Should().BeOfType <BadRequestObjectResult>();
}
public async Task GetMatchingBallotsForPattern_ReturnsEmptyList()
{
var pattern = "dance";
var request = TestFactory.CreateHttpRequest("pattern", pattern);
var logger = TestFactory.CreateLogger();
var svc = TestFactory.CreateElectionResultsService();
var response = (JsonResult)await new BallotLookup(svc.Object).GetMatchingBallotsForPattern(request, pattern, logger);
var list = response?.Value as List <BallotStatus>;
Assert.IsNotNull(list);
Assert.AreEqual(0, list.Count);
}
public async Task NewCogntiveReq_http_trigger_return_successful_exection()
{
var function = new NewCognitiveReq(
TestFactory.CreateCognitiveFilesRepositoryMock(),
TestFactory.CreateUserAccountsRepositoryMock(),
TestFactory.CreateStorageRepositoryMock(),
TestFactory.CreateQueueRepositoryMock());
var result = await function.Run(TestFactory.GetMultipartRequest(0), TestFactory.CreateLogger(LoggerTypes.List));
Assert.True(result is CreatedResult);
}
public void GetNegativeMessage_should_log_message()
{
// Arrange
var logger = (ListLogger)TestFactory.CreateLogger(LoggerTypes.List);
MessageFunction messageFunction = new MessageFunction(_messageResponderServer.Object);
// Act
messageFunction.GetNegativeMessage(null, logger);
// Assert
var msg = logger.Logs[0];
msg.Should().Contain("MessageFunction - C# HTTP trigger function processed a request for GetNegativeMessage.");
}
public async Task Timer_should_log_message()
{
var genericComponentsImportService = new Mock <IGenericComponentsImportService>();
genericComponentsImportService.Setup(x => x.SaveGenericNoiseComponents()).Returns(Task.FromResult((true, true)));
Application.Function function = new Application.Function(genericComponentsImportService.Object);
var loggerMocked = (ListLogger)TestFactory.CreateLogger(LoggerTypes.List);
await function.Run(null, loggerMocked);
var msg = loggerMocked.Logs[0];
Assert.Contains("C# Timer trigger function executed at", msg);
}
public async Task DownloadMultiple_Returns_BadRequest_When_DriveItemIdIsNull()
{
// Arrange
var documentLibraryId = SettingsHelper.DocumentLibraryId;
var body = "{\"driveItems\": [null]}";
var reqMock = TestFactory.CreateHttpRequestMock(body);
var logger = TestFactory.CreateLogger(LoggerTypes.List);
// Act
var httpActionResult = await _sut.DownloadMultiple(reqMock.Object, documentLibraryId, logger);
// Assert
Assert.IsInstanceOf(typeof(BadRequestObjectResult), httpActionResult);
}
public async Task Download_Returns_BadRequest_When_DriveItemIdIsNull()
{
// Arrange
var documentLibraryId = SettingsHelper.DocumentLibraryId;
var req = TestFactory.CreateHttpRequest();
var logger = TestFactory.CreateLogger(LoggerTypes.List);
// Act
var httpActionResult = await _sut.Download(req, documentLibraryId, null, logger);
// Assert
Assert.IsInstanceOf(typeof(BadRequestObjectResult), httpActionResult);
}
public async Task ImportResultsOnBlobUpdate_LogsImport()
{
var fn = "somefilename.ext";
var stream = Stream.Null;
var logger = (ListLogger)TestFactory.CreateLogger(LoggerTypes.List);
var svc = TestFactory.CreateElectionResultsService();
await new ElectionDataManagement(svc.Object).ImportResultsOnBlobUpdate(stream, fn, logger);
Assert.AreEqual(1, logger.Logs.Count);
var msg = logger.Logs[0];
Assert.IsTrue(msg.Contains("ImportElectionResults:"));
Assert.IsTrue(msg.Contains(fn));
}
public async Task DownloadMultiple_Returns_BadRequest_When_DriveItemIdIsEmpty()
{
// Arrange
var documentLibraryId = "DL1";
var body = "{\"driveItems\": [\"\"]}";
var reqMock = TestFactory.CreateHttpRequestMock(body);
var logger = TestFactory.CreateLogger(LoggerTypes.List);
// Act
var httpActionResult = await _controller.DownloadMultiple(reqMock.Object, documentLibraryId, logger);
// Assert
_fileServiceMock.Verify(x => x.DownloadAsync(It.Is <string>(p => p == "siteId"), It.Is <string>(p => p == documentLibraryId), It.IsAny <string>()), Times.Never);
Assert.IsInstanceOf(typeof(BadRequestObjectResult), httpActionResult);
}
public async Task Download_Returns_BadRequest_When_DriveItemIdIsEmpty()
{
// Arrange
var documentLibraryId = "b!Uh445jcGFkK0-jWspn-lx74bPae4-DJEiIWsqKfPgGyQV63S1iPeRIZxnI5dGymZ";
var driveItemId = string.Empty;
var req = TestFactory.CreateHttpRequest();
var logger = TestFactory.CreateLogger(LoggerTypes.List);
// Act
var httpActionResult = await _controller.Download(req, documentLibraryId, driveItemId, logger);
// Assert
_fileServiceMock.Verify(x => x.DownloadAsync(It.Is <string>(p => p == "siteId"), It.Is <string>(p => p == documentLibraryId), It.Is <string>(p => p == driveItemId)), Times.Never);
Assert.IsInstanceOf(typeof(BadRequestObjectResult), httpActionResult);
}
public async Task Download_Returns_BadRequest_When_DocumentLibraryIdIsEmpty()
{
// Arrange
var documentLibraryId = string.Empty;
var driveItemId = "01FG5K4LMYZK6PXIJOOFG3LDYWNPSSFMLR";
var req = TestFactory.CreateHttpRequest();
var logger = TestFactory.CreateLogger(LoggerTypes.List);
// Act
var httpActionResult = await _controller.Download(req, documentLibraryId, driveItemId, logger);
// Assert
_fileServiceMock.Verify(x => x.DownloadAsync(It.Is <string>(p => p == "siteId"), It.Is <string>(p => p == documentLibraryId), It.Is <string>(p => p == driveItemId)), Times.Never);
Assert.IsInstanceOf(typeof(BadRequestObjectResult), httpActionResult);
}
public async void function_http_trigger_should_return_500_if_teamswebhook_config_is_missing()
{
// Arrange
SetEnvironmentVariables(teamsWebhookUrl: null);
var request = TestFactory.CreateHttpRequest();
var sonarqubeMSTeamsBridgeFunction = new SonarqubeMSTeamsBridge(null, null, null, null);
ListLogger logger = (ListLogger)TestFactory.CreateLogger(LoggerTypes.List);
// Act
var response = (StatusCodeResult)await sonarqubeMSTeamsBridgeFunction.Run(request, logger);
// Assert
Assert.Equal(500, response.StatusCode);
Assert.Contains($"Required setting {SonarqubeMSTeamsBridge.Setting_TeamsWebhookUrl} is missing.", logger.Logs);
}
public async Task Run_WithNoBodyInRequest_ReturnsBadRequest()
{
// arrange
var req = new DefaultHttpRequest(new DefaultHttpContext());
var logger = TestFactory.CreateLogger(LoggerTypes.List);
DocumentDetails documentDetails = null;
_documentDetailsCollector.Setup(x => x.AddAsync(It.IsAny <DocumentDetails>(), default(CancellationToken)))
.Callback((DocumentDetails details, CancellationToken token) => documentDetails = details);
// act
var result = await DocumentRequest.Run(req, _documentDetailsCollector.Object, logger);
// assert
result.Should().BeOfType <BadRequestObjectResult>();
}
public async Task EmailServiceTriggerFunctionMustNotProcessEmptyQueueItem()
{
var emailProviderlogger = (ListLogger <FakeProviderService>)TestFactory.CreateLogger <FakeProviderService>(LoggerTypes.List);
var functionLogger = (ListLogger <EmailService>)TestFactory.CreateLogger <EmailService>(LoggerTypes.List);
var emailProvider = TestFactory.CreateFakeEmailProvider(emailProviderlogger);
var serviceCollection = new ServiceCollection();
serviceCollection.AddSingleton <IEmailProvider>(emailProvider);
var durableClient = new Mock <IDurableEntityClient>();
durableClient.Setup(x => x.ReadEntityStateAsync <EmailProvidersStatus>(It.IsAny <EntityId>(), null, null))
.Returns(Task.FromResult(new EntityStateResponse <EmailProvidersStatus>
{
EntityExists = false,
EntityState = null
}));
var options = Options.Create(new ConfigOptions()
{
Sentry = new SentryOptions(),
EmailProviders = new EmailProviders {
SendGrid = new Config.SendGrid {
ApiKey = ""
}
},
EmailProvidersSettings = new EmailProvidersSettings {
SupportedProviders = new List <string> {
"Fake"
}
}
});
var emailServiceFunction = new EmailService(emailProvider, functionLogger, serviceCollection.BuildServiceProvider(), options);
await emailServiceFunction.RunAsync(new Models.EmailQueueItem {
}, durableClient.Object);
var msg = functionLogger.Logs[0];
Assert.Contains("'Sender' must not be empty", msg);
Assert.Contains("'Receiver' must not be empty.", msg);
Assert.Contains("'Subject' must not be empty", msg);
Assert.Contains("'Body' must not be empty", msg);
}
public async Task Download_Returns_File_When_Found()
{
// Arrange
var documentLibraryId = "b!Uh445jcGFkK0-jWspn-lx74bPae4-DJEiIWsqKfPgGyQV63S1iPeRIZxnI5dGymZ";
var driveItemId = "01FG5K4LMYZK6PXIJOOFG3LDYWNPSSFMLR";
var req = TestFactory.CreateHttpRequest();
var logger = TestFactory.CreateLogger(LoggerTypes.List);
_fileServiceMock.Setup(x => x.DownloadAsync(It.Is <string>(p => p == "siteId"), It.Is <string>(x => x == documentLibraryId), It.Is <string>(x => x == driveItemId))).ReturnsAsync(DownloadResult.Success(driveItemId, "MyDocument.docx", new byte[] { 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20 }));
// Act
var httpActionResult = await _controller.Download(req, documentLibraryId, driveItemId, logger);
// Assert
_fileServiceMock.Verify(x => x.DownloadAsync(It.Is <string>(p => p == "siteId"), It.Is <string>(x => x == documentLibraryId), It.Is <string>(x => x == driveItemId)), Times.Once);
Assert.IsInstanceOf(typeof(FileContentResult), httpActionResult);
}
public async Task Run_DbSaveError_ReturnsStatus500InternalServerError()
{
// arrange
var requestBody = "doc123.txt";
var req = TestFactory.CreateHttpRequest($"{{\"body\": \"{requestBody}\"}}");
var logger = TestFactory.CreateLogger(LoggerTypes.List);
_documentDetailsCollector.Setup(x => x.AddAsync(It.IsAny <DocumentDetails>(), default(CancellationToken)))
.Throws(new Exception("Error calling Cosmos DB"));
// act
var result = await DocumentRequest.Run(req, _documentDetailsCollector.Object, logger);
// assert
result.Should().BeOfType <StatusCodeResult>();
var statusCode = ((StatusCodeResult)result).StatusCode;
statusCode.Should().Be(500);
}
public async Task DownloadMultiple_Returns_Files_When_Found()
{
// Arrange
var documentLibraryId = "DL1";
var body = "{\"driveItems\": [\"DI1\", \"DI2\"]}";
var reqMock = TestFactory.CreateHttpRequestMock(body);
var logger = TestFactory.CreateLogger(LoggerTypes.List);
_fileServiceMock.Setup(x => x.DownloadAsync(It.Is <string>(p => p == "siteId"), It.Is <string>(x => x == documentLibraryId), It.Is <string>(x => x == "DI1"))).ReturnsAsync(DownloadResult.Success("DI1", "File1.docx", new byte[] { 0x01, 0x01, 0x01 }));
_fileServiceMock.Setup(x => x.DownloadAsync(It.Is <string>(p => p == "siteId"), It.Is <string>(x => x == documentLibraryId), It.Is <string>(x => x == "DI2"))).ReturnsAsync(DownloadResult.Success("DI2", "File2.docx", new byte[] { 0x02, 0x02, 0x02 }));
// Act
var httpActionResult = await _controller.DownloadMultiple(reqMock.Object, documentLibraryId, logger);
// Assert
_fileServiceMock.Verify(x => x.DownloadAsync(It.Is <string>(p => p == "siteId"), It.Is <string>(x => x == documentLibraryId), It.Is <string>(x => x == "DI1")), Times.Once);
_fileServiceMock.Verify(x => x.DownloadAsync(It.Is <string>(p => p == "siteId"), It.Is <string>(x => x == documentLibraryId), It.Is <string>(x => x == "DI2")), Times.Once);
Assert.IsInstanceOf(typeof(FileContentResult), httpActionResult);
}
public async Task GetDocumentLibraries_Returns_BadRequestObjectResult_When_AnErrorOccurred()
{
// Arrange
var req = TestFactory.CreateHttpRequest();
var logger = TestFactory.CreateLogger(LoggerTypes.List);
_fileServiceMock.Setup(x => x.GetDocumentLibrariesAsync(It.Is <string>(p => p == "siteId"))).ReturnsAsync(DocumentLibrariesResult.Failed("An error occurred."));
// Act
var httpActionResult = await _controller.GetDocumentLibraries(req, logger);
// Assert
Assert.IsInstanceOf(typeof(BadRequestObjectResult), httpActionResult);
_fileServiceMock.Verify(x => x.GetDocumentLibrariesAsync(It.Is <string>(p => p == "siteId")), Times.Once);
var result = ((BadRequestObjectResult)httpActionResult);
Assert.IsNotNull(result);
Assert.AreEqual("An error occurred.", result.Value);
}
