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);
}
