public async Task WithSuccess()
{
// arrange
Mock <ILogger> mockLogger = new Mock <ILogger>();
var mockRequest = Mockers.MockRequest(null);
mockRequest.Setup(x => x.Host).Returns(new HostString("test"));
var sut = HealthMockers.GetApiFunctions(
out Mock <IUserAuthenticationService> mockUserAuthenticationService,
out Mock <IHealthService> mockHealthService);
mockHealthService.Setup(x => x.HealthCheck()).ReturnsAsync(new List <HealthCheckResponse>()
{
new HealthCheckResponse()
{
Application = "Ali",
Status = HealthCheckStatus.OK,
},
new HealthCheckResponse()
{
Application = "Baba",
Status = HealthCheckStatus.OK,
},
});
// act
await sut.SystemHealthCheck(mockRequest.Object, mockLogger.Object).ConfigureAwait(false);
// assert
mockHealthService.Verify(x => x.HealthCheck(), Times.Once);
}
public async Task WithMissingUserIdReturnsBadRequest()
{
// arrange
var mockUserAuth = Mockers.MockUserAuth();
string userId;
IActionResult actionResult = new BadRequestObjectResult(new { error = "Error." });
mockUserAuth.Setup(m => m.GetUserIdAsync(It.IsAny <HttpRequest>(), out userId, out actionResult))
.Returns(Task.FromResult(false));
var fakeRepository = new FakeBlobRepository();
Mock <HttpRequest> mockRequest = Mockers.MockRequest(null);
Mock <ILogger> mockLogger = new Mock <ILogger>();
var sut = new Functions(
mockUserAuth.Object,
fakeRepository);
// act
var response = await sut.AddBegin(mockRequest.Object, mockLogger.Object).ConfigureAwait(false);
var objectResult = (BadRequestObjectResult)response;
var addResponse = (dynamic)objectResult.Value;
// assert
Assert.AreEqual("Error.", addResponse.error);
}
public async Task WithMissingUserIdReturnsBadRequest()
{
// arrange
string userId;
var fakeRepository = new FakeBlobRepository();
Mock <ILogger> mockLogger = new Mock <ILogger>();
var mockRequest = Mockers.MockRequest(null);
var sut = AudioMockers.GetApiFunctionsWithBlobUploaded(
out Mock <IUserAuthenticationService> mockUserAuth,
out FakeBlobRepository fakeBlobRepo,
out Mock <IEventGridPublisherService> mockEventGridPublisherService);
IActionResult actionResult = new BadRequestObjectResult(new { error = "Error." });
mockUserAuth.Setup(m => m.GetUserIdAsync(It.IsAny <HttpRequest>(), out userId, out actionResult))
.Returns(Task.FromResult(false));
// act
var response = await sut.Get(mockRequest.Object, mockLogger.Object, Mockers.DefaultId).ConfigureAwait(false);
var objectResult = (BadRequestObjectResult)response;
var addResponse = (dynamic)objectResult.Value;
// assert
Assert.AreEqual("Error.", addResponse.error);
}
public async Task WithMissingUserIdReturnsBadRequest()
{
// arrange
string userId;
Mock <ILogger> mockLogger = new Mock <ILogger>();
var mockRequest = Mockers.MockRequest(null);
mockRequest.Setup(x => x.Host).Returns(new HostString("test"));
var sut = HealthMockers.GetApiFunctions(
out Mock <IUserAuthenticationService> mockUserAuth,
out Mock <IHealthService> mockHealthService);
IActionResult actionResult = new BadRequestObjectResult(new { error = "Error." });
mockUserAuth.Setup(m => m.GetUserIdAsync(It.IsAny <HttpRequest>(), out userId, out actionResult))
.Returns(Task.FromResult(false));
// act
var response = await sut.HealthCheck(mockRequest.Object, mockLogger.Object).ConfigureAwait(false);
var objectResult = (BadRequestObjectResult)response;
var addResponse = (dynamic)objectResult.Value;
// assert
Assert.AreEqual("Error.", addResponse.error);
}
/// <summary>
/// Gets a mocked audio add complete request.
/// </summary>
/// <returns>Mock http request with an audio add complete request in the body.</returns>
public static Mock <HttpRequest> GetMockAddCompleteRequest()
{
var requestBody = new Api.AddCompleteRequest()
{
CategoryId = Mockers.DefaultCategoryName,
};
return(Mockers.MockRequest(requestBody));
}
/// <summary>
/// Gets an audio operations class with a blob uploaded to the mock
/// blob repository.
/// </summary>
/// <param name="mockUserAuth">Returns the mock user auth.</param>
/// <param name="mockHealthService">Returns the mock health service.</param>
/// <returns>An instance of the <see cref="Functions"/> class.</returns>
public static Functions GetApiFunctions(
out Mock <IUserAuthenticationService> mockUserAuth,
out Mock <IHealthService> mockHealthService)
{
mockUserAuth = Mockers.MockUserAuth();
mockHealthService = new Mock <IHealthService>();
return(new Functions(mockUserAuth.Object, mockHealthService.Object));
}
public async Task WithSuccessDeletesBlob()
{
// arrange
Mock <ILogger> mockLogger = new Mock <ILogger>();
var mockRequest = Mockers.MockRequest(null);
var sut = AudioMockers.GetApiFunctionsWithBlobUploaded();
// act
var response = await sut.Delete(mockRequest.Object, mockLogger.Object, Mockers.DefaultId).ConfigureAwait(false);
var responseType = (NoContentResult)response;
// assert
Assert.IsNotNull(responseType);
}
public void ConfigureServices(IServiceCollection services)
{
var settings = new JsonSerializerSettings();
settings.ContractResolver = new SignalRContractResolver();
var serializer = JsonSerializer.Create(settings);
services.Add(new ServiceDescriptor(typeof(JsonSerializer),
provider => serializer,
ServiceLifetime.Transient));
services.AddSignalR(options => options.Hubs.EnableDetailedErrors = true);
services.AddMvc();
services.AddTransient <IBuildRepository>(s => Mockers.MockIBuildRepository());
services.AddSingleton <IBuildMonitorService>(s => Mockers.MockIBuildMonitorService());
}
public async Task WithMissingCategoryIdReturnsBadRequest()
{
// arrange
Mock <AbstractLogger> mockLogger = new Mock <AbstractLogger>();
var mockRequest = Mockers.MockRequest(new { cateogryId = string.Empty });
var sut = AudioMockers.GetApiFunctionsWithBlobUploaded(
out Mock <IUserAuthenticationService> mockUserAuth,
out FakeBlobRepository fakeRepository,
out Mock <IEventGridPublisherService> mockEventGridPublisherService);
// act
var response = await sut.AddComplete(mockRequest.Object, mockLogger.Object, Mockers.DefaultId).ConfigureAwait(false);
var responseType = (BadRequestObjectResult)response;
Assert.IsNotNull(responseType);
Assert.AreEqual("Missing required property 'categoryId'.", ((dynamic)responseType.Value).error);
}
public async Task WithInvalidJsonRequestReturnsBadRequest()
{
// arrange
Mock <AbstractLogger> mockLogger = new Mock <AbstractLogger>();
var mockRequest = Mockers.MockRequestWithInvalidJson();
var sut = AudioMockers.GetApiFunctionsWithBlobUploaded(
out Mock <IUserAuthenticationService> mockUserAuth,
out FakeBlobRepository fakeRepository,
out Mock <IEventGridPublisherService> mockEventGridPublisherService);
// act
var response = await sut.AddComplete(mockRequest.Object, mockLogger.Object, Mockers.DefaultId).ConfigureAwait(false);
var responseType = (BadRequestObjectResult)response;
Assert.IsNotNull(responseType);
Assert.AreEqual("Body should be provided in JSON format.", ((dynamic)responseType.Value).error);
}
public async Task WithInvalidAudioIdReturnsNull()
{
// arrange
Mock <ILogger> mockLogger = new Mock <ILogger>();
var mockRequest = Mockers.MockRequest(null);
var sut = AudioMockers.GetApiFunctionsWithBlobUploaded(
out FakeBlobRepository fakeBlobRepo);
fakeBlobRepo.Blobs.Clear();
// act
var response = await sut.Get(mockRequest.Object, mockLogger.Object, Mockers.DefaultId).ConfigureAwait(false);
var responseType = (NotFoundResult)response;
// assert
Assert.IsNotNull(responseType);
}
public async Task WithThrownExceptionThrowsException()
{
// arrange
Mock <AbstractLogger> mockLogger = new Mock <AbstractLogger>();
TimerInfo timerInfo = Mockers.GetTimerInfo();
var sut = HealthMockers.GetApiFunctions(
out Mock <IUserAuthenticationService> mockUserAuth,
out Mock <IHealthService> mockHealthService);
System.Exception ex = new System.Exception("My error.");
mockHealthService.Setup(m => m.HealthCheck())
.ThrowsAsync(ex);
// act
await Assert.ThrowsExceptionAsync <System.Exception>(() => sut.SystemHealthCheckTimer(timerInfo, mockLogger.Object)).ConfigureAwait(false);
mockLogger.Verify(moc => moc.Log(LogLevel.Error, It.IsAny <System.Exception>(), "Unhandled Exception."));
}
public async Task WithIncorrectUserIdReturnsAudioNotFound()
{
// arrange
Mock <ILogger> mockLogger = new Mock <ILogger>();
var mockRequest = Mockers.MockRequest(null);
var sut = AudioMockers.GetApiFunctionsWithBlobUploaded(
out FakeBlobRepository fakeBlobRepo);
fakeBlobRepo.Blobs.Clear();
fakeBlobRepo.AddFakeBlob(Mockers.AudioContainerName, $"otheruserid/{Mockers.DefaultId}");
// act
var response = await sut.Delete(mockRequest.Object, mockLogger.Object, Mockers.DefaultId).ConfigureAwait(false);
var responseType = (NoContentResult)response;
// assert
Assert.IsNotNull(responseType);
}
public async Task HealthCheckWithSuccess()
{
var healthService = new HealthService();
List <string> services = new List <string>
{
"test-health",
"test-categories",
"test-audio",
"test-images",
"test-text",
"test-web",
};
Queue <HttpResponseMessage> responses = new Queue <HttpResponseMessage>();
services.ForEach(serviceName =>
{
var healthCheckResponse = new HealthCheckResponse()
{
Status = HealthCheckStatus.OK,
Application = serviceName,
};
var response = new HttpResponseMessage()
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent(
JsonConvert.SerializeObject(healthCheckResponse),
Encoding.UTF8,
"application/json"),
};
responses.Enqueue(response);
});
var mockHttpHandler = Mockers.MockHttpMessageHandler(responses);
HealthService.Client = new HttpClient(mockHttpHandler.Object);
var results = await healthService.HealthCheck().ConfigureAwait(false);
Assert.AreEqual(5, results.Count, $"There were not 5 health check statuses in the response, there were {results.Count}");
}
public async Task WithAnotherUserIdDoesNotReturnSummaries()
{
// arrange
Mock <ILogger> mockLogger = new Mock <ILogger>();
var mockRequest = Mockers.MockRequest(null);
var sut = AudioMockers.GetApiFunctionsWithBlobUploaded(
out FakeBlobRepository fakeBlobRepo);
fakeBlobRepo.AddFakeBlob(Mockers.AudioContainerName, "newblobname");
// act
var response = await sut.GetList(mockRequest.Object, mockLogger.Object).ConfigureAwait(false);
var responseType = (ObjectResult)response;
var responseObject = (GetListResponse)responseType.Value;
// assert
Assert.IsNotNull(responseObject);
Assert.AreEqual(1, responseObject.Count);
}
public async Task WithTranscriptMissingReturnsAudioNote()
{
// arrange
Mock <ILogger> mockLogger = new Mock <ILogger>();
var mockRequest = Mockers.MockRequest(null);
var sut = AudioMockers.GetApiFunctionsWithBlobUploaded(
out FakeBlobRepository fakeBlobRepo);
// act
var response = await sut.Get(mockRequest.Object, mockLogger.Object, Mockers.DefaultId).ConfigureAwait(false);
var responseType = (OkObjectResult)response;
var responseObject = (GetResponse)responseType.Value;
// assert
Assert.IsNotNull(responseObject);
Assert.AreEqual(Mockers.DefaultId, responseObject.Id);
Assert.AreEqual($"https://fakerepository/audio/fakeuserid/{responseObject.Id}?sasToken=Read", responseObject.AudioUrl.ToString());
Assert.IsNull(responseObject.Transcript);
}
public async Task WithBlobStorageFailing()
{
// arrange
Mock <ILogger> mockLogger = new Mock <ILogger>();
var mockRequest = Mockers.MockRequest(null);
mockRequest.Setup(x => x.Host).Returns(new HostString("test"));
var sut = AudioMockers.GetApiFunctionsWithBlobUploaded(
out FakeBlobRepository fakeBlobRepo);
// act
var response = await sut.HealthCheck(mockRequest.Object, mockLogger.Object).ConfigureAwait(false);
var responseType = (OkObjectResult)response;
var responseObject = (HealthCheckResponse)responseType.Value;
// assert
Assert.IsNotNull(responseObject);
Assert.AreEqual(HealthCheckStatus.OK, responseObject.Status);
Assert.AreEqual("test", responseObject.Application);
}
/// <summary>
/// Gets an audio operations class with a blob uploaded to the mock
/// blob repository.
/// </summary>
/// <param name="mockUserAuth">Returns the mock user auth.</param>
/// <param name="fakeBlobRepo">Returns the fake blob repository with the added blob.</param>
/// <param name="mockEventPub">Returns the fake event publisher.</param>
/// <returns>An instance of the <see cref="Api.Functions"/> class.</returns>
public static Api.Functions GetApiFunctionsWithBlobUploaded(
out Mock <IUserAuthenticationService> mockUserAuth,
out FakeBlobRepository fakeBlobRepo,
out Mock <IEventGridPublisherService> mockEventPub)
{
mockUserAuth = Mockers.MockUserAuth();
mockEventPub = new Mock <IEventGridPublisherService>();
var mockEventSub = new Mock <IEventGridSubscriberService>();
var mockAudioTranscriptionService = new Mock <Api.IAudioTranscriptionService>();
fakeBlobRepo = new FakeBlobRepository();
fakeBlobRepo.AddFakeBlob(Mockers.AudioContainerName, $"{Mockers.DefaultUserId}/{Mockers.DefaultId}");
return(new Api.Functions(
mockUserAuth.Object,
fakeBlobRepo,
mockEventSub.Object,
mockEventPub.Object,
mockAudioTranscriptionService.Object));
}
public async Task WithSuccessPublishesAudioDeletedEventToEventGrid()
{
// arrange
Mock <ILogger> mockLogger = new Mock <ILogger>();
var mockRequest = Mockers.MockRequest(null);
var sut = AudioMockers.GetApiFunctionsWithBlobUploaded(
out FakeBlobRepository fakeBlobRepo,
out Mock <IEventGridPublisherService> mockEventGridPublisherService);
// act
var response = await sut.Delete(mockRequest.Object, mockLogger.Object, Mockers.DefaultId).ConfigureAwait(false);
var responseType = (NoContentResult)response;
// assert
mockEventGridPublisherService.Verify(
m => m.PostEventGridEventAsync(
AudioEvents.AudioDeleted,
"fakeuserid/fakeid",
It.IsAny <AudioDeletedEventData>()),
Times.Once);
}
public async Task WithSuccess()
{
// arrange
Mock <ILogger> mockLogger = new Mock <ILogger>();
var mockRequest = Mockers.MockRequest(null);
mockRequest.Setup(x => x.Host).Returns(new HostString("test"));
var sut = HealthMockers.GetApiFunctions(
out Mock <IUserAuthenticationService> mockUserAuthenticationService,
out Mock <IHealthService> mockHealthService);
// act
var response = await sut.HealthCheck(mockRequest.Object, mockLogger.Object).ConfigureAwait(false);
var responseType = (OkObjectResult)response;
var responseObject = (HealthCheckResponse)responseType.Value;
// assert
Assert.IsNotNull(responseObject);
Assert.AreEqual(HealthCheckStatus.OK, responseObject.Status);
Assert.AreEqual("test", responseObject.Application);
}
public async Task WithThrownExceptionThrowsException()
{
// arrange
var mockUserAuth = Mockers.MockUserAuth();
string userId;
IActionResult actionResult = new BadRequestObjectResult(new { error = "Error." });
System.Exception ex = new System.Exception("My error.");
mockUserAuth.Setup(m => m.GetUserIdAsync(It.IsAny <HttpRequest>(), out userId, out actionResult))
.ThrowsAsync(ex);
var fakeRepository = new FakeBlobRepository();
Mock <HttpRequest> mockRequest = Mockers.MockRequest(null);
Mock <AbstractLogger> mockLogger = new Mock <AbstractLogger>();
var sut = new Functions(
mockUserAuth.Object,
fakeRepository);
// act
await Assert.ThrowsExceptionAsync <System.Exception>(() => sut.AddBegin(mockRequest.Object, mockLogger.Object)).ConfigureAwait(false);
mockLogger.Verify(moc => moc.Log(LogLevel.Error, It.IsAny <System.Exception>(), "Unhandled Exception."));
}
public async Task WithSuccessReturnsIdAndUrl()
{
// arrange
var mockUserAuth = Mockers.MockUserAuth();
var fakeRepository = new FakeBlobRepository();
Mock <HttpRequest> mockRequest = Mockers.MockRequest(null);
Mock <ILogger> mockLogger = new Mock <ILogger>();
var sut = new Functions(
mockUserAuth.Object,
fakeRepository);
// act
var response = await sut.AddBegin(mockRequest.Object, mockLogger.Object).ConfigureAwait(false);
var objectResult = (OkObjectResult)response;
var addResponse = (AddBeginResponse)objectResult.Value;
// assert
Assert.IsNotNull(addResponse.Id);
Assert.IsNotNull(addResponse.UploadUrl);
Assert.AreEqual($"https://fakerepository/audio/fakeuserid/{addResponse.Id}?sasToken=Write", addResponse.UploadUrl.ToString());
}
public async Task WithSuccessReturnsSummaries()
{
// arrange
Mock <ILogger> mockLogger = new Mock <ILogger>();
var mockRequest = Mockers.MockRequest(null);
var sut = AudioMockers.GetApiFunctionsWithBlobUploaded(
out FakeBlobRepository fakeBlobRepo);
fakeBlobRepo.AddFakeBlob(Mockers.AudioContainerName, $"{Mockers.DefaultUserId}/newblobname");
fakeBlobRepo.Blobs[0].Properties[Mockers.TranscriptMetadataName] = "faketranscript";
// act
var response = await sut.GetList(mockRequest.Object, mockLogger.Object).ConfigureAwait(false);
var responseType = (ObjectResult)response;
var responseObject = (GetListResponse)responseType.Value;
// assert
Assert.IsNotNull(responseObject);
Assert.AreEqual(2, responseObject.Count);
Assert.AreEqual(Mockers.DefaultId, responseObject[0].Id);
Assert.AreEqual("faketranscript", responseObject[0].Preview);
}
public async Task WithThrownExceptionThrowsException()
{
// arrange
string userId;
Mock <AbstractLogger> mockLogger = new Mock <AbstractLogger>();
var mockRequest = Mockers.MockRequest(null);
mockRequest.Setup(x => x.Host).Returns(new HostString("test"));
var sut = HealthMockers.GetApiFunctions(
out Mock <IUserAuthenticationService> mockUserAuth,
out Mock <IHealthService> mockHealthService);
IActionResult actionResult = new BadRequestObjectResult(new { error = "Error." });
System.Exception ex = new System.Exception("My error.");
mockUserAuth.Setup(m => m.GetUserIdAsync(It.IsAny <HttpRequest>(), out userId, out actionResult))
.ThrowsAsync(ex);
// act
await Assert.ThrowsExceptionAsync <System.Exception>(() => sut.HealthCheck(mockRequest.Object, mockLogger.Object)).ConfigureAwait(false);
mockLogger.Verify(moc => moc.Log(LogLevel.Error, It.IsAny <System.Exception>(), "Unhandled Exception."));
}
public async Task WithSuccess()
{
// arrange
Mock <ILogger> mockLogger = new Mock <ILogger>();
var mockRequest = Mockers.MockRequest(null);
mockRequest.Setup(x => x.Host).Returns(new HostString("test"));
var sut = HealthMockers.GetApiFunctions(
out Mock <IUserAuthenticationService> mockUserAuthenticationService,
out Mock <IHealthService> mockHealthService);
mockHealthService.Setup(x => x.HealthCheck()).ReturnsAsync(new List <HealthCheckResponse>()
{
new HealthCheckResponse()
{
Application = "Ali",
Status = HealthCheckStatus.OK,
},
new HealthCheckResponse()
{
Application = "Baba",
Status = HealthCheckStatus.OK,
},
});
// act
var response = await sut.SystemHealthCheck(mockRequest.Object, mockLogger.Object).ConfigureAwait(false);
var responseType = (OkObjectResult)response;
var responseObject = (List <HealthCheckResponse>)responseType.Value;
// assert
Assert.IsNotNull(responseObject);
Assert.AreEqual(2, responseObject.Count, "The response did not have 2 HealthCheckReponses");
Assert.AreEqual(HealthCheckStatus.OK, responseObject[0].Status);
Assert.AreEqual("Ali", responseObject[0].Application, "The application name for the first item was not 'Ali'");
}
/// <summary>
/// Gets a mocked event grid update transcription request.
/// </summary>
/// <returns>Mock http request that would come from the event grid for an audio created event.</returns>
public static Mock <HttpRequest> GetMockEventGridAudioCreatedRequest()
{
var requestBody = new EventGridRequest <AudioCreatedEventData>()
{
UserId = Mockers.DefaultUserId,
ItemId = Mockers.DefaultId,
Event = new EventGridEvent <AudioCreatedEventData>()
{
Data = new AudioCreatedEventData()
{
Category = Mockers.DefaultId,
},
EventTime = System.DateTime.Now,
Id = System.Guid.NewGuid().ToString(),
EventType = "AudioCreated",
Subject = $"{Mockers.DefaultUserId}/{Mockers.DefaultId}",
Topic = "faketopic",
},
};
var headers = new HeaderDictionary();
return(Mockers.MockRequest(requestBody, headers));
}
