public async Task GetTranslationsByLangauge_ShouldReturnNotFoundResult_WhenLanguageDoesNotExist() { // Arrange const int languageId = 8941; GetTranslationsByLanguageQueryParams model = new GetTranslationsByLanguageQueryParams(); Mock <IMediator> mediatorMock = new Mock <IMediator>(); mediatorMock .Setup(m => m.Send(It.IsAny <LanguageExistsQuery>(), It.IsAny <CancellationToken>())) .ReturnsAsync(false); LanguageController controller = new LanguageController(mediatorMock.Object); // Act ActionResult <IDictionary <string, string> > response = await controller.GetTranslationsByLanguage(languageId, model); // Assert NotFoundObjectResult result = Assert.IsType <NotFoundObjectResult>(response.Result); ErrorResource error = Assert.IsType <ErrorResource>(result.Value); Assert.Equal(StatusCodes.Status404NotFound, error.StatusCode); }
public async Task DeleteMembership_ShouldReturnForbiddenResult_WhenUserIsNotPermittedToDelete() { // Arrange const int membershipId = 1; Mock <IMediator> mediatorMock = new Mock <IMediator>(); mediatorMock .Setup(m => m.Send(It.IsAny <MembershipExistsQuery>(), It.IsAny <CancellationToken>())) .ReturnsAsync(true); mediatorMock .Setup(m => m.Send(It.IsAny <CanDeleteMembershipQuery>(), It.IsAny <CancellationToken>())) .ReturnsAsync(false); GroupMembershipController controller = new GroupMembershipController(mediatorMock.Object, null); // Act ActionResult response = await controller.DeleteMembership(membershipId); // Assert ObjectResult result = Assert.IsType <ObjectResult>(response); ErrorResource error = Assert.IsType <ErrorResource>(result.Value); Assert.NotNull(error); Assert.Equal(StatusCodes.Status403Forbidden, error.StatusCode); }
public async Task SendMessage_ShouldReturnForbiddenResult_WhenUserTriesMessagingHimself() { // Arrange SendMessageBody body = new SendMessageBody { RecipientId = 1, HtmlContent = "hello world" }; _mediatorMock .Setup(m => m.Send(It.IsAny <RecipientExistsQuery>(), It.IsAny <CancellationToken>())) .ReturnsAsync(true); _mediatorMock .Setup(m => m.Send(It.IsAny <IsOwnRecipientQuery>(), It.IsAny <CancellationToken>())) .ReturnsAsync(true); MessageController controller = new MessageController(null, _mediatorMock.Object); // Act ActionResult <ChatMessageResource> response = await controller.SendMessage(body); // Assert ObjectResult result = Assert.IsType <ObjectResult>(response.Result); ErrorResource error = Assert.IsType <ErrorResource>(result.Value); Assert.NotNull(error); Assert.Equal(StatusCodes.Status403Forbidden, error.StatusCode); }
public async Task UpdateMembership_ShouldReturnForbiddenResult_WhenMembershipIsOwnMembership() { // Arrange const int membershipId = 1; UpdateMembershipBody body = new UpdateMembershipBody { IsAdmin = true }; Mock <IMediator> mediatorMock = new Mock <IMediator>(); mediatorMock .Setup(m => m.Send(It.IsAny <MembershipExistsQuery>(), It.IsAny <CancellationToken>())) .ReturnsAsync(true); mediatorMock .Setup(m => m.Send(It.IsAny <IsOwnMembershipQuery>(), It.IsAny <CancellationToken>())) .ReturnsAsync(true); GroupMembershipController controller = new GroupMembershipController(mediatorMock.Object, null); // Act ActionResult response = await controller.UpdateMembership(membershipId, body); // Assert ObjectResult result = Assert.IsType <ObjectResult>(response); ErrorResource error = Assert.IsType <ErrorResource>(result.Value); Assert.NotNull(error); Assert.Equal(StatusCodes.Status403Forbidden, error.StatusCode); }
public async Task DeleteMessage_ShouldReturnForbiddenResult_WhenTheUserIsNotTheAuthorOfTheMessage() { // Arrange const int messageId = 1; _mediatorMock .Setup(m => m.Send(It.IsAny <MessageExistsQuery>(), It.IsAny <CancellationToken>())) .ReturnsAsync(true); _mediatorMock .Setup(m => m.Send(It.IsAny <IsAuthorOfMessageQuery>(), It.IsAny <CancellationToken>())) .ReturnsAsync(false); MessageController controller = new MessageController(null, _mediatorMock.Object); // Act ActionResult response = await controller.DeleteMessage(messageId); // Assert ObjectResult result = Assert.IsType <ObjectResult>(response); ErrorResource error = Assert.IsType <ErrorResource>(result.Value); Assert.NotNull(error); Assert.Equal(StatusCodes.Status403Forbidden, error.StatusCode); }
public async Task SendMessage_ShouldReturnNotFoundResult_WhenRecipientDoesNotExist() { // Arrange SendMessageBody body = new SendMessageBody { RecipientId = 4314, HtmlContent = "hello world" }; _mediatorMock .Setup(m => m.Send(It.IsAny <RecipientExistsQuery>(), It.IsAny <CancellationToken>())) .ReturnsAsync(false); MessageController controller = new MessageController(null, _mediatorMock.Object); // Act ActionResult <ChatMessageResource> response = await controller.SendMessage(body); // Assert NotFoundObjectResult result = Assert.IsType <NotFoundObjectResult>(response.Result); ErrorResource error = Assert.IsType <ErrorResource>(result.Value); Assert.NotNull(error); Assert.Equal(StatusCodes.Status404NotFound, error.StatusCode); }
public async Task UpdateGroup_ShouldReturnNotFoundResult_WhenGroupDoesNotExist() { // Arrange const int groupId = 15453; UpdateGroupBody model = new UpdateGroupBody { Name = "Some updated name", Description = "Some updated description" }; Mock <IMediator> mediatorMock = new Mock <IMediator>(); mediatorMock .Setup(m => m.Send(It.IsAny <GroupExistsQuery>(), It.IsAny <CancellationToken>())) .ReturnsAsync(false); GroupController controller = new GroupController(mediatorMock.Object, null); // Act ActionResult response = await controller.UpdateGroup(groupId, model); // Assert NotFoundObjectResult result = Assert.IsType <NotFoundObjectResult>(response); ErrorResource error = Assert.IsType <ErrorResource>(result.Value); Assert.Equal(StatusCodes.Status404NotFound, error.StatusCode); }
public async Task EditMessage_ShouldReturnNotFoundResult_WhenMessageDoesNotExist() { // Arrange const int messageId = 1; EditMessageBody body = new EditMessageBody { HtmlContent = "<p>hello world</p>" }; _mediatorMock .Setup(m => m.Send(It.IsAny <MessageExistsQuery>(), It.IsAny <CancellationToken>())) .ReturnsAsync(false); MessageController controller = new MessageController(null, _mediatorMock.Object); // Act ActionResult response = await controller.EditMessage(messageId, body); // Assert NotFoundObjectResult result = Assert.IsType <NotFoundObjectResult>(response); ErrorResource error = Assert.IsType <ErrorResource>(result.Value); Assert.NotNull(error); Assert.Equal(StatusCodes.Status404NotFound, error.StatusCode); }
public async Task CreateMembership_ShouldReturnForbiddenResult_WhenUserIsNotAdministrator() { // Arrange CreateMembershipBody body = new CreateMembershipBody { GroupId = 1, UserId = 1, IsAdmin = false }; Mock <IMediator> mediatorMock = new Mock <IMediator>(); mediatorMock .Setup(m => m.Send(It.IsAny <GroupExistsQuery>(), It.IsAny <CancellationToken>())) .ReturnsAsync(true); mediatorMock .Setup(m => m.Send(It.IsAny <UserExistsQuery>(), It.IsAny <CancellationToken>())) .ReturnsAsync(true); mediatorMock .Setup(m => m.Send(It.IsAny <CanCreateMembershipQuery>(), It.IsAny <CancellationToken>())) .ReturnsAsync(false); GroupMembershipController controller = new GroupMembershipController(mediatorMock.Object, null); // Act ActionResult <GroupMembershipResource> response = await controller.CreateMembership(body); // Assert ObjectResult result = Assert.IsType <ObjectResult>(response.Result); ErrorResource error = Assert.IsType <ErrorResource>(result.Value); Assert.NotNull(error); Assert.Equal(StatusCodes.Status403Forbidden, error.StatusCode); }
public WhenPlayMediaOnASpecificDeviceWithInvalidAccessToken() { var deviceId = Guid.NewGuid().ToString(); var mediaUrl = "https://localhost/" + Guid.NewGuid(); var mediaTitle = "Title"; var mediaArtworkUrl = mediaUrl + "/artwork.jpg"; var request = new { actionFields = new { device_id = deviceId, media_url = mediaUrl, media_title = mediaTitle, media_artwork_url = mediaArtworkUrl }, ifttt_source = new { id = "2", url = "https://ifttt.com/myrecipes/personal/2" }, user = new { timezone = "Pacific Time (US & Canada)" } }; var content = new StringContent(JsonConvert.SerializeObject(request)); this.LinnApiActions.PlaySingleMedia( Arg.Any <string>(), deviceId, mediaUrl, mediaTitle, mediaArtworkUrl, Arg.Any <CancellationToken>()).Throws(new LinnApiException(HttpStatusCode.Forbidden)); this.Client.SetAccessToken(Guid.NewGuid().ToString()); this.response = this.Client.PostAsync("/ifttt/v1/actions/play_single_media", content).Result; this.result = this.response.JsonBody <ErrorResource>(); }
public async Task RequestFriendship_ShouldReturnForbiddenResult_WhenWhenRequesterAndAddresseeIdAreTheSame() { // Arrange RequestFriendshipBody body = new RequestFriendshipBody { AddresseeId = 1 }; Claim expectedNameIdentifierClaim = new Claim(ClaimTypes.NameIdentifier, body.AddresseeId.ToString()); Mock <ClaimsPrincipal> userMock = new Mock <ClaimsPrincipal>(); userMock .Setup(m => m.FindFirst(ClaimTypes.NameIdentifier)) .Returns(expectedNameIdentifierClaim); FriendshipController controller = new FriendshipController(null, null) { ControllerContext = new ControllerContext { HttpContext = new DefaultHttpContext { User = userMock.Object } } }; // Act ActionResult <FriendshipResource> response = await controller.RequestFriendship(body); // Assert ObjectResult result = Assert.IsType <ObjectResult>(response.Result); ErrorResource error = Assert.IsType <ErrorResource>(result.Value); Assert.Equal(StatusCodes.Status403Forbidden, error.StatusCode); }
public async Task UpdateFriendshipStatus_ShouldReturnNotFound_WhenFriendshipDoesNotExist() { // Arrange const int friendshipId = 87921; UpdateFriendshipStatusBody model = new UpdateFriendshipStatusBody { FriendshipStatusId = FriendshipStatusId.Accepted }; Mock <IMediator> mediatorMock = new Mock <IMediator>(); mediatorMock .Setup(m => m.Send(It.IsAny <FriendshipExistsQuery>(), It.IsAny <CancellationToken>())) .ReturnsAsync(false); FriendshipController controller = new FriendshipController(mediatorMock.Object, null); // Act ActionResult response = await controller.UpdateFriendshipStatus(friendshipId, model); // Assert NotFoundObjectResult result = Assert.IsType <NotFoundObjectResult>(response); ErrorResource error = Assert.IsType <ErrorResource>(result.Value); Assert.Equal(StatusCodes.Status404NotFound, error.StatusCode); }
public async Task Login_ShouldReturnNotFoundResult_WhenCredentialsAreInvalid() { // Arrange LoginBody credentials = new LoginBody { UserNameOrEmail = "myUsername", Password = "******" }; Mock <IMediator> mediatorMock = new Mock <IMediator>(); mediatorMock .Setup(m => m.Send(It.IsAny <LoginCommand>(), It.IsAny <CancellationToken>())) .ReturnsAsync((AuthenticatedUserResource)null); MapperConfiguration mapperConfiguration = new MapperConfiguration(config => { config.CreateMap <LoginBody, LoginCommand>(); }); IMapper mapperMock = mapperConfiguration.CreateMapper(); SessionController controller = new SessionController(mediatorMock.Object, mapperMock); // Act ActionResult <AuthenticatedUserResource> response = await controller.Login(credentials); // Assert UnauthorizedObjectResult result = Assert.IsType <UnauthorizedObjectResult>(response.Result); ErrorResource error = Assert.IsType <ErrorResource>(result.Value); Assert.Equal(StatusCodes.Status401Unauthorized, error.StatusCode); }
public void AddError(string className, string Key, Enum Value) { if (string.IsNullOrEmpty(_BaseLanguage)) { _BaseLanguage = "VN"; } if (Errors == null) { Errors = new Dictionary <string, string>(); } string file = string.Format("{0}.{1}", _BaseLanguage, className); string path = string.Format("{0}.{1}.{2}", ErrorPath, Key, Value.ToString()); JToken token = ErrorResource.GetValueOrDefault(file)?.SelectToken(path); string content = token == null?Value.ToString() : token.ToString(); if (Errors.ContainsKey(Key)) { if (!Errors[Key].Contains(content)) { Errors[Key] += content; } } else { Errors.Add(Key, content); } }
/// <summary> /// 生成错误返回 /// </summary> /// <param name="context"></param> /// <returns></returns> public static IActionResult ProduceErrorResponse(ActionContext context) { var errors = context.ModelState.SelectMany(m => m.Value.Errors).Select(m => m.ErrorMessage).ToArray(); var response = new ErrorResource(messages: errors); return(new BadRequestObjectResult(response)); }
public static IActionResult ProduceErrorResponse(ActionContext context) { var errors = context.ModelState.GetErrorMessages(); var response = new ErrorResource(messages: errors); return(new BadRequestObjectResult(response)); }
public void contains_profile() { var errorResource = new ErrorResource(); var jToken = _mediaFormatter.Format(errorResource); jToken.SelectToken("_links.profile.href").Value<string>().ShouldEqual(Profiles.Error); }
public void contains_errors_array() { var errorResource = new ErrorResource(); var jToken = _mediaFormatter.Format(errorResource); jToken.SelectToken("_errors").Type.ShouldEqual(JTokenType.Array); }
private static HttpResponseMessage SetupErrorMessage(HttpRequestMessage request, HttpStatusCode code, ErrorResource errorRep) { var resp = request.CreateResponse(code, errorRep); resp.Content.Headers.ContentType = new MediaTypeHeaderValue(ErrorResource.ErrorProblemMediaType); return(resp); }
public void error_items_are_formatted_correctly() { var errorResource = new ErrorResource(); errorResource.Errors.Add(new ErrorEntryResource("a title", "a message")); var jToken = _mediaFormatter.Format(errorResource); jToken.SelectToken("_errors[0].title").Value<string>().ShouldEqual("a title"); jToken.SelectToken("_errors[0].message").Value<string>().ShouldEqual("a message"); }
public WhenGettingUserInfoWithInvalidAccessToken() { this.UserInfoResourceFactory.Create(Arg.Any <string>(), Arg.Any <CancellationToken>()) .Throws(new LinnApiException(HttpStatusCode.Forbidden)); this.Client.SetAccessToken(Guid.NewGuid().ToString()); this.response = this.Client.GetAsync("/ifttt/v1/user/info").Result; this.result = this.response.JsonBody <ErrorResource>(); }
public string GetErrorMessage(string path, string Value) { if (string.IsNullOrEmpty(_BaseLanguage)) { _BaseLanguage = "VN"; } JToken token = ErrorResource.GetValueOrDefault(_BaseLanguage).SelectToken(path + "." + Value); return(token?.Value <string>()); }
public override void Handle(ExceptionHandlerContext context) { var errorResponse = _transformer.Transform(context.Exception); var errorResource = new ErrorResource(); errorResource.Errors.Add(new ErrorEntryResource(errorResponse.Title, errorResponse.Message)); var resp = new HttpResponseMessage(errorResponse.HttpStatusCode) { Content = new ObjectContent(typeof(ErrorResource), errorResource, new HyperfriendlyJsonMediaTypeFormatter()) }; context.Result = new HyperfriendlyErrorMessageResult(resp); }
public WhenConfiguringDeviceIdForTurningOffASpecificDeviceWithInvalidAccessToken() { var request = new { }; var content = new StringContent(JsonConvert.SerializeObject(request)); this.LinnApiActions.GetDeviceNames(Arg.Any <string>(), Arg.Any <CancellationToken>()).Throws(new LinnApiException(HttpStatusCode.Forbidden)); this.Client.SetAccessToken(Guid.NewGuid().ToString()); this.response = this.Client.PostAsync("/ifttt/v1/actions/turn_off_device/fields/device_id/options", content).Result; this.result = this.response.JsonBody <ErrorResource>(); }
public WhenStartPlaylistOnASpecificDeviceWithMissingActionFields() { var request = new { ifttt_source = new { id = "2", url = "https://ifttt.com/myrecipes/personal/2" }, user = new { timezone = "Pacific Time (US & Canada)" } }; var content = new StringContent(JsonConvert.SerializeObject(request)); this.Client.SetAccessToken(this.AccessToken); this.response = this.Client.PostAsync("/ifttt/v1/actions/play_playlist", content).Result; this.result = this.response.JsonBody <ErrorResource>(); }
public async Task RequestFriendship_ShouldReturnForbiddenResult_WhenUserCombinationAlreadyExists() { // Arrange RequestFriendshipBody body = new RequestFriendshipBody { AddresseeId = 1 }; Claim expectedNameIdentifierClaim = new Claim(ClaimTypes.NameIdentifier, "2"); Mock <ClaimsPrincipal> userMock = new Mock <ClaimsPrincipal>(); userMock .Setup(m => m.FindFirst(ClaimTypes.NameIdentifier)) .Returns(expectedNameIdentifierClaim); Mock <IMediator> mediatorMock = new Mock <IMediator>(); mediatorMock .Setup(m => m.Send(It.IsAny <UserExistsQuery>(), It.IsAny <CancellationToken>())) .ReturnsAsync(true); mediatorMock .Setup(m => m.Send(It.IsAny <FriendshipCombinationExistsQuery>(), It.IsAny <CancellationToken>())) .ReturnsAsync(true); FriendshipController controller = new FriendshipController(mediatorMock.Object, null) { ControllerContext = new ControllerContext { HttpContext = new DefaultHttpContext { User = userMock.Object } } }; // Act ActionResult <FriendshipResource> response = await controller.RequestFriendship(body); // Assert ObjectResult result = Assert.IsType <ObjectResult>(response.Result); ErrorResource error = Assert.IsType <ErrorResource>(result.Value); Assert.Equal(StatusCodes.Status403Forbidden, error.StatusCode); }
public WhenInvokePinOnASpecificDeviceWithMissingPlaylistId() { var deviceId = Guid.NewGuid().ToString(); var request = new { actionFields = new { device_Id = deviceId }, ifttt_source = new { id = "2", url = "https://ifttt.com/myrecipes/personal/2" }, user = new { timezone = "Pacific Time (US & Canada)" } }; var content = new StringContent(JsonConvert.SerializeObject(request)); this.Client.SetAccessToken(this.AccessToken); this.response = this.Client.PostAsync("/ifttt/v1/actions/invoke_pin", content).Result; this.result = this.response.JsonBody <ErrorResource>(); }
public WhenTurningOffAllDevicesWithInvalidAccessToken() { var request = new { actionFields = new { }, ifttt_source = new { id = "2", url = "https://ifttt.com/myrecipes/personal/2" }, user = new { timezone = "Pacific Time (US & Canada)" } }; var content = new StringContent(JsonConvert.SerializeObject(request)); this.LinnApiActions.TurnOffAllDevices(Arg.Any <string>(), Arg.Any <CancellationToken>()).Throws(new LinnApiException(HttpStatusCode.Forbidden)); this.Client.SetAccessToken(Guid.NewGuid().ToString()); this.response = this.Client.PostAsync("/ifttt/v1/actions/turn_off_all_devices", content).Result; this.result = this.response.JsonBody <ErrorResource>(); }
public async Task GetUserProfile_ShouldReturnNotFound_WhenUserDoesNotExist() { // Arrange const int userId = 121234; _mediatorMock .Setup(m => m.Send(It.IsAny <GetUserProfileQuery>(), It.IsAny <CancellationToken>())) .ReturnsAsync((UserProfileResource)null); UserController controller = new UserController(_mediatorMock.Object, null); // Act ActionResult <UserProfileResource> response = await controller.GetUserProfile(userId); // Assert NotFoundObjectResult result = Assert.IsType <NotFoundObjectResult>(response.Result); ErrorResource error = Assert.IsType <ErrorResource>(result.Value); Assert.Equal(StatusCodes.Status404NotFound, error.StatusCode); }
public WhenUnmutingASpecificDeviceWithMissingDeviceId() { var deviceId = Guid.NewGuid().ToString(); var request = new { actionFields = new { }, ifttt_source = new { id = "2", url = "https://ifttt.com/myrecipes/personal/2" }, user = new { timezone = "Pacific Time (US & Canada)" } }; var content = new StringContent(JsonConvert.SerializeObject(request)); this.LinnApiActions.MuteDevice(this.AccessToken, deviceId, Arg.Any <CancellationToken>()).Returns("id"); this.Client.SetAccessToken(this.AccessToken); this.response = this.Client.PostAsync("/ifttt/v1/actions/unmute_device", content).Result; this.result = this.response.JsonBody <ErrorResource>(); }
public async Task GetMessageById_ShouldReturnNotFoundResult_WhenMessageDoesNotExist() { // Arrange const int messageId = 431; _mediatorMock .Setup(m => m.Send(It.IsAny <MessageExistsQuery>(), It.IsAny <CancellationToken>())) .ReturnsAsync(false); MessageController controller = new MessageController(null, _mediatorMock.Object); // Act ActionResult <MessageResource> response = await controller.GetMessageById(messageId); // Assert NotFoundObjectResult result = Assert.IsType <NotFoundObjectResult>(response.Result); ErrorResource error = Assert.IsType <ErrorResource>(result.Value); Assert.NotNull(error); Assert.Equal(StatusCodes.Status404NotFound, error.StatusCode); }
public async Task CreateUserAccount_ShouldReturnForbiddenResult_WhenUserNameOrEmailAlreadyExists() { // Arrange CreateAccountBody credentials = new CreateAccountBody { UserName = "", Email = "", Password = "" }; _mediatorMock .Setup(m => m.Send(It.IsAny <UserNameOrEmailExistsQuery>(), It.IsAny <CancellationToken>())) .ReturnsAsync(true); UserController controller = new UserController(_mediatorMock.Object, _mapperMock); // Act ActionResult response = await controller.CreateAccount(credentials); // Assert ObjectResult result = Assert.IsType <ObjectResult>(response); ErrorResource error = Assert.IsType <ErrorResource>(result.Value); Assert.Equal(StatusCodes.Status403Forbidden, error.StatusCode); }
public async Task GetFriendshipById_ShouldReturnNotFoundResult_WhenFriendshipIsNotFound() { // Arrange const int friendshipId = 632; Mock <IMediator> mediatorMock = new Mock <IMediator>(); mediatorMock .Setup(m => m.Send(It.IsAny <GetFriendshipByIdQuery>(), It.IsAny <CancellationToken>())) .ReturnsAsync((FriendshipResource)null); FriendshipController controller = new FriendshipController(mediatorMock.Object, null); // Act ActionResult <FriendshipResource> response = await controller.GetFriendshipById(friendshipId); // Assert NotFoundObjectResult result = Assert.IsType <NotFoundObjectResult>(response.Result); ErrorResource error = Assert.IsType <ErrorResource>(result.Value); Assert.Equal(StatusCodes.Status404NotFound, error.StatusCode); }
public async Task GetMembershipsByGroup_ShouldReturnNotFoundResult_WhenGroupDoesNotExist() { // Arrange const int groupId = 842; Mock <IMediator> mediatorMock = new Mock <IMediator>(); mediatorMock .Setup(m => m.Send(It.IsAny <GroupExistsQuery>(), It.IsAny <CancellationToken>())) .ReturnsAsync(false); GroupController controller = new GroupController(mediatorMock.Object, null); // Act ActionResult <IEnumerable <GroupMembershipResource> > response = await controller.GetMembershipsByGroup(groupId); // Assert NotFoundObjectResult result = Assert.IsType <NotFoundObjectResult>(response.Result); ErrorResource error = Assert.IsType <ErrorResource>(result.Value); Assert.Equal(StatusCodes.Status404NotFound, error.StatusCode); }