public async Task <IActionResult> Edit(int id)
{
var model = new EditModel(_context);
await model.OnGetAsync(id);
return(View(model));
}
public async Task OnGet_WithRoles_PopulatesThePageModel()
{
var user = new UserView(UserTestData.ApplicationUsers[0]);
var roles = new List <string>()
{
UserRoles.FileCreator,
UserRoles.FileEditor,
UserRoles.SiteMaintenance,
UserRoles.UserMaintenance,
};
var mockRepo = new Mock <IUserService>();
mockRepo.Setup(l => l.GetUserByIdAsync(It.IsAny <Guid>()))
.ReturnsAsync(user);
mockRepo.Setup(l => l.GetUserRolesAsync(It.IsAny <Guid>()))
.ReturnsAsync(roles);
var pageModel = new EditModel(mockRepo.Object);
var result = await pageModel.OnGetAsync(Guid.Empty).ConfigureAwait(false);
result.Should().BeOfType <PageResult>();
pageModel.UserId.ShouldEqual(Guid.Empty);
pageModel.DisplayName.ShouldEqual(user.DisplayName);
pageModel.Email.ShouldEqual(user.Email);
pageModel.HasFileCreatorRole.ShouldBeTrue();
pageModel.HasFileEditorRole.ShouldBeTrue();
pageModel.HasSiteMaintenanceRole.ShouldBeTrue();
pageModel.HasUserAdminRole.ShouldBeTrue();
}
public async Task OnPostEditProyectosPersonales_VerSiRealmenteEdita()
{
// Arrange
//Preparamos un contexto que guarde la base de datos en memoria ram.
var OptionsBuilder = new DbContextOptionsBuilder <IdentityContext>()
.UseInMemoryDatabase("InMemoryDb");
IdentityContext TestIdentityContext = new IdentityContext(OptionsBuilder.Options);
ProyectoPersonal ProyectoPersonal = new ProyectoPersonal()
{
ID = 4, Descripcion = "Book", FechaComienzo = DateTime.Parse("2019/02/12"), FechaFinalizacion = DateTime.Parse("2019/02/12"), TipoDeProyecto = "Foto"
};
//Guardamos un Proyecto Personal en bd
TestIdentityContext.ProyectoPersonal.Add(ProyectoPersonal);
TestIdentityContext.SaveChanges();
//Creo una instancia de Proyecto Personal para comparar más adelante
ProyectoPersonal ProyectoPersonalEsperado = new ProyectoPersonal()
{
ID = 4, Descripcion = "Camara", FechaComienzo = DateTime.Parse("2019/03/12"), FechaFinalizacion = DateTime.Parse("2019/04/12"), TipoDeProyecto = "camara"
};
// Act
//Creamos una pagina de tipo EditModel (de Proyectos Personales), la cual es la que se encarga de la logica
//de editar Proyectos Personales en bd.
EditModel PageEditModel = new EditModel(TestIdentityContext);
//Simulamos haber hecho el edit en un Proyectos Personales con el id
await PageEditModel.OnGetAsync(ProyectoPersonal.ID);
//Modificamos los valores de los atributos de la instancia "ProyectoPersonal" de Proyecto Personal
PageEditModel.ProyectoPersonal.Descripcion = ProyectoPersonalEsperado.Descripcion;
PageEditModel.ProyectoPersonal.FechaComienzo = ProyectoPersonalEsperado.FechaComienzo;
PageEditModel.ProyectoPersonal.FechaFinalizacion = ProyectoPersonalEsperado.FechaFinalizacion;
PageEditModel.ProyectoPersonal.TipoDeProyecto = ProyectoPersonalEsperado.TipoDeProyecto;
//Simulamos un post que envíe el formulario de la pagina y por ende guarda los cambios de la edicion
await PageEditModel.OnPostAsync();
// Assert
//Buscamos si aún esta en bd el Proyecto Personal que debió haber sido editada por la pagina
ProyectoPersonal ProyectoPersonalRecibida = await TestIdentityContext.ProyectoPersonal.FindAsync(ProyectoPersonal.ID);
Assert.Equal(
ProyectoPersonalEsperado.Descripcion.ToString(),
ProyectoPersonalRecibida.Descripcion.ToString());
Assert.Equal(
ProyectoPersonalEsperado.FechaComienzo.ToString(),
ProyectoPersonalRecibida.FechaComienzo.ToString());
Assert.Equal(
ProyectoPersonalEsperado.FechaFinalizacion.ToString(),
ProyectoPersonalRecibida.FechaFinalizacion.ToString());
Assert.Equal(
ProyectoPersonalEsperado.TipoDeProyecto.ToString(),
ProyectoPersonalRecibida.TipoDeProyecto.ToString());
//Si se ejecuta correctamente, significa que el programa modifica correctamente Proyectos Personales
}
public async Task OnGet_MissingId_ReturnsNotFound()
{
var mockRepo = new Mock <IUserService>();
var pageModel = new EditModel(mockRepo.Object);
var result = await pageModel.OnGetAsync(null).ConfigureAwait(false);
result.Should().BeOfType <NotFoundResult>();
pageModel.UserId.Should().Be(Guid.Empty);
}
public async Task OnGet_MissingId_ReturnsNotFound()
{
var mockRepo = new Mock <IFacilityRepository>();
var mockSelectListHelper = new Mock <ISelectListHelper>();
var pageModel = new EditModel(mockRepo.Object, mockSelectListHelper.Object);
var result = await pageModel.OnGetAsync(null).ConfigureAwait(false);
result.Should().BeOfType <NotFoundResult>();
pageModel.Id.Should().Be(Guid.Empty);
pageModel.Facility.ShouldBeNull();
}
public async Task OnGetAsync_PopulatesThePageModel_WithAnAssignment()
{
// Arrange
var pageModel = new EditModel(MockAppDbContext.Object);
// Act
await pageModel.OnGetAsync(1);
// Assert
var actualAssignment = Assert.IsAssignableFrom <Assignment>(pageModel.Assignment);
Assert.Equal(ApplicationDbContext.GetSeedingAssignments().First(a => a.Id == 1).Name, actualAssignment.Name);
}
public async Task OnGet_NonexistentId_ReturnsNotFound()
{
var mockRepo = new Mock <IUserService>();
mockRepo.Setup(l => l.GetUserByIdAsync(It.IsAny <Guid>()))
.ReturnsAsync((UserView)null);
var pageModel = new EditModel(mockRepo.Object);
var result = await pageModel.OnGetAsync(Guid.Empty).ConfigureAwait(false);
result.Should().BeOfType <NotFoundResult>();
pageModel.UserId.Should().Be(Guid.Empty);
}
public async Task OnPostEditCalificaciones_VerSiRealmenteEdita()
{
// Arrange
//Preparamos un contexto que guarde la base de datos en memoria ram.
var OptionsBuilder = new DbContextOptionsBuilder <IdentityContext>()
.UseInMemoryDatabase("InMemoryDb");
IdentityContext TestIdentityContext = new IdentityContext(OptionsBuilder.Options);
Calificacion Calificacion = new Calificacion()
{
ID = 2, Nota = 5, Descripcion = "Descripcion de prueba"
};
//Guardamos una calificacion en bd
TestIdentityContext.Calificacion.Add(Calificacion);
TestIdentityContext.SaveChanges();
//Creo una instancia de Calificacion para comparar más adelante
Calificacion CalificacionEsperada = new Calificacion()
{
ID = 2, Nota = 1, Descripcion = "Nueva Descripcion"
};
// Act
//Creamos una pagina de tipo EditModel (de Calificaciones), la cual es la que se encarga de la logica
//de editar calificaciones en bd.
EditModel PageEditModel = new EditModel(TestIdentityContext);
//Simulamos haber hecho el edit en una calificaion con el id
await PageEditModel.OnGetAsync(Calificacion.ID);
//Modificamos los valores de los atributos de la instancia "calificacion" de Calificacion
PageEditModel.Calificacion.Descripcion = CalificacionEsperada.Descripcion;
PageEditModel.Calificacion.Nota = CalificacionEsperada.Nota;
//Simulamos un post que envíe el formulario de la pagina y por ende guarda los cambios de la edicion
await PageEditModel.OnPostAsync();
// Assert
//Buscamos si aún esta en bd la calificacion que debió haber sido editada por la pagina
Calificacion CalificacionRecibida = await TestIdentityContext.Calificacion.FindAsync(Calificacion.ID);
Assert.Equal(
CalificacionEsperada.Descripcion.ToString(),
CalificacionRecibida.Descripcion.ToString());
Assert.Equal(
CalificacionEsperada.Nota.ToString(),
CalificacionRecibida.Nota.ToString());
//Si se ejecuta correctamente, significa que el programa modifica correctamente calificaciones
}
public async Task OnPostEditEspecialidades_VerSiRealmenteEdita()
{
// Arrange
//Preparamos un contexto que guarde la base de datos en memoria ram.
var OptionsBuilder = new DbContextOptionsBuilder <IdentityContext>()
.UseInMemoryDatabase("InMemoryDb");
IdentityContext TestIdentityContext = new IdentityContext(OptionsBuilder.Options);
Especialidad Especialidad = new Especialidad()
{
ID = 2, Area = "Foto Fija", Nivel = "Basico"
};
//Guardamos una Especialidad en bd
TestIdentityContext.Especialidad.Add(Especialidad);
TestIdentityContext.SaveChanges();
//Creo una instancia de Especialidad para comparar más adelante
Especialidad EspecialidadEsperada = new Especialidad()
{
ID = 2, Area = "Animacion", Nivel = "Avanzado"
};
// Act
//Creamos una pagina de tipo EditModel (de Especialidades), la cual es la que se encarga de la logica
//de editar Especialidades en bd.
EditModel PageEditModel = new EditModel(TestIdentityContext);
//Simulamos haber hecho el edit en una especialidad con el id
await PageEditModel.OnGetAsync(Especialidad.ID);
//Modificamos los valores de los atributos de la instancia "Especialidad" de Especialidad
PageEditModel.Especialidad.Nivel = EspecialidadEsperada.Nivel;
PageEditModel.Especialidad.Area = EspecialidadEsperada.Area;
//Simulamos un post que envíe el formulario de la pagina y por ende guarda los cambios de la edicion
await PageEditModel.OnPostAsync();
// Assert
//Buscamos si aún esta en bd la Especialidad que debió haber sido editada por la pagina
Especialidad EspecialidadRecibida = await TestIdentityContext.Especialidad.FindAsync(Especialidad.ID);
Assert.Equal(
EspecialidadEsperada.Nivel.ToString(),
EspecialidadRecibida.Nivel.ToString());
Assert.Equal(
EspecialidadEsperada.Area.ToString(),
EspecialidadRecibida.Area.ToString());
//Si se ejecuta correctamente, significa que el programa modifica correctamente Especialidades
}
public async Task EditModel_GetRequestNotFoundResult()
{
// Arrange
var id = "test-post";
var repoPost = Mock.Create <IPostRepository>();
var repoUser = Mock.Create <IUserRepository>();
var pageModel = new EditModel(repoPost, repoUser);
Mock.Arrange(() => repoPost.GetAsync(id)).Returns(Task.FromResult((Post)null));
// Act
var result = await pageModel.OnGetAsync(id);
// Assert
Assert.IsType <NotFoundResult>(result);
}
public async Task OnGet_NonexistentId_ReturnsNotFound()
{
var mockRepo = new Mock <ICabinetRepository>();
mockRepo.Setup(l => l.GetCabinetSummaryAsync(It.IsAny <Guid>()))
.ReturnsAsync((CabinetSummaryDto)null)
.Verifiable();
var pageModel = new EditModel(mockRepo.Object);
var result = await pageModel.OnGetAsync(Guid.Empty).ConfigureAwait(false);
result.Should().BeOfType <NotFoundResult>();
pageModel.Id.Should().Be(Guid.Empty);
pageModel.OriginalCabinetName.ShouldBeNull();
pageModel.CabinetEdit.Should().Be(default);
public async Task OnGet_NonexistentId_ReturnsNotFound()
{
var mockRepo = new Mock <IFacilityRepository>();
mockRepo.Setup(l => l.GetFacilityAsync(It.IsAny <Guid>()))
.ReturnsAsync((FacilityDetailDto)null)
.Verifiable();
var mockSelectListHelper = new Mock <ISelectListHelper>();
var pageModel = new EditModel(mockRepo.Object, mockSelectListHelper.Object);
var result = await pageModel.OnGetAsync(Guid.Empty).ConfigureAwait(false);
result.Should().BeOfType <NotFoundResult>();
pageModel.Id.Should().Be(Guid.Empty);
pageModel.Facility.ShouldBeNull();
}
public async Task OnGet_PopulatesThePageModel()
{
var cabinet = RepositoryData.Cabinets[0];
var expected = new CabinetSummaryDto(cabinet);
var mockRepo = new Mock <ICabinetRepository>();
mockRepo.Setup(l => l.GetCabinetSummaryAsync(cabinet.Id))
.ReturnsAsync(expected)
.Verifiable();
var pageModel = new EditModel(mockRepo.Object);
var result = await pageModel.OnGetAsync(cabinet.Id).ConfigureAwait(false);
result.Should().BeOfType <PageResult>();
pageModel.Id.Should().Be(cabinet.Id);
pageModel.OriginalCabinetName.Should().Be(cabinet.Name);
pageModel.CabinetEdit.Should().BeEquivalentTo(new CabinetEditDto(expected));
}
public async Task OnGetAsync_ReturnsForbidResult_WithUnAuthorizedUser()
{
//Arrange
var authorizationService = new Mock <IAuthorizationService>();
authorizationService.Setup(x => x.AuthorizeAsync(It.IsAny <ClaimsPrincipal>(), It.IsAny <object>(), It.IsAny <IEnumerable <IAuthorizationRequirement> >()))
.ReturnsAsync(AuthorizationResult.Failed());
var store = new Mock <IUserStore <IdentityUser> >();
var userManager = new Mock <UserManager <IdentityUser> >(store.Object, null, null, null, null, null, null, null, null);
var pageModel = new EditModel(AppDbContext, authorizationService.Object, userManager.Object);
//Act
var result = await pageModel.OnGetAsync(1);
// Assert
Assert.IsType <ForbidResult>(result);
}
public async Task OnGetAsync_PopulatesThePageModel_WithAResource(int resourceId)
{
// Arrange
var optionsBuilder = new DbContextOptionsBuilder <ClippyContext>()
.UseInMemoryDatabase("InMemoryDb");
var mockContext = new Mock <ClippyContext>(optionsBuilder.Options);
var expectedResource = DatabaseInitializer.GetSeedingResources().Single(r => r.Id == resourceId);
mockContext.Setup(
db => db.GetResourceAsync(resourceId)).Returns(Task.FromResult(expectedResource));
var pageModel = new EditModel(mockContext.Object);
// Act
await pageModel.OnGetAsync(resourceId);
// Assert
var actualResource = Assert.IsAssignableFrom <EditResourceModel>(pageModel.Resource);
Assert.Equal(expectedResource.Location, actualResource.Location);
}
public async Task OnGet_PopulatesThePageModel()
{
var facilityId = RepositoryData.Facilities()[0].Id;
var facility = ResourceHelper.GetFacilityDetail(facilityId);
var mockRepo = new Mock <IFacilityRepository>();
mockRepo.Setup(l => l.GetFacilityAsync(It.IsAny <Guid>()))
.ReturnsAsync(facility)
.Verifiable();
var mockSelectListHelper = new Mock <ISelectListHelper>();
var pageModel = new EditModel(mockRepo.Object, mockSelectListHelper.Object);
var result = await pageModel.OnGetAsync(facility.Id).ConfigureAwait(false);
result.Should().BeOfType <PageResult>();
pageModel.Id.Should().Be(facility.Id);
pageModel.Facility.Should().BeEquivalentTo(new FacilityEditDto(facility));
}
public async Task EditModel_GetRequestSendsPostToPage()
{
// Arrange
var id = "test-post";
var repoPost = Mock.Create <IPostRepository>();
var repoUser = Mock.Create <IUserRepository>();
var pageModel = new EditModel(repoPost, repoUser);
Mock.Arrange(() => repoPost.GetAsync(id)).Returns(Task.FromResult(new Post {
ID = id
}));
// Act
await pageModel.OnGetAsync(id);
// Assert
var result = Assert.IsAssignableFrom <Post>(pageModel.Post);
Assert.Equal(id, result.ID);
}
public async Task OnGetAsync_PopulatesThePageModel_WithAUser(int userId)
{
// Arrange
var optionsBuilder = new DbContextOptionsBuilder <ClippyContext>()
.UseInMemoryDatabase("InMemoryDb");
var mockContext = new Mock <ClippyContext>(optionsBuilder.Options);
var mockLogger = new Mock <ILogger <EditModel> >();
var expectedUser = DatabaseInitializer.GetSeedingUsers().Single(u => u.Id == userId);
expectedUser.Roles = new List <Role>();
mockContext.Setup(
db => db.GetUserAsync(userId)).Returns(Task.FromResult(expectedUser));
var pageModel = new EditModel(mockContext.Object, mockLogger.Object);
// Act
await pageModel.OnGetAsync(userId);
// Assert
var actualUser = Assert.IsAssignableFrom <EditUserModel>(pageModel.UserEntity);
Assert.Equal(expectedUser.Username, actualUser.Username);
}