public async Task <ServiceResponseDto> UnSubscribeFromCollectionAsync(int userId, int collectionId) { ServiceResponseDto serviceResponseDto = new ServiceResponseDto(); if (!await _collectionSubscriberRepository.ExistsAsync(collSubscriber => collSubscriber.CollectionId.Equals(collectionId) && collSubscriber.UserId.Equals(userId))) { serviceResponseDto.Message = "User is not subscribed to collection."; return(serviceResponseDto); } CollectionSubscriber collectionSubscriber = await _collectionSubscriberRepository .FindSingleByExpressionAsync(collectSub => collectSub.CollectionId.Equals(collectionId) && collectSub.UserId.Equals(userId)); if (await _collectionSubscriberRepository.DeleteAsync(collectionSubscriber)) { serviceResponseDto.Success = true; serviceResponseDto.Message = "Successfully unsubscribed from collection."; } else { serviceResponseDto.Message = "Failed to unsubscribe from collection."; } return(serviceResponseDto); }
public async Task <ServiceResponseDto> FollowUserAsync(FollowerDto followerDto) { ServiceResponseDto followResultDto = new ServiceResponseDto(); Follower follower = DtoToEntityConverter.Convert <Follower, FollowerDto>(followerDto); if (!await _applicationUserRepository.ExistsAsync(user => user.Id.Equals(followerDto.UserId))) { followResultDto.Message = "The user does not exist."; return(followResultDto); } if (!await _applicationUserRepository.ExistsAsync(user => user.Id.Equals(followerDto.FollowerUserId))) { followResultDto.Message = "The follower user does not exist."; return(followResultDto); } string username = (await _applicationUserRepository.FindSingleByExpressionAsync(user => user.Id.Equals(followerDto.UserId))).UserName; if (await _followerRepository.ExistsAsync(follow => follow.UserId.Equals(followerDto.UserId) && follow.FollowerUserId.Equals(followerDto.FollowerUserId))) { followResultDto.Message = $"You already follow {username}"; return(followResultDto); } if (await _followerRepository.CreateAsync(follower)) { followResultDto.Success = true; followResultDto.Message = $"Successfully followed {username}"; return(followResultDto); } followResultDto.Message = "Something happened try again later.."; return(followResultDto); }
public async Task <ServiceResponseDto> SubscribeToCollectionAsync(int userId, int collectionId) { ServiceResponseDto serviceResponseDto = new ServiceResponseDto(); if (await _collectionSubscriberRepository.ExistsAsync(collSubscriber => collSubscriber.CollectionId.Equals(collectionId) && collSubscriber.UserId.Equals(userId))) { serviceResponseDto.Message = "User is already subscribed to collection."; return(serviceResponseDto); } CollectionSubscriber collectionSubscriber = new CollectionSubscriber { CollectionId = collectionId, UserId = userId }; if (await _collectionSubscriberRepository.CreateAsync(collectionSubscriber)) { serviceResponseDto.Success = true; serviceResponseDto.Message = "Successfully subscribed to collection."; } else { serviceResponseDto.Message = "Failed to subscribe to collection."; } return(serviceResponseDto); }
public async Task AddMemeToCollectionAsync_Should_Pass() { // Arrange MemeDto expectedMemeDto = new MemeDto { Id = "a0Q558q", ImageUrl = "https://images-cdn.9gag.com/photo/a0Q558q_700b.jpg", VideoUrl = "http://img-9gag-fun.9cache.com/photo/a0Q558q_460sv.mp4", PageUrl = "http://9gag.com/gag/a0Q558q", Title = "Old but Gold" }; Meme entity = DtoToEntityConverter.Convert <Meme, MemeDto>(expectedMemeDto); Assert.IsTrue(await MemeRepository.CreateAsync(entity)); AddMemeToCollectionDto addMemeToCollectionDto = new AddMemeToCollectionDto { MemeId = "a0Q558q", UserId = 1, CollectionId = 1 }; // Act ServiceResponseDto addMemeToCollectionResultDto = await CollectionItemDetailService.AddMemeToCollectionAsync(addMemeToCollectionDto); // Assert Assert.IsTrue(addMemeToCollectionResultDto.Success); Assert.AreEqual(addMemeToCollectionResultDto.Message, "Successfully added meme to the collection."); CollectionItemDetail actualCollectionItemDetail = (await CollectionItemDetailRepository.GetAllAsync()).First(); Assert.IsTrue( actualCollectionItemDetail.MemeId.Equals("a0Q558q") && actualCollectionItemDetail.AddedByUserId.Equals(1) && actualCollectionItemDetail.CollectionId.Equals(1)); }
public async Task <ServiceResponseDto> MarkSharedMemeAsSeenAsync(SharedMemeDto sharedMeme) { ServiceResponseDto sharedMemeMarkAsSeenDto = new ServiceResponseDto { Message = "Something happened try again later.." }; if (!await _sharedMemeRepository.ExistsAsync(sm => sm.Id.Equals(sharedMeme.Id))) { sharedMemeMarkAsSeenDto.Message = "Something happened try again later.."; return(sharedMemeMarkAsSeenDto); } SharedMeme sharedMemeEntity = await _sharedMemeRepository.FindSingleByExpressionAsync(sm => sm.Id.Equals(sharedMeme.Id)); if (sharedMemeEntity.IsSeen) { sharedMemeMarkAsSeenDto.Message = "The shared meme is already marked as seen."; return(sharedMemeMarkAsSeenDto); } sharedMemeEntity.IsSeen = true; if (!await _sharedMemeRepository.UpdateAsync(sharedMemeEntity)) { return(sharedMemeMarkAsSeenDto); } sharedMemeMarkAsSeenDto.Success = true; sharedMemeMarkAsSeenDto.Message = "Successfully marked the shared meme as seen."; return(sharedMemeMarkAsSeenDto); }
public async Task <ServiceResponseDto> RemoveMemeFromCollectionAsync(RemoveMemeFromCollectionDto removeMemeFromCollectionDto) { ServiceResponseDto serviceResultDto = new ServiceResponseDto(); bool isOwnerOfCollection = await _collectionRepository.ExistsAsync(collection => collection.Id.Equals(removeMemeFromCollectionDto.CollectionId) && collection.UserId.Equals(removeMemeFromCollectionDto.UserId)); CollectionItemDetail actualCollectionItemDetail = await _collectionItemDetailRepository .FindSingleByExpressionAsync(collectionItemDetail => collectionItemDetail.Id.Equals(removeMemeFromCollectionDto.CollectionItemDetailId)); // TODO: check if user is currently subscribed? if (!actualCollectionItemDetail.AddedByUserId.Equals(removeMemeFromCollectionDto.UserId) || !isOwnerOfCollection) { serviceResultDto.Message = "Failed to remove meme because user is not authorized."; return(serviceResultDto); } if (await _collectionItemDetailRepository.DeleteAsync(actualCollectionItemDetail)) { serviceResultDto.Success = true; serviceResultDto.Message = "Successfully removed meme from collection."; } else { serviceResultDto.Message = "Failed to remove meme from the collection"; } return(serviceResultDto); }
public async Task DeleteCollectionAsync_Should_Pass() { // Arrange CollectionDto collectionDto = new CollectionDto { UserId = 1, Name = "Dank Memes" }; await CollectionService.CreateCollectionAsync(collectionDto); List <CollectionDto> collections = (await CollectionService.GetAllCollectionsAsync()).ToList(); Assert.IsTrue(collections.Count.Equals(1)); // Act DeleteCollectionDto deleteCollectionDto = new DeleteCollectionDto { Id = 1, UserId = 1 }; ServiceResponseDto deleteCollectionResultDto = await CollectionService.DeleteCollectionAsync(deleteCollectionDto); // Assert Assert.IsTrue(deleteCollectionResultDto.Success); collections = (await CollectionService.GetAllCollectionsAsync()).ToList(); Assert.IsTrue(collections.Count.Equals(0)); }
public async Task <ServiceResponseDto> DeleteCollectionAsync(DeleteCollectionDto deleteCollectionDto) { ServiceResponseDto deleteCollectionResultDto = new ServiceResponseDto(); if (!await _collectionRepository.ExistsAsync(collection => collection.Id.Equals(deleteCollectionDto.Id))) { deleteCollectionResultDto.Message = "The collection does not exist."; return(deleteCollectionResultDto); } if (!await _collectionRepository.ExistsAsync(collection => collection.Id.Equals(deleteCollectionDto.Id) && collection.UserId.Equals(deleteCollectionDto.UserId))) { deleteCollectionResultDto.Message = "The collection does not exist or you are not the owner of the collection."; return(deleteCollectionResultDto); } Collection actualCollection = await _collectionRepository.FindSingleByExpressionAsync(collection => collection.Id.Equals(deleteCollectionDto.Id) && collection.UserId.Equals(deleteCollectionDto.UserId)); if (await _collectionRepository.DeleteAsync(actualCollection)) { deleteCollectionResultDto.Success = true; deleteCollectionResultDto.Message = "Successfully deleted the collection."; return(deleteCollectionResultDto); } deleteCollectionResultDto.Message = "Something happened try again later.."; return(deleteCollectionResultDto); }
/// <summary> /// Create a result object given the value and errors list /// </summary> /// <typeparam name="T"></typeparam> /// <param name="value"></param> /// <param name="errors"></param> /// <returns></returns> public ServiceResponseDto <T> CreateResult <T>(T value, IEnumerable <IError> errors) { var result = new ServiceResponseDto <T>() { Errors = errors?.ToList(), ResultObject = value }; return(result); }
private async Task HandleAuthError() { var originalStatusCode = Context.Response.StatusCode; var originalStatusMsg = ((HttpStatusCode)originalStatusCode).ToString(); Context.Response.ContentType = MediaTypeNames.Application.Json; Context.Response.StatusCode = (int)HttpStatusCode.OK; var responseBody = new ServiceResponseDto(originalStatusCode, originalStatusMsg); var serializedResponseDto = JsonConvert.SerializeObject(responseBody); await Context.Response.WriteAsync(serializedResponseDto); }
public async Task <IActionResult> MarkMemeAsSeenAsync([FromBody] MarkMemeAsSeenViewModel markMemeAsSeenViewModel) { if (!ModelState.IsValid) { return(Json(ModelState.DefaultInvalidModelStateWithErrorMessages())); } int userId = Convert.ToInt32(User.FindFirstValue(ClaimTypes.NameIdentifier)); SharedMemeDto sharedMemeDto = markMemeAsSeenViewModel.GetSharedMemeDto(userId); ServiceResponseDto sharedMemeMarkAsSeenDto = await _memeSharingService.MarkSharedMemeAsSeenAsync(sharedMemeDto); return(Json(sharedMemeMarkAsSeenDto)); }
public async Task <IActionResult> CreateCommentAsync([FromBody] CreateCommentViewModel createCommentViewModel) { if (!ModelState.IsValid) { return(Json(ModelState.DefaultInvalidModelStateWithErrorMessages())); } int userId = Convert.ToInt32(User.FindFirstValue(ClaimTypes.NameIdentifier)); CommentDto commentDto = createCommentViewModel.GetCommentDto(userId); ServiceResponseDto commentResultDto = await _commentService.CreateCommentAsync(commentDto); return(Json(commentResultDto)); }
public async Task FollowUserAsync_Should_Fail_User_Does_Not_Exist() { // Arrange FollowerDto followerDto = new FollowerDto { UserId = 1, FollowerUserId = 6 }; // Act ServiceResponseDto responseDto = await FollowerService.FollowUserAsync(followerDto); // Assert Assert.IsFalse(responseDto.Success); }
public async Task FollowUserAsync_Should_Pass() { // Arrange FollowerDto followerDto = new FollowerDto { UserId = 1, FollowerUserId = 2 }; // Act ServiceResponseDto responseDto = await FollowerService.FollowUserAsync(followerDto); // Assert Assert.IsTrue(responseDto.Success); }
public async Task UnFollowUserAsync_Should_Fail_Because_User_Is_Not_Currently_Followed() { // Arrange FollowerDto followerDto = new FollowerDto { UserId = 1, FollowerUserId = 2 }; // Act ServiceResponseDto responseDto = await FollowerService.UnFollowUserAsync(followerDto); // Assert Assert.IsFalse(responseDto.Success); }
public async Task <IActionResult> UnFollowAsync([FromBody] UnFollowViewModel unFollowViewModel) { if (!ModelState.IsValid) { return(Json(ModelState.DefaultInvalidModelStateWithErrorMessages())); } int userId = Convert.ToInt32(User.FindFirstValue(ClaimTypes.NameIdentifier)); FollowerDto follower = unFollowViewModel.GetFollowerDto(userId); ServiceResponseDto unFollowResultDto = await _followerService.UnFollowUserAsync(follower); await _tempDataService.UpdateTempDataAsync(TempData, userId); return(Json(unFollowResultDto)); }
public async Task <IActionResult> ShareMemeToFriendAsync([FromBody] ShareMemeViewModel shareMemeViewModel) { if (!ModelState.IsValid) { return(Json(ModelState.DefaultInvalidModelStateWithErrorMessages())); } int userId = Convert.ToInt32(User.FindFirstValue(ClaimTypes.NameIdentifier)); SharedMemeDto sharedMemeDto = shareMemeViewModel.GetSharedMemeDto(userId); ServiceResponseDto sharedMemeResultDto = await _memeSharingService.ShareMemeToMutualFollowerAsync(sharedMemeDto); return(sharedMemeResultDto.Success ? Json(new { success = true, to = sharedMemeResultDto.Message }) : Json(new { success = false, message = "Something happened.." })); }
public async Task ShareMemeToMutualFollowerAsync_Should_Pass() { // Arrange SharedMemeDto sharedMemeDto = new SharedMemeDto { SenderUserId = 1, ReceiverUserId = 2, MemeId = "a0Q558q" }; // Act ServiceResponseDto serviceResponseDto = await MemeSharingService.ShareMemeToMutualFollowerAsync(sharedMemeDto); // Assert Assert.IsTrue(serviceResponseDto.Success); }
public async Task AddMemeToCollectionAsync_Should_Fail_With_Message_Meme_Does_Not_Exist() { // Arrange AddMemeToCollectionDto addMemeToCollectionDto = new AddMemeToCollectionDto { MemeId = "a0Q558q", UserId = 1, CollectionId = 1 }; // Act ServiceResponseDto serviceResultDto = await CollectionItemDetailService.AddMemeToCollectionAsync(addMemeToCollectionDto); // Assert Assert.IsFalse(serviceResultDto.Success); Assert.AreEqual(serviceResultDto.Message, "Meme does not exist."); }
public async Task CreateCollectionAsync_Should_Pass() { // Arrange CollectionDto expectedCollectionDto1 = new CollectionDto { UserId = 1, Name = "Dank" }; ServiceResponseDto createCollectionResultDto = await CollectionService.CreateCollectionAsync(expectedCollectionDto1); Assert.IsTrue(createCollectionResultDto.Success); // Act CollectionDto actualCollectionDto1 = await CollectionService.GetCollectionByIdAsync(1); // Assert Assert.AreEqual(expectedCollectionDto1, actualCollectionDto1); }
public JsonResult Authenticate(CredentialsViewModel model) { ServiceResponseDto <AuthenticationResultViewModel> serviceResult = SendRequest <AuthenticationResultViewModel, CredentialsViewModel>(new ServiceRequestDto <CredentialsViewModel> { ServiceUrl = HomeControllerServiceUrl.AuthenticationService, ServiceMethodName = HomeControllerServiceUrl.AuthenticationMethod, RequestType = WebRequestMethods.Http.Post, RequestModel = model }); if (serviceResult.ErrorModel != null) { Response.StatusCode = serviceResult.ErrorModel.StatusCode; return(Json(serviceResult.ErrorModel, JsonRequestBehavior.AllowGet)); } return(Json(serviceResult.ResultViewModel, JsonRequestBehavior.DenyGet)); }
public async Task <ServiceResponseDto> CreateCollectionAsync(CollectionDto collectionDto) { ServiceResponseDto createCollectionResultDto = new ServiceResponseDto(); if (await _collectionRepository.ExistsAsync(collection => collection.Name.Equals(collectionDto.Name))) { createCollectionResultDto.Message = $"A collection with the name {collectionDto.Name} already exists."; return(createCollectionResultDto); } Collection actualCollection = DtoToEntityConverter.Convert <Collection, CollectionDto>(collectionDto); if (await _collectionRepository.CreateAsync(actualCollection)) { createCollectionResultDto.Success = true; createCollectionResultDto.Message = "The collection is created successfully."; return(createCollectionResultDto); } createCollectionResultDto.Message = "Something happened try again later.."; return(createCollectionResultDto); }
public async Task <ServiceResponseDto> DeAuthorizeSubscriberFromCollectionAsync(int userId, int collectionId) { ServiceResponseDto serviceResponseDto = new ServiceResponseDto(); CollectionSubscriber actualCollectionSubscriber = await _collectionSubscriberRepository .FindSingleByExpressionAsync(collectionSubscriber => collectionSubscriber.CollectionId.Equals(collectionId) && collectionSubscriber.UserId.Equals(userId)); actualCollectionSubscriber.IsAuthorized = false; if (await _collectionSubscriberRepository.UpdateAsync(actualCollectionSubscriber)) { serviceResponseDto.Success = true; serviceResponseDto.Message = "Successfully de-authorized user from collection."; } else { serviceResponseDto.Message = "Failed to de-authorize user from collection."; } return(serviceResponseDto); }
public async Task RemoveMemeFromCollectionAsync_Should_Throw_ApplicationUserIsNotAuthorizedException() { // Arrange MemeDto expectedMemeDto = new MemeDto { Id = "a0Q558q", ImageUrl = "https://images-cdn.9gag.com/photo/a0Q558q_700b.jpg", VideoUrl = "http://img-9gag-fun.9cache.com/photo/a0Q558q_460sv.mp4", PageUrl = "http://9gag.com/gag/a0Q558q", Title = "Old but Gold" }; Meme entity = DtoToEntityConverter.Convert <Meme, MemeDto>(expectedMemeDto); Assert.IsTrue(await MemeRepository.CreateAsync(entity)); AddMemeToCollectionDto addMemeToCollectionDto = new AddMemeToCollectionDto { MemeId = "a0Q558q", UserId = 1, CollectionId = 1 }; ServiceResponseDto addMemeToCollectionResultDto = await CollectionItemDetailService.AddMemeToCollectionAsync(addMemeToCollectionDto); Assert.IsTrue(addMemeToCollectionResultDto.Success); RemoveMemeFromCollectionDto removeMemeFromCollectionDto = new RemoveMemeFromCollectionDto { CollectionId = 1, CollectionItemDetailId = 1, UserId = 2 }; // Act & Assert ServiceResponseDto serviceResponseDto = await CollectionItemDetailService.RemoveMemeFromCollectionAsync(removeMemeFromCollectionDto); Assert.IsFalse(serviceResponseDto.Success); Assert.AreEqual(serviceResponseDto.Message, "Failed to remove meme because user is not authorized."); }
public async Task RemoveMemeFromCollectionAsync_Should_Pass() { // Arrange MemeDto expectedMemeDto = new MemeDto { Id = "a0Q558q", ImageUrl = "https://images-cdn.9gag.com/photo/a0Q558q_700b.jpg", VideoUrl = "http://img-9gag-fun.9cache.com/photo/a0Q558q_460sv.mp4", PageUrl = "http://9gag.com/gag/a0Q558q", Title = "Old but Gold" }; Meme entity = DtoToEntityConverter.Convert <Meme, MemeDto>(expectedMemeDto); Assert.IsTrue(await MemeRepository.CreateAsync(entity)); AddMemeToCollectionDto addMemeToCollectionDto = new AddMemeToCollectionDto { MemeId = "a0Q558q", UserId = 1, CollectionId = 1 }; ServiceResponseDto addMemeToCollectionResultDto = await CollectionItemDetailService.AddMemeToCollectionAsync(addMemeToCollectionDto); Assert.IsTrue(addMemeToCollectionResultDto.Success); RemoveMemeFromCollectionDto removeMemeFromCollectionDto = new RemoveMemeFromCollectionDto { CollectionId = 1, CollectionItemDetailId = 1, UserId = 1 }; // Act ServiceResponseDto serviceResponseDto = await CollectionItemDetailService.RemoveMemeFromCollectionAsync(removeMemeFromCollectionDto); // Assert Assert.IsTrue(serviceResponseDto.Success); List <CollectionItemDetail> collectionItemDetails = (await CollectionItemDetailRepository.GetAllAsync()).ToList(); Assert.AreEqual(collectionItemDetails.Count, 0); }
public JsonResult GetTokenTest(string secureToken) { ServiceResponseDto <TokenTestResultViewModel> serviceResult = SendRequest <TokenTestResultViewModel>(new ServiceRequestDto { ServiceUrl = HomeControllerServiceUrl.TestService, ServiceMethodName = HomeControllerServiceUrl.TestGetWithTokenHeaderMethod, RequestType = WebRequestMethods.Http.Get, HeaderParameters = new Dictionary <string, string> { { "Token", secureToken } } }); if (serviceResult.ErrorModel != null) { Response.StatusCode = serviceResult.ErrorModel.StatusCode; return(Json(serviceResult.ErrorModel, JsonRequestBehavior.AllowGet)); } return(Json(serviceResult.ResultViewModel, JsonRequestBehavior.AllowGet)); }
public JsonResult PostBasicAuthTest(string authorizationString) { ServiceResponseDto <TokenTestResultViewModel> serviceResult = SendRequest <TokenTestResultViewModel>(new ServiceRequestDto { ServiceUrl = HomeControllerServiceUrl.TestService, ServiceMethodName = HomeControllerServiceUrl.TestPostWithBasicAuthHeaderMethodName, RequestType = WebRequestMethods.Http.Post, HeaderParameters = new Dictionary <string, string> { { "Authorization", authorizationString } } }); if (serviceResult.ErrorModel != null) { Response.StatusCode = serviceResult.ErrorModel.StatusCode; return(Json(serviceResult.ErrorModel, JsonRequestBehavior.AllowGet)); } return(Json(serviceResult.ResultViewModel, JsonRequestBehavior.AllowGet)); }
public async Task CreateCommentAsync_Should_Pass() { // Arrange CommentDto commentDto = new CommentDto { MemeId = "a0Q558q", Text = "Haha, super funny meme!", UserId = 1 }; // NOTE: the repository is used here instead of CommentService.GetCommentsByMemeIdAsync because relational data will not work in memory. List <Comment> commentsBefore = (List <Comment>) await CommentRepository.FindManyByExpressionAsync(comment => comment.MemeId.Equals("a0Q558q")); Assert.IsTrue(commentsBefore.Count.Equals(0)); // Act ServiceResponseDto responseDto = await CommentService.CreateCommentAsync(commentDto); // Assert Assert.IsTrue(responseDto.Success); List <Comment> commentsAfter = (List <Comment>) await CommentRepository.FindManyByExpressionAsync(comment => comment.MemeId.Equals("a0Q558q")); Assert.IsTrue(commentsAfter.Count.Equals(1)); }
public async Task <ServiceResponseDto> UnFollowUserAsync(FollowerDto followerDto) { ServiceResponseDto unFollowResultDto = new ServiceResponseDto(); Follower follower = DtoToEntityConverter.Convert <Follower, FollowerDto>(followerDto); if (!await _applicationUserRepository.ExistsAsync(user => user.Id.Equals(followerDto.UserId))) { unFollowResultDto.Message = "The user does not exist."; return(unFollowResultDto); } if (!await _applicationUserRepository.ExistsAsync(user => user.Id.Equals(followerDto.FollowerUserId))) { unFollowResultDto.Message = "The follower user does not exist."; return(unFollowResultDto); } string username = (await _applicationUserRepository.FindSingleByExpressionAsync(user => user.Id.Equals(followerDto.UserId))).UserName; if (!await _followerRepository.ExistsAsync(follow => follow.UserId.Equals(followerDto.UserId) && follow.FollowerUserId.Equals(followerDto.FollowerUserId))) { unFollowResultDto.Message = $"you do not have {username} followed"; return(unFollowResultDto); } Follower actualFollower = await _followerRepository.FindSingleByExpressionAsync(follwr => follwr.UserId.Equals(follower.UserId) && follwr.FollowerUserId.Equals(follower.FollowerUserId)); if (await _followerRepository.DeleteAsync(actualFollower)) { unFollowResultDto.Success = true; unFollowResultDto.Message = $"Successfully unfollowed {username}"; return(unFollowResultDto); } unFollowResultDto.Message = "Something happened try again later.."; return(unFollowResultDto); }
public async Task Initialize() { ApplicationDbFactory = new ApplicationDbFactory("InMemoryDatabase"); await ApplicationDbFactory.Create().Database.EnsureDeletedAsync(); await ApplicationDbFactory.Create().Database.EnsureCreatedAsync(); ApplicationDbFactory.Create().ResetValueGenerators(); // Relational-specific methods can only be used when the context is using a relational database provider.. // ApplicationDbFactory.Create().Database.Migrate(); CollectionRepository = new CollectionRepository(ApplicationDbFactory.Create(), CollectionValidator); MemeRepository = new MemeRepository(ApplicationDbFactory.Create(), MemeValidator); CollectionItemDetailRepository = new CollectionItemDetailRepository(ApplicationDbFactory.Create(), CollectionItemDetailValidator); CollectionService = new CollectionService(CollectionRepository); CollectionItemDetailService = new CollectionItemDetailService(CollectionItemDetailRepository, CollectionRepository, MemeRepository); CollectionDto collectionDto = new CollectionDto { UserId = 1, Name = "Dank Memes" }; ServiceResponseDto createCollectionResultDto = await CollectionService.CreateCollectionAsync(collectionDto); Assert.IsTrue(createCollectionResultDto.Success); }