public void GetAccount_AllParametersOk_AccountExists()
{
_mockService.Setup(service => service.GetAccount(It.IsAny <string>()))
.Returns(new Account {
AccountID = "12345", Password = "******"
});
AccountRequestBody request = new AccountRequestBody()
{
AccountId = "12345"
};
var actionResult = _controller.GetAccount(request);
Assert.IsType <ActionResult <AccountResponseBody> >(actionResult);
ConflictObjectResult conflictResult = (ConflictObjectResult)actionResult.Result;
Assert.IsType <AccountResponseBody>(conflictResult.Value);
AccountResponseBody responseBody = (AccountResponseBody)conflictResult.Value;
Assert.False(responseBody.success);
Assert.Null(responseBody.password);
Assert.Equal("Account exists", responseBody.description);
}
public void OnException(ExceptionContext context)
{
if (context.Exception is AcmeException acmeException)
{
_logger.LogDebug($"Detected {acmeException.GetType()}. Converting to BadRequest.");
#if DEBUG
_logger.LogError(context.Exception, "AcmeException detected.");
#endif
ObjectResult result;
if (acmeException is ConflictRequestException)
{
result = new ConflictObjectResult(acmeException.GetHttpError());
}
else if (acmeException is NotAllowedException)
{
result = new UnauthorizedObjectResult(acmeException.GetHttpError());
}
else if (acmeException is NotFoundException)
{
result = new NotFoundObjectResult(acmeException.GetHttpError());
}
else
{
result = new BadRequestObjectResult(acmeException.GetHttpError());
}
result.ContentTypes.Add("application/problem+json");
context.Result = result;
}
}
public async Task <ObjectResult> RegisterAsync(CancellationToken cancellationToken = default)
{
var userFromIdentity = GetUserFromIdentity();
try
{
var user = await _userService.RegisterAsync(userFromIdentity, cancellationToken);
var userViewModel = _mapper.Map <UserInfoViewModel>(user);
var result = new OkObjectResult(userViewModel);
return(result);
}
catch (UserEmailNotVerifiedException)
{
var modelState = new ModelStateDictionary();
modelState.AddModelError(nameof(UserInfo.IsEmailVerified), "Email is not verified");
var badResult = new BadRequestObjectResult(modelState);
return(badResult);
}
catch (UserDuplicateInsertionException)
{
var modelState = new ModelStateDictionary();
modelState.AddModelError(nameof(UserInfo.GoogleId), "User already registered");
var badResult = new ConflictObjectResult(modelState);
return(badResult);
}
}
public void RegisterTestUsernameTaken()
{
_userService.Setup(us => us.AddUser(It.IsAny<UserModel>())).Returns(false);
ConflictObjectResult result = _userController.Register(new UserDto() { Password = "******", Username = "******" }) as ConflictObjectResult;
Assert.IsInstanceOfType(result, typeof(ConflictObjectResult));
Assert.AreEqual("Username already taken", result.Value);
}
public void ConflictObjectResultHasStatusCode409()
{
// Arrange
var result = new ConflictObjectResult("Some Message");
// Assert
Assert.Equal(409, result.StatusCode);
}
public void ConflictObjectResult_SetsStatusCodeAndValue()
{
// Arrange & Act
var obj = new object();
var conflictObjectResult = new ConflictObjectResult(obj);
// Assert
Assert.Equal(StatusCodes.Status409Conflict, conflictObjectResult.StatusCode);
Assert.Equal(obj, conflictObjectResult.Value);
}
public void ErrorAs_Null_ShouldFail()
{
ActionResult result = new ConflictObjectResult(null as object);
var failureMessage = FailureMessageHelper.ExpectedContextTypeXButFoundNull(
"ConflictObjectResult.Error", typeof(object));
Action a = () => result.Should().BeConflictObjectResult().ErrorAs <object>();
a.Should().Throw <Exception>().WithMessage(failureMessage);
}
public void ConflictObjectResult_ModelState_SetsStatusCodeAndValue()
{
// Arrange & Act
var conflictObjectResult = new ConflictObjectResult(new ModelStateDictionary());
// Assert
Assert.Equal(StatusCodes.Status409Conflict, conflictObjectResult.StatusCode);
var errors = Assert.IsType <SerializableError>(conflictObjectResult.Value);
Assert.Empty(errors);
}
public async Task UpdateUser_ServicesReturnsConflict_ReturnsConflictResponse()
{
// arrange
_mockService.Setup(s => s.UpdateUser(It.IsAny <int>(), It.IsAny <string>()))
.ReturnsAsync(new ServiceResponse {
IsError = true, ResponseType = ServiceResponseType.Conflict, ErrorMessage = "ERROR"
});
// act
IActionResult response = await _controller.UpdateUser("1", TestData.GetUserRequest());
ConflictObjectResult objectResponse = response as ConflictObjectResult;
// assert
Assert.NotNull(objectResponse.Value);
}
public async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Function, "GET", "POST", Route = "subscription")] HttpRequest req,
ILogger log)
{
string name = req.Query["name"];
var cleanedName = name.Trim(' ').Replace(' ', '-').ToLowerInvariant();
if (string.IsNullOrEmpty(cleanedName))
{
return(new BadRequestObjectResult("Please provide your name on the query string (?name=YOURNAME)"));
}
var resourceGroup = Environment.GetEnvironmentVariable("Servicebus_ResourceGroup");
var servicebusNamespace = Environment.GetEnvironmentVariable("Servicebus_Namespace");
var servicebusTopic = Environment.GetEnvironmentVariable("Servicebus_Topic");
ActionResult result = null;
try
{
if (req.Method == HttpMethods.Get)
{
var subs = await _serviceBusManager.Inner.Subscriptions.ListByTopicAsync(
resourceGroup,
servicebusNamespace,
servicebusTopic);
var subList = subs.AsEnumerable();
result = new OkObjectResult(subList.Where(sub => sub.Name.StartsWith(cleanedName)));
}
else if (req.Method == HttpMethods.Post)
{
result = await CreateTopicSubscription(
resourceGroup,
servicebusNamespace,
servicebusTopic,
cleanedName);
}
}
catch (Exception ex)
{
result = new ConflictObjectResult(ex.Message);
}
return(result);
}
/// <summary>
/// Rebuilds the index
/// </summary>
/// <param name="indexName"></param>
/// <returns></returns>
public IActionResult PostRebuildIndex(string indexName)
{
ActionResult validate = ValidateIndex(indexName, out IIndex? index);
if (!validate.IsSuccessStatusCode())
{
return(validate);
}
validate = ValidatePopulator(index !);
if (!validate.IsSuccessStatusCode())
{
return(validate);
}
_logger.LogInformation("Rebuilding index '{IndexName}'", indexName);
//remove it in case there's a handler there already
index !.IndexOperationComplete -= Indexer_IndexOperationComplete;
//now add a single handler
index.IndexOperationComplete += Indexer_IndexOperationComplete;
try
{
var cacheKey = "temp_indexing_op_" + index.Name;
//put temp val in cache which is used as a rudimentary way to know when the indexing is done
_runtimeCache.Insert(cacheKey, () => "tempValue", TimeSpan.FromMinutes(5));
_indexRebuilder.RebuildIndex(indexName);
return(new OkResult());
}
catch (Exception ex)
{
//ensure it's not listening
index.IndexOperationComplete -= Indexer_IndexOperationComplete;
_logger.LogError(ex, "An error occurred rebuilding index");
var response = new ConflictObjectResult(
"The index could not be rebuilt at this time, most likely there is another thread currently writing to the index. Error: {ex}");
HttpContext.SetReasonPhrase("Could Not Rebuild");
return(response);
}
}
public void GuessWordNoGame()
{
//prep auth
string username = "******";
var mockContext = new Mock <HttpContext>(MockBehavior.Strict);
mockContext.SetupGet(hc => hc.User.Identity.Name).Returns(username);
_gameController.ControllerContext = new ControllerContext()
{
HttpContext = mockContext.Object
};
ConflictObjectResult result = _gameController.GuessWord(new GuessWriteDto()) as ConflictObjectResult;
Assert.IsInstanceOfType(result, typeof(ConflictObjectResult));
Assert.AreEqual("User doesn't currently have any game.", result.Value);
}
public static IActionResult AsActionResult(this Exception ex)
{
IActionResult result;
if (ex is ArgumentException)
{
result = new ConflictObjectResult(new B2CResponseContent(
ex.Message,
HttpStatusCode.Conflict));
}
else
{
result = new BadRequestObjectResult(new B2CResponseContent(
ex.Message,
HttpStatusCode.InternalServerError));
}
return(result);
}
public void When_HandlingDomainException_Expect_ConflictObjectResult()
{
// Arrange
TestDomainException exception = new TestDomainException(Guid.NewGuid().ToString());
ExceptionContext context = new ExceptionContext(this.actionContext, new List <IFilterMetadata>())
{
Exception = exception,
};
ExceptionFilter exceptionFilter = new ExceptionFilter(new MockProblemDetailsFactory());
// Act
exceptionFilter.OnException(context);
// Assert
ConflictObjectResult objectResult = Assert.IsType <ConflictObjectResult>(context.Result);
ProblemDetails problemDetails = Assert.IsType <ProblemDetails>(objectResult.Value);
Assert.Equal((int)HttpStatusCode.Conflict, problemDetails.Status);
Assert.Equal(exception.Message, problemDetails.Detail);
}
/// <summary>
/// DB操作結果をActionResultに変換する
/// </summary>
/// <typeparam name="T">Dtoクラス型</typeparam>
/// <param name="resultCode">結果コード</param>
/// <param name="message">結果メッセージ</param>
/// <param name="dto">response用Dtoクラスパラメータ</param>
/// <returns>結果コードに対応するActionResult</returns>
public static ActionResult ConvertToActionResult <T>(ResultCode resultCode, string message, T dto)
{
ActionResult action;
switch (resultCode)
{
case ResultCode.Succeed:
action = new OkObjectResult(dto);
break;
case ResultCode.Conflict:
//// Swagger定義に合わせて、エラー時のBodyには何も設定しない
action = new ConflictObjectResult(string.Empty);
break;
case ResultCode.DoStartedDelivery:
action = new StatusCodeResult(StatusCodes.Status403Forbidden); // ObjectResultに403相当のものがない
break;
case ResultCode.NotFound:
//// Swagger定義に合わせて、エラー時のBodyには何も設定しない
action = new NotFoundObjectResult(string.Empty);
break;
case ResultCode.ParameterError:
//// Swagger定義に合わせて、エラー時のBodyには何も設定しない
action = new BadRequestObjectResult(string.Empty);
break;
default:
action = new StatusCodeResult(StatusCodes.Status500InternalServerError);
break;
}
return(action);
}
/// <summary>
/// Creates an <see cref="IActionResult"/> from a <see cref="HttpResponseMessage"/>.
/// </summary>
/// <param name="message">The <see cref="HttpResponseMessage"/> to convert.</param>
/// <param name="location">The location of the created resource. This location is used only when a <see cref="HttpStatusCode.Created"/> is handled.</param>
/// <param name="authenticationSchemes">The authentication schemes to challenge. This location is used only when a <see cref="HttpStatusCode.Forbidden"/> is handled.</param>
/// <param name="authenticationProperties"><see cref="AuthenticationProperties"/> used to perform the authentication challenge. This location is used only when a <see cref="HttpStatusCode.Forbidden"/> is handled.</param>
/// <param name="objectResultTypeIfNotSupported">The type of the <see cref="ObjectResult"/> to convert to if the <see cref="HttpResponseMessage.StatusCode"/> of the specified <paramref name="message"/> if not managed.</param>
/// <returns>
/// An <see cref="IActionResult"/>:
/// - containing the stringified <see cref="HttpResponseMessage.Content"/> of the specified <paramref name="message"/>.<para/>
/// - having its <see cref="IActionResult.StatusCode"/> property set to the <see cref="HttpResponseMessage.StatusCode"/> of the specified <paramref name="message"/>.
/// </returns>
/// <remarks>
/// Only the following status codes are managed:<para/>
/// - HttpStatusCode.BadGateway<para/>
/// - HttpStatusCode.BadRequest<para/>
/// - HttpStatusCode.Conflict<para/>
/// - HttpStatusCode.OK<para/>
/// - HttpStatusCode.NotFound<para/>
/// - HttpStatusCode.Unauthorized<para/>
/// - HttpStatusCode.Created<para/>
/// - HttpStatusCode.NoContent<para/>
/// - HttpStatusCode.Forbidden<para/>
/// - UnprocessableEntity (422)
/// </remarks>
public static async Task <IActionResult> ToActionResultAsync(this HttpResponseMessage message,
List <string>?authenticationSchemes = null,
Microsoft.AspNetCore.Authentication.AuthenticationProperties?authenticationProperties = null,
Uri?location = null,
Type?objectResultTypeIfNotSupported = null)
{
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
var messageContent = await message.Content.ReadAsStringAsync();
ObjectResult?resultingObjectResult;
switch (message.StatusCode)
{
case HttpStatusCode.OK:
resultingObjectResult = new OkObjectResult(messageContent);
break;
case HttpStatusCode.Created:
resultingObjectResult = new CreatedResult(location, messageContent);
break;
case HttpStatusCode.NotFound:
resultingObjectResult = new NotFoundObjectResult(messageContent);
break;
case HttpStatusCode.BadRequest:
resultingObjectResult = new BadRequestObjectResult(messageContent);
break;
case HttpStatusCode.Unauthorized:
resultingObjectResult = new UnauthorizedObjectResult(messageContent);
break;
case HttpStatusCode.BadGateway:
resultingObjectResult = new BadRequestObjectResult(messageContent);
break;
case HttpStatusCode.Conflict:
resultingObjectResult = new ConflictObjectResult(messageContent);
break;
case HttpStatusCode.NoContent:
return(new NoContentResult());
case HttpStatusCode.Forbidden:
return(new ForbidResult(authenticationSchemes, authenticationProperties));
case HttpStatusCode.InternalServerError:
return(new StatusCodeResult((int)HttpStatusCode.InternalServerError));
default:
if ((int)message.StatusCode == 422)
{
resultingObjectResult = new UnprocessableEntityObjectResult(messageContent);
}
else
{
objectResultTypeIfNotSupported ??= typeof(OkObjectResult);
resultingObjectResult = Activator.CreateInstance(objectResultTypeIfNotSupported) as ObjectResult;
if (resultingObjectResult == null)
{
throw new InvalidOperationException($"Can not create an instance of the given type {objectResultTypeIfNotSupported}. Should be an {nameof(ObjectResult)}");
}
resultingObjectResult.Value = messageContent;
}
break;
}
resultingObjectResult.StatusCode = (int)message.StatusCode;
return(resultingObjectResult);
}
public void BeConflictObjectResult_GivenConflictObject_ShouldPass()
{
ActionResult result = new ConflictObjectResult("foo");
result.Should().BeConflictObjectResult();
}
public async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Function, "GET", "POST", Route = "subscription")] HttpRequest req,
ILogger log)
{
string name = req.Query["name"];
var cleanedName = name.Trim(' ').Replace(' ', '-').ToLowerInvariant();
if (string.IsNullOrEmpty(cleanedName))
{
return(ActionResultBuilder.GetBadRequest());
}
var resourceGroup = Environment.GetEnvironmentVariable("Servicebus_ResourceGroup");
var servicebusNamespace = Environment.GetEnvironmentVariable("Servicebus_Namespace");
var servicebusTopic = Environment.GetEnvironmentVariable("Servicebus_Topic");
var apiManagementSubscriptionKey = Environment.GetEnvironmentVariable("ApiManagement_SubscriptionKey");
var servicebusConnectionStringListenOnly = Environment.GetEnvironmentVariable("Servicebus_ListenOnlyKey");
ActionResult result = null;
try
{
var matchingSubs = await _topicSubscription.GetTopicSubscriptionsForName(
resourceGroup,
servicebusNamespace,
servicebusTopic,
cleanedName);
if (req.Method == HttpMethods.Get)
{
result = ActionResultBuilder.GetOkResultWithSubscriptions(
servicebusConnectionStringListenOnly,
apiManagementSubscriptionKey,
servicebusTopic,
matchingSubs.Select(s => s.Name));
}
else if (req.Method == HttpMethods.Post)
{
if (matchingSubs.Any())
{
result = ActionResultBuilder.GetOkResultWithSubscriptions(
servicebusConnectionStringListenOnly,
apiManagementSubscriptionKey,
servicebusTopic,
matchingSubs.Select(s => s.Name));
}
else
{
var subName = await _topicSubscription.CreateTopicSubscription(
resourceGroup,
servicebusNamespace,
servicebusTopic,
cleanedName);
return(ActionResultBuilder.GetOkResultWithSubscriptions(
servicebusConnectionStringListenOnly,
apiManagementSubscriptionKey,
servicebusTopic,
new List <string> {
subName
}));
}
}
}
catch (Exception ex)
{
result = new ConflictObjectResult(ex.Message);
}
return(result);
}
