public async Task PostFromAnAuthenticatedUserWithValidModelState_UpdatesAccountAndReturnsEmptyResult()
{
TestableAccountController controller = TestableAccountController.Create();
const int currentUserAccountId = 1;
const string newDisplayName = "Bobo";
controller.MockContextService.Setup(x => x.CurrentUserAccountId).Returns(currentUserAccountId);
var account = new Account {
Id = currentUserAccountId,
CreatedOn = DateTime.Today,
DisplayName = "dude",
IsAutoSetup = true,
Email = "*****@*****.**",
Reputation = 123
};
controller.AccountRepository.Accounts.Add(account);
EmptyResult result = await controller.Update(new AccountUpdateViewModel { DisplayName = newDisplayName }) as EmptyResult;
Assert.IsNotNull(result);
Assert.AreEqual(newDisplayName, account.DisplayName);
Assert.IsFalse(account.IsAutoSetup);
Assert.AreEqual(1, controller.AccountRepository.NumberOfTimesUpdateWasInvoked);
}
public async Task AnUnAuthenticatedUserPostsTokenAndAccountIdThatAreValid_MarksAuthenticationTokenAsUsed()
{
TestableAccountController controller = TestableAccountController.Create();
var systemTime = new DateTime(2017, 5, 1, 7, 31, 50);
controller.MockContextService.Setup(x => x.CurrentUserIsAuthenticated).Returns(false);
controller.MockSystemClock.Setup(x => x.UtcNow).Returns(systemTime);
const int accountId = 1;
const string token = "totally-fake-token";
controller.AuthenticationTokenRepository.AuthenticationTokens.Add(new AuthenticationToken {
Id = Guid.NewGuid(),
AccountId = accountId,
Token = token,
IsUsed = false
});
EmptyResult result = await controller.Authenticate(new AuthenticationViewModel { AuthenticationToken = token, AccountId = accountId }) as EmptyResult;
AuthenticationToken authenticationToken = controller.AuthenticationTokenRepository.AuthenticationTokens.FirstOrDefault();
Assert.IsNotNull(result);
Assert.IsNotNull(authenticationToken);
Assert.IsTrue(authenticationToken.IsUsed);
Assert.AreEqual(systemTime, authenticationToken.UsedOn);
Assert.AreEqual(1, controller.AuthenticationTokenRepository.NumberOfTimesUpdateWasInvoked);
}
public virtual async Task <bool> BuyProduct(BuyProductReq buyProductReq, string userName)
{
bool payResult = await Pay(buyProductReq, userName);
if (!payResult)
{
return(false);
}
// buy product id gets validated int the overwritten Pay method
List <PurchaseItemReq> purchaseItems = new List <PurchaseItemReq>
{
new PurchaseItemReq
{
Price = buyProductReq.Price,
Username = userName,
StoreItemId = buyProductReq.Id,
Quantity = buyProductReq.Quantity,
}
};
EmptyResult checkoutResult = await _storeAPICalls.CheckoutBasketAsync(purchaseItems);
if (checkoutResult == null)
{
return(false);
}
return(true);
}
public override Task ExecuteResultAsync(ActionContext context)
{
EnsureArg.IsNotNull(context, nameof(context));
HttpResponse response = context.HttpContext.Response;
if (StatusCode.HasValue)
{
response.StatusCode = (int)StatusCode.Value;
}
foreach (KeyValuePair <string, StringValues> header in Headers)
{
response.Headers.Add(header);
}
ActionResult result;
if (Result == null)
{
result = new EmptyResult();
}
else
{
result = new ObjectResult(GetResultToSerialize());
}
return(result.ExecuteResultAsync(context));
}
[ActionName("Login")] //该注解可以更改路由中Action名称
public ActionResult Login(User model)
{
//if (!ModelState.IsValid)
//{
// //用户输入服务端验证,此处处理验证不通过的提示代码 本例略过
// return View("Login");
//}
string result = null;
string sql = "select* from Users where UserName = '******' and PassWord = '******'";
User user = dbs.Select_UserInfo(sql); //执行Reader查询，存入dr
if (user.RoleNum != null & user.RoleNum != "")
{
if (user.RoleNum == "1")
{
result = "Admin,Edit,Select";
}
else if (user.RoleNum == "2")
{
result = "Edit,Select";
}
else if (user.RoleNum == "3")
{
result = "Select";
}
}
if (result == null)
{
//ViewData["msg"] = "登陆失败";
//用户名或者密码不正确的提示代码 本例略过
return(Content("<script>alert('UserName or Password Error !');history.go(-1);</script>"));
}
else
{
//if () { } else {
//用户登陆核心代码
FormsAuthenticationTicket authTicket = new FormsAuthenticationTicket(
1,
model.UserName,
DateTime.Now,
DateTime.Now.AddHours(12), //记住密码的时间
model.RememberMe, //是否保存cookie 记住密码
result //获取的用户权限列表 用逗号分割的字符串
);
string encryptedTickt = FormsAuthentication.Encrypt(authTicket);
HttpCookie authCookie = new HttpCookie(FormsAuthentication.FormsCookieName, encryptedTickt);
Response.Cookies.Add(authCookie);
Response.Redirect("/PCTron/", true);
ActionResult empty = new EmptyResult();
//return empty;
return(RedirectToAction("Indexs"));
}
}
private void OnUpdateAvatarURL(EmptyResult result)
{
if (GameObject.Find("MainMenu-Canvas") != null)
{
GameObject.Find("MainMenu-Canvas").GetComponent <MainMenu> ().HideWaitIndicator();
}
Destroy(this.gameObject);
}
private void ValidateSuccess(EmptyResult updateResult, string updateProfileName)
{
if (!updateResult.IsSuccess)
{
var errorDetails = string.Join(", ", updateResult.Errors.Select(e => e.Code));
throw new ProfileServiceTestException($"Failed to {updateProfileName}. Reason: {errorDetails}");
}
}
public static async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Anonymous, "put", Route = "news/{id}")] HttpRequest req,
[CosmosDB(ConnectionStringSetting = "CosmosDBConnection")] DocumentClient newsDb,
ILogger log,
string id)
{
log.LogInformation("Started adding news item.");
var streamReader = new StreamReader(req.Body);
var requestBody = await streamReader.ReadToEndAsync();
var data = JsonConvert.DeserializeObject <NewsModel>(requestBody);
if (data is null)
{
var error = "Couldn't deserialize request object.";
log.LogError(error);
return(new NotFoundObjectResult(error));
}
var collectionUri = UriFactory.CreateDocumentCollectionUri("News", "NewsFeed");
var newsItem = newsDb.CreateDocumentQuery(collectionUri)
.FirstOrDefault(t => t.Id == id);
if (newsItem is null)
{
log.LogError("Couldn't find requested news item.");
return(new NotFoundResult());
}
newsItem.SetPropertyValue("Date", data.Date);
newsItem.SetPropertyValue("ShortDescription", data.ShortDescription);
newsItem.SetPropertyValue("FullText", data.FullText);
newsItem.SetPropertyValue("SourceLabel", data.SourceLabel);
newsItem.SetPropertyValue("PreviewSource", data.PreviewSource);
newsItem.SetPropertyValue("Attachments", data.Attachments);
newsItem.SetPropertyValue("Tags", data.Tags);
IActionResult result = new EmptyResult();
await newsDb.ReplaceDocumentAsync(newsItem)
.ContinueWith(t =>
{
if (t.IsFaulted || t.IsCanceled)
{
var error = "Couldn't replace news item. Perhaps, data has incorrect structure.";
log.LogError(error);
result = new BadRequestObjectResult(error);
}
if (t.IsCompletedSuccessfully)
{
log.LogInformation("Replaced news item: {data}", data);
result = new OkObjectResult(newsItem);
}
});
return(result);
}
private static IActionResult GetResultFromActionResult(IActionResult actionResult)
{
return(actionResult switch
{
StatusCodeResult result => GetResultFromCondition(IsSuccessful(result.StatusCode)),
ObjectResult result => GetResultFromObjectResult(result),
EmptyResult _ => GetResultFromCondition(true),
_ => actionResult
});
protected override void FinalizeSetUp()
{
_actionResultFactory = MockFor <ISitemapActionResultFactory>();
_sitemapProvider = new SitemapProvider(_actionResultFactory.Object);
_httpContext = MockFor <HttpContextBase>();
_config = MockFor <ISitemapConfiguration <SampleData> >();
_expectedResult = new EmptyResult();
}
public static EmptyResult GetInstance()
{
if (instance == null)
{
lock (sync)
{
return(instance = new EmptyResult());
}
}
return(instance);
}
public void GetPackageReturnsCacheablePackageIfAllowCacheIsTrue()
{
//Arrange
var package = new Package();
const string packageHash = "1234fe";
package.Hash = packageHash;
var actionResult = new EmptyResult();
var packageSvc = new Mock <IPackageService>(MockBehavior.Strict);
packageSvc.Setup(p => p.FindPackageByIdAndVersion("Baz", "1.0.1", false)).Returns(package).Verifiable();
packageSvc.Setup(p => p.AddDownloadStatistics(package, "Foo", "Qux")).Verifiable();
var packageFileSvc = new Mock <IPackageFileService>(MockBehavior.Strict);
packageFileSvc.SetupGet(fs => fs.AllowCachingOfPackage).Returns(true);
packageFileSvc.Setup(s => s.CreateDownloadPackageActionResult(package)).Returns(actionResult).Verifiable();
var userSvc = new Mock <IUserService>(MockBehavior.Strict);
var httpRequest = new Mock <HttpRequestBase>(MockBehavior.Strict);
httpRequest.SetupGet(r => r.UserHostAddress).Returns("Foo");
httpRequest.SetupGet(r => r.UserAgent).Returns("Qux");
var httpContext = new Mock <HttpContextBase>(MockBehavior.Strict);
httpContext.SetupGet(c => c.Request).Returns(httpRequest.Object);
var httpCache = new Mock <HttpCachePolicyBase>(MockBehavior.Strict);
httpCache.Setup(hc => hc.SetETag(packageHash)).Verifiable();
httpCache.Setup(hc => hc.SetCacheability(HttpCacheability.Public)).Verifiable();
httpCache.Setup(hc => hc.SetProxyMaxAge(It.IsAny <TimeSpan>())).Verifiable();
var httpResponse = new Mock <HttpResponseBase>(MockBehavior.Strict);
httpResponse.SetupGet(res => res.Cache).Returns(httpCache.Object);
var controller = CreateController(userSvc: userSvc, packageSvc: packageSvc, fileService: packageFileSvc);
var controllerContext = new ControllerContext(new RequestContext(httpContext.Object, new RouteData()), controller);
controller.ControllerContext = controllerContext;
httpContext.SetupGet(c => c.Response).Returns(httpResponse.Object);
//Act
var result = controller.GetPackage("Baz", "1.0.1");
//Assert
Assert.Equal(actionResult, result);
httpCache.Verify();
}
public void Login_Gmail()
{
string uriGoogleCallBack = Request.Url.GetLeftPart(UriPartial.Authority) + "/Authentication/Login_GmailCallback";
ActionResult action = new EmptyResult();
string Url = "https://accounts.google.com/o/oauth2/auth?";
StringBuilder UrlBuilder = new StringBuilder(Url);
UrlBuilder.Append("client_id=" + googleClientID);
UrlBuilder.Append("&redirect_uri=" + uriGoogleCallBack);
UrlBuilder.Append("&response_type=code");
UrlBuilder.Append("&scope=" + "https://www.googleapis.com/auth/userinfo.email");
Response.Redirect(UrlBuilder.ToString(), false);
}
public async Task InvokeAction_InvokesAsyncActionFilter_ShortCircuit_WithResult()
{
// Arrange
var result = new EmptyResult();
ActionExecutedContext context = null;
var actionFilter1 = new Mock<IActionFilter>(MockBehavior.Strict);
actionFilter1.Setup(f => f.OnActionExecuting(It.IsAny<ActionExecutingContext>())).Verifiable();
actionFilter1
.Setup(f => f.OnActionExecuted(It.IsAny<ActionExecutedContext>()))
.Callback<ActionExecutedContext>(c => context = c)
.Verifiable();
var actionFilter2 = new Mock<IAsyncActionFilter>(MockBehavior.Strict);
actionFilter2
.Setup(f => f.OnActionExecutionAsync(It.IsAny<ActionExecutingContext>(), It.IsAny<ActionExecutionDelegate>()))
.Returns<ActionExecutingContext, ActionExecutionDelegate>((c, next) =>
{
// Notice we're not calling next
c.Result = result;
return Task.FromResult(true);
})
.Verifiable();
var actionFilter3 = new Mock<IActionFilter>(MockBehavior.Strict);
var resultFilter = new Mock<IResultFilter>(MockBehavior.Strict);
resultFilter.Setup(f => f.OnResultExecuting(It.IsAny<ResultExecutingContext>())).Verifiable();
resultFilter.Setup(f => f.OnResultExecuted(It.IsAny<ResultExecutedContext>())).Verifiable();
var invoker = CreateInvoker(new IFilterMetadata[]
{
actionFilter1.Object,
actionFilter2.Object,
actionFilter3.Object,
resultFilter.Object,
});
// Act
await invoker.InvokeAsync();
// Assert
actionFilter1.Verify(f => f.OnActionExecuting(It.IsAny<ActionExecutingContext>()), Times.Once());
actionFilter1.Verify(f => f.OnActionExecuted(It.IsAny<ActionExecutedContext>()), Times.Once());
actionFilter2.Verify(
f => f.OnActionExecutionAsync(It.IsAny<ActionExecutingContext>(), It.IsAny<ActionExecutionDelegate>()),
Times.Once());
resultFilter.Verify(f => f.OnResultExecuting(It.IsAny<ResultExecutingContext>()), Times.Once());
resultFilter.Verify(f => f.OnResultExecuted(It.IsAny<ResultExecutedContext>()), Times.Once());
Assert.True(context.Canceled);
Assert.Same(context.Result, result);
}
public async Task InvokeAction_InvokesActionFilter_ShortCircuit()
{
// Arrange
var result = new EmptyResult();
ActionExecutedContext context = null;
var actionFilter1 = new Mock<IActionFilter>(MockBehavior.Strict);
actionFilter1.Setup(f => f.OnActionExecuting(It.IsAny<ActionExecutingContext>())).Verifiable();
actionFilter1
.Setup(f => f.OnActionExecuted(It.IsAny<ActionExecutedContext>()))
.Callback<ActionExecutedContext>(c => context = c)
.Verifiable();
var actionFilter2 = new Mock<IActionFilter>(MockBehavior.Strict);
actionFilter2
.Setup(f => f.OnActionExecuting(It.IsAny<ActionExecutingContext>()))
.Callback<ActionExecutingContext>(c => c.Result = result)
.Verifiable();
var actionFilter3 = new Mock<IActionFilter>(MockBehavior.Strict);
var resultFilter = new Mock<IResultFilter>(MockBehavior.Strict);
resultFilter.Setup(f => f.OnResultExecuting(It.IsAny<ResultExecutingContext>())).Verifiable();
resultFilter.Setup(f => f.OnResultExecuted(It.IsAny<ResultExecutedContext>())).Verifiable();
var invoker = CreateInvoker(new IFilterMetadata[]
{
actionFilter1.Object,
actionFilter2.Object,
actionFilter3.Object,
resultFilter.Object,
});
// Act
await invoker.InvokeAsync();
// Assert
actionFilter1.Verify(f => f.OnActionExecuting(It.IsAny<ActionExecutingContext>()), Times.Once());
actionFilter1.Verify(f => f.OnActionExecuted(It.IsAny<ActionExecutedContext>()), Times.Once());
actionFilter2.Verify(f => f.OnActionExecuting(It.IsAny<ActionExecutingContext>()), Times.Once());
resultFilter.Verify(f => f.OnResultExecuting(It.IsAny<ResultExecutingContext>()), Times.Once());
resultFilter.Verify(f => f.OnResultExecuted(It.IsAny<ResultExecutedContext>()), Times.Once());
Assert.True(context.Canceled);
Assert.Same(context.Result, result);
}
public void OnExceptionWithWrongExceptionTypeDoesNothing() {
// Arrange
HandleErrorAttribute attr = new HandleErrorAttribute() { ExceptionType = typeof(ArgumentException) };
ActionResult result = new EmptyResult();
ExceptionContext context = GetExceptionContext(GetHttpContext(), null, new InvalidCastException());
context.Result = result;
// Exception
attr.OnException(context);
// Assert
Assert.AreSame(result, context.Result, "The context's Result property should have remain unchanged.");
}
public void OnExceptionWithNon500ExceptionDoesNothing() {
// Arrange
HandleErrorAttribute attr = new HandleErrorAttribute();
ActionResult result = new EmptyResult();
ExceptionContext context = GetExceptionContext(GetHttpContext(), null, new HttpException(404, "Some Exception"));
context.Result = result;
// Exception
attr.OnException(context);
// Assert
Assert.AreSame(result, context.Result, "The context's Result property should have remain unchanged.");
}
public void OnExceptionWithCustomErrorsDisabledDoesNothing() {
// Arrange
HandleErrorAttribute attr = new HandleErrorAttribute();
ActionResult result = new EmptyResult();
ExceptionContext context = GetExceptionContext(GetHttpContext(false), null, new Exception());
context.Result = result;
// Exception
attr.OnException(context);
// Assert
Assert.AreSame(result, context.Result, "The context's Result property should have remain unchanged.");
}
public void OnExceptionWithNon500ExceptionDoesNothing()
{
// Arrange
HandleErrorAttribute attr = new HandleErrorAttribute();
ActionResult result = new EmptyResult();
ExceptionContext context = GetExceptionContext(GetHttpContext(), null, new HttpException(404, "Some Exception"));
context.Result = result;
// Exception
attr.OnException(context);
// Assert
Assert.Same(result, context.Result);
}
public void OnExceptionWithExceptionHandledDoesNothing()
{
// Arrange
HandleErrorAttribute attr = new HandleErrorAttribute();
ActionResult result = new EmptyResult();
ExceptionContext context = GetExceptionContext(GetHttpContext(), null, new Exception());
context.Result = result;
context.ExceptionHandled = true;
// Exception
attr.OnException(context);
// Assert
Assert.Same(result, context.Result);
}
public void BeEmpty_GivenEmpty_ShouldPass()
{
ActionResult result = new EmptyResult();
result.Should().BeEmptyResult();
}
