public void WithRouteName_GivenExpected_ShouldPass()
{
ActionResult result = new RedirectToRouteResult("default", null);
result.Should()
.BeRedirectToRouteResult()
.WithRouteName("default");
}
public void WithPermanent_GivenExpected_ShouldPass()
{
ActionResult result = new RedirectToRouteResult("", null, true);
result.Should()
.BeRedirectToRouteResult()
.WithPermanent(true);
}
private static ActionResult GetRedirectResultByExceptionType(string errType, ExceptionContext exceptionContext)
{
var urlHelper = new UrlHelper(exceptionContext.HttpContext.Request.RequestContext);
var exception = exceptionContext.Exception;
var iController = exceptionContext.Controller as IControllerProperties;
var isAdminController = iController != null && iController.IsAdminController;
if (exception is UnauthorizedAccessException)
errType = "unauthorized";
else if (exception is InvalidMonthException)
errType = "invalid-month";
ActionResult redirectTo = isAdminController ? new RedirectResult(urlHelper.Action("Error","Admin", new { Area = "Admin", err = errType }))
: new RedirectResult(urlHelper.Action("Error", "Home", new { Area = "", err = errType }));
if (exception is UrlNotFoundException)
redirectTo = new RedirectToRouteResult("Error404", new RouteValueDictionary());
if (exception is InvalidThemeException)
redirectTo = new RedirectToRouteResult("InvalidTheme", new RouteValueDictionary());
if (exception is SqlException)
redirectTo = new RedirectToRouteResult("InitializeDatabase", new RouteValueDictionary());
return redirectTo;
}
void creating_a_game()
{
act = () =>
{
result = GivenAGame(name: "join now");
gameId = result.GameId();
player1 = result.UserId();
};
it["the game is created"] = () =>
(GetGame(gameId).Name as object).should_be("join now");
it["the user who created the game, has joined the game as player 1"] = () =>
{
dynamic game = GetGame(gameId);
(game.Player1Id as object).should_be(player1);
(game.CurrentTurn as object).should_be(player1);
};
it["the game is listed as a game that's available"] = () =>
(AvailableGames().First().Id as object).should_be(gameId);
}
public void ErrorResponse(string msg, ExceptionContext ec)
{
var routeData = new RouteValueDictionary(new { message = msg });
var response = new RedirectToRouteResult("ErrorPage", routeData);
ec.Result = response;
ec.ExceptionHandled = true;
}
public void filmsCreatePostTest()
{
Film newFilm = new Film(4, "Ime4", "https://www.google.com/images/branding/googlelogo/1x/googlelogo_color_272x92dp.png", "Musical", "Director 2", "6 May 2018 (USA)", "Short description", "Star 1, Star 2", 0.0, 0, "22:00");
System.Web.Mvc.RedirectToRouteResult result = controller.Create(newFilm) as System.Web.Mvc.RedirectToRouteResult;
Assert.AreEqual("Index", result.RouteValues["action"]);
}
protected RedirectToRouteResult NotEmptyView(BaseController controller, Object model)
{
RedirectToRouteResult result = new RedirectToRouteResult(new RouteValueDictionary());
controller.When(sub => sub.NotEmptyView(model)).DoNotCallBase();
controller.NotEmptyView(model).Returns(result);
return result;
}
protected RedirectToRouteResult RedirectToNotFound(BaseController controller)
{
RedirectToRouteResult result = new RedirectToRouteResult(new RouteValueDictionary());
controller.When(sub => sub.RedirectToNotFound()).DoNotCallBase();
controller.RedirectToNotFound().Returns(result);
return result;
}
protected RedirectToRouteResult RedirectIfAuthorized(BaseController controller, String actionName, String controllerName)
{
RedirectToRouteResult result = new RedirectToRouteResult(new RouteValueDictionary());
controller.When(sub => sub.RedirectIfAuthorized(actionName, controllerName)).DoNotCallBase();
controller.RedirectIfAuthorized(actionName, controllerName).Returns(result);
return result;
}
public void WithPermanent_GivenUnExpected_ShouldFail()
{
ActionResult result = new RedirectToRouteResult("", null, true);
Action a = () => result.Should()
.BeRedirectToRouteResult()
.WithPermanent(false);
a.ShouldThrow<Exception>()
.WithMessage("Expected RedirectToRoute.Permanent to be False, but found True");
}
public void WithRouteName_GivenUnExpected_ShouldFail()
{
ActionResult result = new RedirectToRouteResult("default", null);
Action a = () => result.Should()
.BeRedirectToRouteResult()
.WithRouteName("xyz");
a.ShouldThrow<Exception>()
.WithMessage("Expected RedirectToRoute.RouteName to be \"xyz\", but found \"default\"");
}
public void filmsEditPostTest2()
{
Film film = controller.getFilm(280);
film.Name = "Black Panther";
System.Web.Mvc.RedirectToRouteResult result = controller.Edit(film) as System.Web.Mvc.RedirectToRouteResult;
Assert.AreEqual("Index", result.RouteValues["action"]);
Assert.AreEqual(280, controller.getFilmIdByTitle("Black Panther"));
}
protected ActionResult RedirectToLocal(string returnUrl,
RedirectToRouteResult defaultUrl = null)
{
if (Url.IsLocalUrl(returnUrl))
{
return Redirect(returnUrl);
}
return defaultUrl ?? RedirectToAction("Index", "Home");
}
public void Should_remove_items_from_routevalues_once_stored_in_tempdata()
{
var result = new RedirectToRouteResult<SampleController>(x => x.Index(_someObject, 5));
var context = new ActionExecutedContext() {
Result = result,
Controller = new SampleController()
};
_filter.OnActionExecuted(context);
result.RouteValues.ContainsKey("viewModel").ShouldBeFalse();
}
/// <summary>
/// Adds the query string name with the temp data key to QueryStrings
/// </summary>
/// <param name="result"></param>
/// <param name="filterContext"></param>
protected virtual void AddQueryString(RedirectToRouteResult result, ActionExecutedContext filterContext)
{
//add notification query string to the result
var key = GetTempDataKey(filterContext);
var val = GetTempDataValue(filterContext);
//only add the query string if both the key and value are not null
if (key != null && val != null)
{
result.RouteValues.Add(QueryStringName, key);
}
}
public async void HttpGet_ErrorRedirect_UserIsLoggedIn_RedirectsToDefaultLoginAction()
{
var accessToken = "letmein";
var defaultLoginAction = new RedirectToRouteResult(new RouteValueDictionary(new { action = "gosomewhere " }));
A.CallTo(() => weeeAuthorization.GetAuthorizationState())
.Returns(AuthorizationState.LoggedIn(accessToken, defaultLoginAction));
var result = await ErrorsController().ErrorRedirect();
Assert.Equal(defaultLoginAction, result);
}
public void WithRouteValue_GivenExpected_ShouldPass()
{
ActionResult result = new RedirectToRouteResult("", new RouteValueDictionary(
new
{
Id = "22"
}));
result.Should()
.BeRedirectToRouteResult()
.WithRouteValue("Id", "22");
}
public override void ExecuteResult(ControllerContext context)
{
RouteValueDictionary routeDictionary = new RouteValueDictionary {{"controller", "Home"}, {"action", "Index"}};
if (!string.IsNullOrEmpty(_homepageMessage))
{
routeDictionary.Add("message", _homepageMessage);
}
RedirectToRouteResult redirectResult = new RedirectToRouteResult(routeDictionary);
redirectResult.ExecuteResult(context);
}
public ActionResult AatInput(Inputs input)
{
//SetSetting(AppSettings.UseSiteMinderSimulator, "true");
//SetSetting(AppSettings.ConfigIndividualKey, input.IndividualKey);
var result = new RedirectToRouteResult(new RouteValueDictionary(new
{
action = "Index",
controller = "Home"
}));
return result;
}
public void DeleteConfirmedValidId()
{
//Arrange
FakeVideoGamesBL fake = new FakeVideoGamesBL();
VideoGamesController controller = new VideoGamesController(fake);
controller.testCase = true;
//var result = (VideoGame)((ViewResult)controller.Details(1)).Model;
// Act
System.Web.Mvc.RedirectToRouteResult actual = (System.Web.Mvc.RedirectToRouteResult)controller.DeleteConfirmed(1);
// Assert
Assert.AreEqual("VideoGames", actual.RouteValues["action"]);
}
void setting_up_a_game()
{
context["a game has been created and two people have joined"] = () =>
{
before = () =>
{
result = GivenAGame(name: "join now");
gameId = result.GameId();
player1 = result.UserId();
player2 = Guid.NewGuid().ToString();
JoinGame(gameId, player2);
};
it["squares can be added and removed"] = () =>
{
SetupGame(player1, gameId, "1A");
(GetGame(gameId).Player1Squares.First().Location as string).should_be("1A");
SetupGame(player1, gameId, "1A");
((int)GetGame(gameId).Player1Squares.Count()).should_be(0);
};
it["maximum of 5 squares can be marked for each player"] = () =>
{
new string[]
{
"1A", "2A",
"3A", "4A",
"5A", "1B"
}.ForEach(location => SetupGame(player1, gameId, location));
((int)GetGame(gameId).Player1Squares.Count()).should_be(5);
new string[]
{
"1E", "2E",
"3E", "4E",
"5E", "1D"
}.ForEach(location => SetupGame(player2, gameId, location));
((int)GetGame(gameId).Player2Squares.Count()).should_be(5);
};
};
}
public void WithRouteValue_GivenUnexpected_ShouldFail()
{
ActionResult result = new RedirectToRouteResult("", new RouteValueDictionary(
new
{
Id = "22"
}));
Action a = () => result.Should()
.BeRedirectToRouteResult()
.WithRouteValue("Id", "11");
a.ShouldThrow<Exception>()
.WithMessage("Expected dictionary to contain value \"11\" at key \"Id\", but found \"22\".");
}
public void AControllerTest()
{
JCE_STD.Models.LogOnModel model = new Models.LogOnModel();
JCE_STD.Controllers.AccountController AC = new Controllers.AccountController();
JCE_STD.Controllers.HomeController success = new Controllers.HomeController();
RouteValueDictionary rDic = new RouteValueDictionary();
RedirectToRouteResult r = new RedirectToRouteResult("success",rDic);
model.UserName = "******";
model.Password = "******";
/* Assert.AreEqual(r, AC.LogOn(model)); */
ViewResult abc = new ViewResult();
Assert.AreEqual(abc.View, AC.LogOn(model));
}
public void BeerController_AddAction()
{
BeersController controller = new BeersController(new FakeRepositories.FakeBeerRepository());
Beer beer = new Beer()
{
BeerId = 1,
Name = "Blue Brew",
Type = "Ale",
UnitPrice = 69,
ABV = 69
};
System.Web.Mvc.RedirectToRouteResult result = controller.Create(beer) as System.Web.Mvc.RedirectToRouteResult;
Assert.IsNotNull(result);
}
public override void ExecuteResult(ControllerContext context)
{
// Set error statuc code as 403 Forbidden. For details see the following link: http://en.wikipedia.org/wiki/List_of_HTTP_status_codes
SetErrorResponse(context, HttpStatusCode.Forbidden);
var log = LogManager.GetCurrentClassLogger();
log.Error(BuildErrorMessage(context));
// HAL: It is tempopary implementation. Separate view should be implemented
var route = new RouteValueDictionary(new Dictionary<string, object>
{
{Constants.RouteKeys.Controller, ErrorsController.Name},
{Constants.RouteKeys.Action, ErrorsController.NoPermissionAction},
{Constants.RouteKeys.AspxErrorPath, context.HttpContext.Request.RawUrl}
});
var result = new RedirectToRouteResult(route);
result.ExecuteResult(context);
}
public void BrewariesController_AddAction()
{
BreweriesController controller = new BreweriesController(new FakeRepositories.FakeBrewaryRepository());
Brewery brew = new Brewery()
{
Name = "Sleeman",
Address = "Oakville",
YTDSales = 500,
BreweryId = 5
};
System.Web.Mvc.RedirectToRouteResult result = controller.Create(brew) as System.Web.Mvc.RedirectToRouteResult;
Assert.IsNotNull(result);
}
public void BarsController_AddAction()
{
BarsController controller = new BarsController(new FakeRepositories.FakeBarRepository());
Bar bar = new Bar()
{
Name = "Monaghans",
Address = "Oakville",
StoreId = 1,
UnitsOrdered = 5,
};
System.Web.Mvc.RedirectToRouteResult result = controller.Create(bar) as System.Web.Mvc.RedirectToRouteResult;
Assert.IsNotNull(result);
}
private static ActionResult GetRedirectResultByExceptionType(string errType, ExceptionContext exceptionContext)
{
var urlHelper = new UrlHelper(exceptionContext.HttpContext.Request.RequestContext);
var exception = exceptionContext.Exception;
if (exception is UnauthorizedAccessException)
errType = "unauthorized";
ActionResult redirectTo=null;
if (exception is UrlNotFoundException)
redirectTo = new RedirectToRouteResult("Error404", new RouteValueDictionary());
else
{
redirectTo = new RedirectToRouteResult("Error500", new RouteValueDictionary());
}
return redirectTo;
}
/// <summary>
/// Checks if user is authenticated.
/// </summary>
/// <param name="filterContext">The filter context.</param>
private static void CheckIfUserIsAuthenticated(AuthorizationContext filterContext)
{
if (!filterContext.HttpContext.User.Identity.IsAuthenticated)
{
FormsAuthenticationUtil.SignOut();
if (IsAjaxRequest(filterContext))
{
var jsonResult = new JsonRequestResult
{
ResultType = JsonRequestResultType.Error,
Message = Constants._msgExpiredSession,
Description = Constants._msgExpiredSession
};
filterContext.Result = new JsonResult { Data = jsonResult };
return;
}
filterContext.Result = new RedirectToRouteResult(new RouteValueDictionary(new
{
action = "LogIn",
controller = "Account",
area = "Admin"
}));
return;
}
if (filterContext.HttpContext.User.Identity.IsAuthenticated)
{
return;
}
//if result is null, we're OK
if (filterContext.Result == null)
{
return;
}
var result = new RedirectToRouteResult(new RouteValueDictionary(new
{
action = "AcessoNegado",
controller = "Home",
area = "Admin"
}));
filterContext.Result = result;
}
public void BeerController_Edit()
{
BeersController controller = new BeersController(new FakeRepositories.FakeBeerRepository());
Beer beer = new Beer()
{
BeerId = 1,
Name = "GreasyKev",
Type = "Ale",
UnitPrice = 1,
ABV = 1
};
System.Web.Mvc.RedirectToRouteResult createBeer = controller.Create(beer) as System.Web.Mvc.RedirectToRouteResult;
System.Web.Mvc.RedirectToRouteResult result = controller.Edit(beer) as System.Web.Mvc.RedirectToRouteResult;
Assert.IsNotNull(createBeer);
Assert.IsNotNull(result);
}
public void BrewariesController_Edit()
{
BreweriesController controller = new BreweriesController(new FakeRepositories.FakeBrewaryRepository());
Brewery brew = new Brewery()
{
Name = "Molson",
Address = "Toronto",
YTDSales = 5030,
BreweryId = 1
};
System.Web.Mvc.RedirectToRouteResult result = controller.Create(brew) as System.Web.Mvc.RedirectToRouteResult;
System.Web.Mvc.RedirectToRouteResult edit = controller.Edit(brew) as System.Web.Mvc.RedirectToRouteResult;
Assert.IsNotNull(result);
Assert.IsNotNull(edit);
}
public void BeerController_DeleteAction()
{
BeersController controller = new BeersController(new FakeRepositories.FakeBeerRepository());
Beer beer = new Beer()
{
BeerId = 1,
Name = "BeeBrew",
Type = "Ale",
UnitPrice = 5,
ABV = 4
};
System.Web.Mvc.RedirectToRouteResult createBeer = controller.Create(beer) as System.Web.Mvc.RedirectToRouteResult;
System.Web.Mvc.RedirectToRouteResult delete = controller.DeleteConfirmed(1) as System.Web.Mvc.RedirectToRouteResult;
System.Web.Mvc.RedirectToRouteResult result = controller.Details(1) as System.Web.Mvc.RedirectToRouteResult;
Assert.IsNull(result);
}
public void BarsController_Edit()
{
BarsController controller = new BarsController(new FakeRepositories.FakeBarRepository());
Bar bar = new Bar()
{
Name = "Cheers",
Address = "Toronto",
StoreId = 10,
UnitsOrdered = 100,
};
System.Web.Mvc.RedirectToRouteResult result = controller.Create(bar) as System.Web.Mvc.RedirectToRouteResult;
System.Web.Mvc.RedirectToRouteResult edit = controller.Edit(bar) as System.Web.Mvc.RedirectToRouteResult;
Assert.IsNotNull(result);
Assert.IsNotNull(edit);
}
public static void SetReportPost_ReturnsARedirect_WhenModelStateIsValid()
{
// Arrange
var mockRepo = new Mock <IReportService>();
var controller = new HomeController(mockRepo.Object);
ReportViewModel rep = new ReportViewModel();
var ctx = controller.MockControllerContext();
ctx.Object.Request.QueryString.Set("email", "*****@*****.**");
// ContextMocks.Request.SetupGet(r => r["mymodel"]).Returns(email);
// Act
System.Web.Mvc.RedirectToRouteResult redirectResult =
(System.Web.Mvc.RedirectToRouteResult)controller.SetReport(rep);
// Assert
Assert.IsInstanceOf <System.Web.Mvc.RedirectToRouteResult>(redirectResult);
Assert.AreEqual("Home/Index", redirectResult.RouteValues["controller"]);
}
public void OnAuthentication(AuthenticationContext filterContext)
{
if (filterContext.Controller.ControllerContext.HttpContext.Session["UserId"] == null
&& filterContext.Controller.ControllerContext.HttpContext.Session["UserId"].AsString() != CommonUtility.GetAppSetting<string>("AdminUserId"))
{
string redirectionUrl = string.Empty;
if (filterContext.RequestContext.HttpContext.Request.HttpMethod == System.Net.Http.HttpMethod.Get.ToString().ToUpper())
{
redirectionUrl = filterContext.RequestContext.HttpContext.Request.Url.AbsoluteUri.ToBase64Encode();
}
RedirectToRouteResult redirect = new RedirectToRouteResult("Login", new RouteValueDictionary(new
{
redirectionUrl = redirectionUrl
}));
filterContext.Result = redirect;
}
}
public static ActionResult Redirect(RouteValueDictionary route, ActionExecutingContext context)
{
ActionResult result;
if (context.HttpContext.Request.IsAjaxRequest())
{
UrlHelper url = new UrlHelper(context.RequestContext);
result = new JavaScriptResult()
{
Script = "window.location = '" + url.Action(null, route) + "';"
};
}
else
{
result = new RedirectToRouteResult(route);
}
return result;
}
public void BrewariesController_Delete()
{
BreweriesController controller = new BreweriesController(new FakeRepositories.FakeBrewaryRepository());
Brewery brew = new Brewery()
{
Name = "Molson",
Address = "Toronto",
YTDSales = 5030,
BreweryId = 1
};
System.Web.Mvc.RedirectToRouteResult result = controller.Create(brew) as System.Web.Mvc.RedirectToRouteResult;
System.Web.Mvc.RedirectToRouteResult deleteResult = controller.DeleteConfirmed(1) as System.Web.Mvc.RedirectToRouteResult;
System.Web.Mvc.RedirectToRouteResult model = controller.Details(1) as System.Web.Mvc.RedirectToRouteResult;
Assert.IsNotNull(result);
Assert.IsNotNull(deleteResult);
Assert.IsNull(model);
}
public void BarsController_Delete()
{
BarsController controller = new BarsController(new FakeRepositories.FakeBarRepository());
Bar bar = new Bar()
{
Name = "Cheers",
Address = "Toronto",
StoreId = 10,
UnitsOrdered = 100,
};
System.Web.Mvc.RedirectToRouteResult result = controller.Create(bar) as System.Web.Mvc.RedirectToRouteResult;
System.Web.Mvc.RedirectToRouteResult deleteResult = controller.DeleteConfirmed(10) as System.Web.Mvc.RedirectToRouteResult;
System.Web.Mvc.RedirectToRouteResult model = controller.Details(10) as System.Web.Mvc.RedirectToRouteResult;
Assert.IsNotNull(result);
Assert.IsNotNull(deleteResult);
Assert.IsNull(model);
}
public override void OnException(ExceptionContext filterContext)
{
var message = "An error has occurred.";
if (filterContext.Exception is ValidationException)
{
message = string.Join(" ", ((ValidationException)filterContext.Exception).ValidationResults.Select(e => e.ErrorMessage));
}
ActionResult result = null;
if (filterContext.RequestContext.HttpContext.Request.IsAjaxRequest())
{
filterContext.HttpContext.Response.StatusCode = 500;
filterContext.HttpContext.Response.StatusDescription = "An error has occurred.";
result = new JsonResult() { Data = new { message = message } };
}
else
{
filterContext.Controller.TempData["Alert"] = Alert.Danger(message);
result = new RedirectToRouteResult(filterContext.Controller.ControllerContext.RouteData.DataTokens);
}
filterContext.Result = result;
filterContext.ExceptionHandled = true;
}
public override void OnActionExecuting(ActionExecutingContext filterContext)
{
base.OnActionExecuting(filterContext);
var context = filterContext.HttpContext;
// check if session is supported
if (context.Session != null) {
// check if a new session id was generated
if (context.Session.IsNewSession) {
// If it says it is a new session, but an existing cookie exists, then it must
// have timed out
string sessionCookie = context.Request.Headers["Cookie"];
if ((null != sessionCookie) && (sessionCookie.IndexOf("ASP.NET_SessionId") >= 0)) {
var routeResult = new RedirectToRouteResult(new RouteValueDictionary() {
{ "action", "login" },
{"controller", "Account"},
{"timeout", true }
});
filterContext.Result = routeResult;
}
}
}
}
public override void OnActionExecuting(ActionExecutingContext filterContext)
{
var controller = filterContext.Controller as DoverController;
var moduleId = filterContext.RouteData.Values["moduleid"] as string;
int nModuleId;
if(controller != null) {
if(!String.IsNullOrWhiteSpace(moduleId)) {
if(Int32.TryParse(moduleId, out nModuleId)) {
var theModule = controller.ModRepository.GetModuleById(nModuleId,
m => m.Account,
m => m.Fields.Include<Field, FieldDataType>(f => f.FieldDataType),
m => m.Rows.Include<Row, Cell>(r => r.Cells));
var redirectResult = new RedirectToRouteResult(
new RouteValueDictionary(new {
Controller = "Home",
Action = "Index"
}));
if(theModule == null) {
controller.TempData["Message"] = "Módulo não encontrado.";
filterContext.Result = redirectResult;
}
else if (!IsAuthorized(controller, theModule)) {
controller.TempData["Message"] = "Usuário não autorizado.";
filterContext.Result = redirectResult;
}
filterContext.ActionParameters["module"] = theModule;
}
}
}
base.OnActionExecuting(filterContext);
}
public override void ExecuteResult(ControllerContext context)
{
RedirectToRouteResult result = null;
if (this.user.IsOwner)
{
result = new RedirectToRouteResult(new RouteValueDictionary {
{ "Controller", "Owner" },
{ "Action", "Index" } });
}
else if (this.user.IsWitness)
{
result = new RedirectToRouteResult(new RouteValueDictionary {
{ "Controller", "Witness" },
{ "Action", "Index" } });
}
else if (this.user.IsDataheir)
{
result = new RedirectToRouteResult(new RouteValueDictionary {
{ "Controller", "Recipient" },
{ "Action", "Index" } });
}
result.ExecuteResult(context);
}
public RedirectToRouteResultWrapper(RedirectToRouteResult redirectToRouteResult, RouteCollection routeTable)
: base(redirectToRouteResult.RouteName, redirectToRouteResult.RouteValues)
{
this.Routes = routeTable;
}
