public ActionResult Login(string txtLogin, string txtPassword)
{
SecurityServices serv = new SecurityServices();
Usuario user;
ActionResult result = new EmptyResult();
try
{
user = serv.Login(txtLogin, txtPassword);
if (user != null)
{
// Opcion 1: terminamos aca y no pedimos perfil
// result = View("LoginOK", user);
// TODO acomodar autenticacion para que no se repita el codigo
// Opcion 2: redirigimos a otra vista que nos permite elegir el perfil (salvo que tenga un unico perfil...)
if (user.Perfiles.Count > 1)
{
result = View("PerfilSelect", user);
}
else
{
// Guardamos los datos de sesion en el "contexto" de la sesion establecida (similar al Context que usamos en WPF)
//
Session["SESION_USER"] = serv.CrearSesion(user, user.Perfiles.Single());
FormsAuthentication.SetAuthCookie(user.Login, false);
string redirectUrl = FormsAuthentication.GetRedirectUrl(user.Login, false);
if (redirectUrl == "/" || string.IsNullOrEmpty(redirectUrl))
{
// creamos una nueva vista strong-typed para incorporar la Sesion
result = View("LoginOK_v2", Session["SESION_USER"] as Sesion);
}
else
{
result = new RedirectResult(redirectUrl);
}
}
}
else
{
// TODO: armar paginas de error para los casos de credenciales incorrectas o excepcion
// TODO: y un controlador que ademas realice el log del problema?
//
result = new HttpUnauthorizedResult("Credenciales incorrectas");
}
}
catch (Exception ex)
{
// redireccionar a una pagina de error!!
result = new HttpUnauthorizedResult("Estas al horno!!!");
}
return result;
}
public void AdaptResult_Returns_Original_Result_If_Not_ViewResultBase()
{
// Arrange
ModuleApplication app = CreateTestApplication();
ActionResult toAdapt = new EmptyResult();
// Act
ActionResult adapted = app.AdaptResult(toAdapt);
// Assert
Assert.AreSame(adapted, toAdapt);
}
public void TestMimeAllReturnedIfNoSpecificResolverFound()
{
var allResult = new ViewResult();
var htmlResult = new EmptyResult();
_format.Html(() => htmlResult);
_format.All(() => allResult);
Assert.That(_format.ResolveResult("text/html"), Is.EqualTo(htmlResult));
Assert.That(_format.ResolveResult("*/*", "text/html"), Is.EqualTo(allResult));
Assert.That(_format.ResolveResult("*/*", "application/json"), Is.EqualTo(allResult));
Assert.That(_format.ResolveResult("application/json"), Is.EqualTo(allResult));
Assert.That(_format.ResolveResult((string[]) null), Is.EqualTo(allResult));
}
public ActionResult jcc(System.Web.HttpRequestBase request)
{
// string action = base.RouteData.GetRequiredString("action");
ActionResult result;
try
{
Tracing.DataTrace.TraceEvent(TraceEventType.Verbose, 0, "jcc payment data: {0}", new object[]
{
base.Request.DumpValues()
});
this.CheckServerAddressList();
var paymentResult = JccPaymentResult.Create(request);
if (paymentResult.Status == JccPaymentResult.OpeationStatus.Success)
{
ConfirmInvoiceResult invoiceResult = BookingProvider.ConfirmInvoice(paymentResult.InvoiceNumber.Trim());
Tracing.DataTrace.TraceEvent(TraceEventType.Information, 0, "jcc transaction: invoice: '{0}', status: '{1}', invoice confirmation: '{2}'", new object[]
{
paymentResult.InvoiceNumber,
paymentResult.Status,
invoiceResult.IsSuccess ? "SUCCESS" : "FAILED"
});
if (!invoiceResult.IsSuccess)
{
throw new System.Exception(string.Format("invoice confirm error {0}", invoiceResult.ErrorMessage));
}
}
else
{
Tracing.DataTrace.TraceEvent(TraceEventType.Information, 0, "jcc transaction: invoice: '{0}', status: '{1}'", new object[]
{
paymentResult.InvoiceNumber,
paymentResult.Status
});
}
result = new EmptyResult();
}
catch (System.Exception ex)
{
Tracing.DataTrace.TraceEvent(TraceEventType.Error, 0, "jcc payment error: {0}", new object[]
{
ex.ToString()
});
result = new HttpStatusCodeResult(500);
}
return result;
}
public void op_View_ExceptionContext()
{
var expected = new EmptyResult();
var filterContext = new ExceptionContext();
var mock = new Mock<IInterceptInternalServerError>(MockBehavior.Strict);
mock
.Setup(x => x.View(filterContext))
.Returns(expected)
.Verifiable();
var actual = mock.Object.View(filterContext);
Assert.Equal(expected, actual);
mock.VerifyAll();
}
protected override bool VerifyProjectRequest(Project entity, out ActionResult result)
{
if (entity == null)
{
result = View("ProjectNotFound");
return false;
}
if (!this.CurrentUser.IsPrincipalInvestigatorFor(entity))
{
result = View("NoProjectAccessRight");
return false;
}
if (entity.SourceProjectType == SourceProjectType.DEPOSIT)
{
result = View("IncorrectProjectType");
return false;
}
result = new EmptyResult();
return true;
}
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 GetPackageReturnsPackageIfItExists()
{
// Arrange
var guid = Guid.NewGuid();
var package = new Package();
var actionResult = new EmptyResult();
var packageSvc = new Mock<IPackageService>(MockBehavior.Strict);
packageSvc.Setup(x => x.FindPackageByIdAndVersion("Baz", "1.0.1", false)).Returns(package);
packageSvc.Setup(x => x.AddDownloadStatistics(package, "Foo", "Qux")).Verifiable();
var packageFileSvc = new Mock<IPackageFileService>(MockBehavior.Strict);
packageFileSvc.Setup(s => s.CreateDownloadPackageActionResult(package)).Returns(actionResult).Verifiable();
packageFileSvc.SetupGet(s => s.AllowCachingOfPackage).Returns(false);
var userSvc = new Mock<IUserService>(MockBehavior.Strict);
userSvc.Setup(x => x.FindByApiKey(guid)).Returns(new User());
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 controller = CreateController(userSvc: userSvc, packageSvc: packageSvc, fileService: packageFileSvc);
var controllerContext = new ControllerContext(new RequestContext(httpContext.Object, new RouteData()), controller);
controller.ControllerContext = controllerContext;
// Act
var result = controller.GetPackage("Baz", "1.0.1");
// Assert
Assert.Same(actionResult, result);
packageFileSvc.Verify();
packageSvc.Verify();
}
public void BeEmpty_GivenEmpty_ShouldPass()
{
ActionResult result = new EmptyResult();
result.Should().BeEmptyResult();
}
public async Task GetPackageReturnsLatestPackageIfNoVersionIsProvided()
{
// Arrange
var guid = Guid.NewGuid();
var package = new Package();
var actionResult = new EmptyResult();
var packageService = new Mock<IPackageService>(MockBehavior.Strict);
packageService.Setup(x => x.FindPackageByIdAndVersion("Baz", "", false)).Returns(package);
packageService.Setup(x => x.AddDownloadStatistics(package, "Foo", "Qux", "Install")).Verifiable();
var packageFileService = new Mock<IPackageFileService>(MockBehavior.Strict);
packageFileService.Setup(s => s.CreateDownloadPackageActionResultAsync(HttpRequestUrl, package))
.Returns(Task.FromResult<ActionResult>(actionResult))
.Verifiable();
var userService = new Mock<IUserService>(MockBehavior.Strict);
userService.Setup(x => x.FindByApiKey(guid)).Returns(new User());
NameValueCollection headers = new NameValueCollection();
headers.Add("NuGet-Operation", "Install");
var httpRequest = new Mock<HttpRequestBase>(MockBehavior.Strict);
httpRequest.SetupGet(r => r.UserHostAddress).Returns("Foo");
httpRequest.SetupGet(r => r.UserAgent).Returns("Qux");
httpRequest.SetupGet(r => r.Headers).Returns(headers);
httpRequest.SetupGet(r => r.Url).Returns(HttpRequestUrl);
var httpContext = new Mock<HttpContextBase>(MockBehavior.Strict);
httpContext.SetupGet(c => c.Request).Returns(httpRequest.Object);
var controller = CreateController(userService: userService, packageService: packageService, fileService: packageFileService);
var controllerContext = new ControllerContext(new RequestContext(httpContext.Object, new RouteData()), controller);
controller.ControllerContext = controllerContext;
// Act
var result = await controller.GetPackage("Baz", "");
// Assert
Assert.Same(actionResult, result);
packageFileService.Verify();
packageService.Verify();
}
public ActionResult Get(string metaViewName)
{
ActionResult res = new EmptyResult();
var dataSource = new DynamicEntityJSONDataSource();
if (Request.HttpMethod.Equals("GET", StringComparison.InvariantCultureIgnoreCase))
{
if (!SecurityCache.ViewCan(metaViewName, SecurityPermissionBaseTypeEnum.View))
{
return new ContentResult
{
ContentType = "text/html",
Content = DynamicEntityJSONDataSource.GetNotSuccess(WsFactory.GetАccessDeniedPage())
};
}
var extra = DynamicEntityJSONDataSource.GetExtra(Request.QueryString).ToLower();
res = Get(metaViewName, dataSource, extra);
}
else if (Request.HttpMethod.Equals("POST", StringComparison.InvariantCultureIgnoreCase))
{
if (!SecurityCache.ViewCan(metaViewName, SecurityPermissionBaseTypeEnum.Add))
{
return new ContentResult
{
ContentType = "text/html",
Content = DynamicEntityJSONDataSource.GetNotSuccess(WsFactory.GetАccessDeniedPage())
};
}
var updatedJson = Request.Body();
res = new ContentResult
{
ContentType = "text/html",
Content = dataSource.Insert(metaViewName,
DynamicEntityJSONDataSource.GetEntityOperationType(Request.QueryString),
updatedJson,
DynamicEntityJSONDataSource.GetExtra(Request.Params),
DynamicEntityJSONDataSource.GetVisibility(Request.QueryString),
DynamicEntityJSONDataSource.GetBaseEntityIdName(Request.Params),
DynamicEntityJSONDataSource.GetBaseEntityIdValue(Request.Params))
};
}
else if (Request.HttpMethod.Equals("PUT", StringComparison.InvariantCultureIgnoreCase))
{
if (!SecurityCache.ViewCan(metaViewName, SecurityPermissionBaseTypeEnum.Edit))
{
return new ContentResult
{
ContentType = "text/html",
Content = DynamicEntityJSONDataSource.GetNotSuccess(WsFactory.GetАccessDeniedPage())
};
}
var updatedJson = Request.Body();
res = new ContentResult
{
ContentType = "text/html",
Content =
dataSource.Update(metaViewName,
updatedJson,
DynamicEntityJSONDataSource.GetExtra(Request.Params),
DynamicEntityJSONDataSource.GetVisibility(Request.QueryString),
DynamicEntityJSONDataSource.GetBaseEntityIdName(Request.QueryString),
DynamicEntityJSONDataSource.GetBaseEntityIdValue(Request.QueryString))
};
}
else if (Request.HttpMethod.Equals("DELETE", StringComparison.InvariantCultureIgnoreCase))
{
if (!SecurityCache.ViewCan(metaViewName, SecurityPermissionBaseTypeEnum.Delete))
{
return new ContentResult
{
ContentType = "text/html",
Content = DynamicEntityJSONDataSource.GetNotSuccess(WsFactory.GetАccessDeniedPage())
};
}
var updatedJson = Request.Body();
string validateRes = string.Empty;
if (metaViewName != "Budget")
{
if (!MetadataRepositoty.ValidadateDelete(metaViewName, updatedJson, out validateRes))
{
return new ContentResult
{
ContentType = "text/html",
Content = DynamicEntityJSONDataSource.GetNotSuccess(validateRes)
};
}
}
res = new ContentResult
{
ContentType = "text/html",
Content =
dataSource.Delete(metaViewName,
updatedJson,
DynamicEntityJSONDataSource.GetExtra(Request.Params),
DynamicEntityJSONDataSource.GetBaseEntityIdName(Request.QueryString),
DynamicEntityJSONDataSource.GetBaseEntityIdValue(Request.QueryString))
};
}
return res;
}
public void Should_convert()
{
ActionResult result = new EmptyResult();
var converted = result.AssertResultIs<EmptyResult>();
Assert.IsNotNull(converted);
}
public void TestWithResolveHook()
{
var hookInvoked = false;
var hookResult = new EmptyResult();
_format.WithResolveHook(context =>
{
hookInvoked = true;
return hookResult;
});
Assert.That(_format.ResolveResult(_controllerContext), Is.SameAs(hookResult));
Assert.That(hookInvoked);
}
public async Task GetPackageReturns503IfNoVersionIsProvidedAndDatabaseUnavailable()
{
// Arrange
var package = new Package();
var actionResult = new EmptyResult();
var controller = new TestableApiController(MockBehavior.Strict);
controller.MockPackageService.Setup(x => x.FindPackageByIdAndVersion("Baz", "", false)).Throws(new DataException("Oh noes, database broked!"));
NameValueCollection headers = new NameValueCollection();
headers.Add("NuGet-Operation", "Install");
var httpRequest = new Mock<HttpRequestBase>(MockBehavior.Strict);
httpRequest.SetupGet(r => r.UserHostAddress).Returns("Foo");
httpRequest.SetupGet(r => r.UserAgent).Returns("Qux");
httpRequest.SetupGet(r => r.Headers).Returns(headers);
httpRequest.SetupGet(r => r.Url).Returns(HttpRequestUrl);
var httpContext = new Mock<HttpContextBase>(MockBehavior.Strict);
httpContext.SetupGet(c => c.Request).Returns(httpRequest.Object);
var controllerContext = new ControllerContext(new RequestContext(httpContext.Object, new RouteData()), controller);
controller.ControllerContext = controllerContext;
// Act
var result = await controller.GetPackage("Baz", "");
// Assert
ResultAssert.IsStatusCode(result, HttpStatusCode.ServiceUnavailable, Strings.DatabaseUnavailable_TrySpecificVersion);
controller.MockPackageFileService.Verify();
controller.MockPackageService.Verify();
controller.MockUserService.Verify();
}
public void ExecuteRequest_Returns_AdaptedResult_And_ControllerContext_From_Controller()
{
// Arrange
ModuleApplication app = CreateTestApplication();
SetupGetRouteDataCall(app);
ControllerContext controllerContext = Mockery.CreateMockControllerContext();
ActionResult actionResult = new Mock<ActionResult>().Object;
EmptyResult expected = new EmptyResult();
Mock.Get(app)
.Setup(a => a.AdaptResult(actionResult))
.Returns(expected);
IModuleController controller = SetupMockController(actionResult, controllerContext);
app.ControllerFactory = SetupControllerFactory(controller);
ModuleRequestContext moduleRequestContext = CreateModuleContext(app, "Foo/Bar/Baz");
// Act
ModuleRequestResult result = app.ExecuteRequest(moduleRequestContext);
// Assert
Assert.AreSame(expected, result.ActionResult, "Expected that the result of the action would be adapted and returned by the application");
Assert.AreSame(controllerContext, result.ControllerContext, "Expected that the controller context of the controller would be returned by the application");
}
public void InvokeActionMethodFilterWhereOnActionExecutingCancels() {
// Arrange
bool wasCalled = false;
Dictionary<string, object> parameters = new Dictionary<string, object>();
ActionResult actionResult = new EmptyResult();
ActionExecutingContext preContext = GetEmptyActionExecutingContext();
ActionFilterImpl filter = new ActionFilterImpl() {
OnActionExecutingImpl = delegate(ActionExecutingContext filterContext) {
Assert.IsFalse(wasCalled);
wasCalled = true;
filterContext.Result = actionResult;
},
};
BeginInvokeCallback beginContinuation = (innerCallback, innerState) => {
Assert.Fail("The continuation should not be called.");
return null;
};
AsyncCallback<ActionExecutedContext> endContinuation = ar => {
Assert.Fail("The continuation should not be called.");
return null;
};
// Act
IAsyncResult asyncResult = AsyncControllerActionInvoker.BeginInvokeActionMethodFilter(filter, preContext, beginContinuation, endContinuation, null, null);
ActionExecutedContext postContext = AsyncControllerActionInvoker.EndInvokeActionMethodFilter(asyncResult);
// Assert
Assert.IsTrue(wasCalled);
Assert.IsNull(postContext.Exception);
Assert.IsTrue(postContext.Canceled);
Assert.AreEqual(actionResult, postContext.Result, "Result was incorrect.");
Assert.AreEqual(preContext.ActionDescriptor, postContext.ActionDescriptor, "Descriptor was incorrect.");
}
public void LoginPost_Returns_Result_Of_OnLoginFormSubmit()
{
// Arrange
var controller = new IdentityController();
controller.IdentitySources.AddMock(UnusedMockIdentitySource);
var mockSource = controller.IdentitySources.AddMock(SelectedMockIdentitySource);
EmptyResult expectedResult = new EmptyResult();
mockSource.Setup(s => s.OnLoginFormSubmit(It.IsAny<ControllerContext>(), TestReturnUrl))
.Returns(expectedResult);
// Act
ActionResult actualResult = controller.LoginPost(SelectedMockIdentitySource, TestReturnUrl.ToString());
// Assert
Assert.AreSame(expectedResult, actualResult);
}
public void LoginGet_Returns_Result_Of_IdentitySource_Login()
{
// Arrange
var controller = new IdentityController();
controller.IdentitySources.AddMock(UnusedMockIdentitySource);
var mockSource = controller.IdentitySources.AddMock(SelectedMockIdentitySource);
EmptyResult expectedResult = new EmptyResult();
mockSource.Setup(s => s.Login(It.IsAny<ControllerContext>(), TestReturnUrl))
.Returns(expectedResult);
// Act
ActionResult actualResult = controller.LoginGet(SelectedMockIdentitySource, TestReturnUrl.ToString());
// Assert
Assert.AreSame(expectedResult, actualResult, "Expected that the result of Login would be passed unmodified");
}
public ActionResult GetAJAXTree(string metaViewName)
{
ActionResult res = new EmptyResult();
var dataSource = new DynamicEntityJSONDataSource();
if (Request.HttpMethod.Equals("GET", StringComparison.InvariantCultureIgnoreCase))
{
if (!SecurityCache.ViewCan(metaViewName, SecurityPermissionBaseTypeEnum.View))
{
return new ContentResult
{
ContentType = "text/html",
Content = DynamicEntityJSONDataSource.GetNotSuccess(WsFactory.GetАccessDeniedPage())
};
}
res = new ContentResult
{
ContentType = "text/html",
Content = dataSource.GetJSONAJAXTreeData(metaViewName,
DynamicEntityJSONDataSource.GetSort(Request.QueryString),
DynamicEntityJSONDataSource.GetSearch(Request.QueryString),
DynamicEntityJSONDataSource.GetExtra(Request.Params),
DynamicEntityJSONDataSource.GetBaseEntityIdName(Request.QueryString),
DynamicEntityJSONDataSource.GetBaseEntityIdValue(Request.QueryString),
DynamicEntityJSONDataSource.GetCallback(Request.QueryString),
DynamicEntityJSONDataSource.GetNodeValue(Request.QueryString),
DynamicEntityJSONDataSource.GetVisibility(Request.QueryString), GetShowDeleted(metaViewName)
)
};
}
else if (Request.HttpMethod.Equals("DELETE", StringComparison.InvariantCultureIgnoreCase))
{
if (!SecurityCache.ViewCan(metaViewName, SecurityPermissionBaseTypeEnum.Delete))
{
return new ContentResult
{
ContentType = "text/html",
Content = DynamicEntityJSONDataSource.GetNotSuccess(WsFactory.GetАccessDeniedPage())
};
}
var updatedJson = Request.Body();
string validateRes = string.Empty;
if (!MetadataRepositoty.ValidadateDelete(metaViewName, updatedJson, out validateRes))
{
return new ContentResult
{
ContentType = "text/html",
Content = DynamicEntityJSONDataSource.GetNotSuccess(validateRes)
};
}
return new ContentResult
{
ContentType = "text/html",
Content =
dataSource.Delete(metaViewName,
updatedJson,
DynamicEntityJSONDataSource.GetExtra(Request.Params),
DynamicEntityJSONDataSource.GetBaseEntityIdName(Request.QueryString),
DynamicEntityJSONDataSource.GetBaseEntityIdValue(Request.QueryString))
};
}
return res;
}
public async Task GetPackageReturnsSpecificPackageEvenIfDatabaseIsOffline()
{
// Arrange
var package = new Package();
var actionResult = new EmptyResult();
var controller = new TestableApiController(MockBehavior.Strict);
controller.MockPackageService.Setup(x => x.FindPackageByIdAndVersion("Baz", "1.0.0", false)).Throws(new DataException("Can't find the database")).Verifiable();
controller.MockPackageFileService.Setup(s => s.CreateDownloadPackageActionResultAsync(HttpRequestUrl, "Baz", "1.0.0"))
.Returns(Task.FromResult<ActionResult>(actionResult))
.Verifiable();
NameValueCollection headers = new NameValueCollection();
headers.Add("NuGet-Operation", "Install");
var httpRequest = new Mock<HttpRequestBase>(MockBehavior.Strict);
httpRequest.SetupGet(r => r.UserHostAddress).Returns("Foo");
httpRequest.SetupGet(r => r.UserAgent).Returns("Qux");
httpRequest.SetupGet(r => r.Headers).Returns(headers);
httpRequest.SetupGet(r => r.Url).Returns(HttpRequestUrl);
var httpContext = new Mock<HttpContextBase>(MockBehavior.Strict);
httpContext.SetupGet(c => c.Request).Returns(httpRequest.Object);
var controllerContext = new ControllerContext(new RequestContext(httpContext.Object, new RouteData()), controller);
controller.ControllerContext = controllerContext;
// Act
var result = await controller.GetPackage("Baz", "1.0.0");
// Assert
Assert.Same(actionResult, result);
controller.MockPackageFileService.Verify();
controller.MockPackageService.Verify();
}
public void TryLogInByRedirectingUserToRelyingParty()
{
var loginModel = new LogInModel { OpenId = ConnectionHelper.OpenId };
// We don't care what the result is. We just want to check we get back the same object
var redirectResult = new EmptyResult();
var relyingParty = A.Fake<IAccountRelyingParty>();
var accountController = ControllerLocator.GetAccountControllerForLoginTest(relyingParty);
A.CallTo(() => relyingParty.IsValidIdentifier(ConnectionHelper.OpenId)).Returns(true);
A.CallTo(() => relyingParty.CreateRequest(ConnectionHelper.OpenId)).Returns(redirectResult);
var result = accountController.LogIn(loginModel);
Assert.That(result, Is.Not.Null);
Assert.That(result, Is.SameAs(redirectResult));
A.CallTo(() => relyingParty.IsValidIdentifier(ConnectionHelper.OpenId)).MustHaveHappened();
A.CallTo(() => relyingParty.CreateRequest(ConnectionHelper.OpenId)).MustHaveHappened();
}
public async Task GetPackageReturnsLatestPackageIfNoVersionIsProvided()
{
// Arrange
const string PackageId = "Baz";
var package = new Package() { Version = "1.2.0408", NormalizedVersion = "1.2.408" };
var actionResult = new EmptyResult();
var controller = new TestableApiController(MockBehavior.Strict);
controller.MockPackageService.Setup(x => x.FindPackageByIdAndVersion(PackageId, "", false)).Returns(package);
controller.MockPackageService.Setup(x => x.AddDownloadStatistics(It.IsAny<PackageStatistics>())).Verifiable();
controller.MockPackageFileService.Setup(s => s.CreateDownloadPackageActionResultAsync(HttpRequestUrl, PackageId, package.NormalizedVersion))
.Returns(Task.FromResult<ActionResult>(actionResult))
.Verifiable();
NameValueCollection headers = new NameValueCollection();
headers.Add("NuGet-Operation", "Install");
var httpRequest = new Mock<HttpRequestBase>(MockBehavior.Strict);
httpRequest.SetupGet(r => r.UserHostAddress).Returns("Foo");
httpRequest.SetupGet(r => r.UserAgent).Returns("Qux");
httpRequest.SetupGet(r => r.Headers).Returns(headers);
httpRequest.SetupGet(r => r.Url).Returns(HttpRequestUrl);
var httpContext = new Mock<HttpContextBase>(MockBehavior.Strict);
httpContext.SetupGet(c => c.Request).Returns(httpRequest.Object);
var controllerContext = new ControllerContext(new RequestContext(httpContext.Object, new RouteData()), controller);
controller.ControllerContext = controllerContext;
// Act
var result = await controller.GetPackage(PackageId, "");
// Assert
Assert.Same(actionResult, result);
controller.MockPackageFileService.Verify();
controller.MockPackageService.Verify();
controller.MockUserService.Verify();
}
protected override void FinalizeSetUp()
{
_actionResultFactory = MockFor<ISitemapActionResultFactory>();
_sitemapProvider = new SitemapProvider(_actionResultFactory.Object);
_httpContext = MockFor<HttpContextBase>();
_config = MockFor<ISitemapConfiguration<SampleData>>();
_expectedResult = new EmptyResult();
}
private static ActionResult SetupMockLastPageResult(DebugIdentitySource identitySource, ControllerContext context)
{
ActionResult expected = new EmptyResult();
Mock.Get(identitySource).Setup(i => i.ReturnToLastPage(context)).Returns(expected);
return expected;
}
public override void Given()
{
ExpectedResult = new EmptyResult();
actionResultFactoryTester = new ActionResultFactoryTester<ActionResultFactory>(new[] { "text/html" }, ExpectedResult);
}
