public async Task OnPostDeleteProyectosPersonales_VerSiRealmenteBorra()
{
// 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 = 45, 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);
await TestIdentityContext.SaveChangesAsync();
// Act
//Creamos una pagina de tipo DeleteModel (de Proyectos Personales), la cual es la que se encarga de la logica
//de borrar Proyectos Personales en bd.
DeleteModel PageDeleteModel = new DeleteModel(TestIdentityContext);
//Simulamos un post que envíe el formulario de la pagina y por ende borre en bd, el Proyecto Personal que ingresamos en bd anteriormente
await PageDeleteModel.OnPostAsync(ProyectoPersonal.ID);
// Assert
//Buscamos si aún esta en bd el Proyecto Personal que debió haber sido borrada por la pagina
ProyectoPersonal ProyectoPersonalRecibida = await TestIdentityContext.ProyectoPersonal.FindAsync(ProyectoPersonal.ID);
Assert.Null(ProyectoPersonalRecibida);
//Si es Null significa que la pagina lo borro correctamente
}
public async Task OnPostAsync_InvalidModel()
{
// Arrange
var apiResource = new ApiResource {
Id = Random.Next()
};
var apiResources = new Mock <DbSet <ApiResource> >();
apiResources.Setup(x => x.FindAsync(apiResource.Id)).ReturnsAsync(apiResource);
var context = new Mock <IConfigurationDbContext>();
context.Setup(x => x.ApiResources).Returns(apiResources.Object);
var id = Random.Next();
var delete = new DeleteModel(context.Object)
{
ApiResource = new ApiResource {
Id = id
}
};
// Act
var post = await delete.OnPostAsync().ConfigureAwait(false);
// Assert
apiResources.Verify(x => x.FindAsync(id), Times.Once);
apiResources.Verify(x => x.Remove(apiResource), Times.Never);
context.Verify(x => x.SaveChangesAsync(), Times.Never);
Assert.IsType <PageResult>(post);
}
public async Task OnPostAsync()
{
// Arrange
var identityResource = new IdentityResource {
Id = Random.Next()
};
var identityResources = new Mock <DbSet <IdentityResource> >();
identityResources.Setup(x => x.FindAsync(identityResource.Id)).ReturnsAsync(identityResource);
var context = new Mock <IConfigurationDbContext>();
context.Setup(x => x.IdentityResources).Returns(identityResources.Object);
var delete = new DeleteModel(context.Object)
{
IdentityResource = identityResource
};
// Act
var post = await delete.OnPostAsync().ConfigureAwait(false);
// Assert
identityResources.Verify(x => x.FindAsync(identityResource.Id), Times.Once);
identityResources.Verify(x => x.Remove(identityResource), Times.Once);
context.Verify(x => x.SaveChangesAsync(), Times.Once);
var result = Assert.IsType <RedirectToPageResult>(post);
Assert.Equal("./Index", result.PageName);
}
public async Task OnPostAsync_InvalidUserCode()
{
// Arrange
var deviceFlowCode = new DeviceFlowCodes {
UserCode = $"{Guid.NewGuid()}"
};
var deviceFlowCodes = new Mock <DbSet <DeviceFlowCodes> >();
deviceFlowCodes.Setup(x => x.FindAsync(deviceFlowCode.UserCode)).ReturnsAsync(deviceFlowCode);
var context = new Mock <IPersistedGrantDbContext>();
context.Setup(x => x.DeviceFlowCodes).Returns(deviceFlowCodes.Object);
var delete = new DeleteModel(context.Object)
{
DeviceFlowCode = new DeviceFlowCodes {
UserCode = string.Empty
}
};
// Act
var post = await delete.OnPostAsync().ConfigureAwait(false);
// Assert
deviceFlowCodes.Verify(x => x.FindAsync(deviceFlowCode.UserCode), Times.Never);
deviceFlowCodes.Verify(x => x.Remove(deviceFlowCode), Times.Never);
context.Verify(x => x.SaveChangesAsync(), Times.Never);
Assert.IsType <PageResult>(post);
}
public async Task OnPostAsync()
{
// Arrange
var deviceFlowCode = new DeviceFlowCodes {
UserCode = $"{Guid.NewGuid()}"
};
var deviceFlowCodes = new Mock <DbSet <DeviceFlowCodes> >();
deviceFlowCodes.Setup(x => x.FindAsync(deviceFlowCode.UserCode)).ReturnsAsync(deviceFlowCode);
var context = new Mock <IPersistedGrantDbContext>();
context.Setup(x => x.DeviceFlowCodes).Returns(deviceFlowCodes.Object);
var delete = new DeleteModel(context.Object)
{
DeviceFlowCode = deviceFlowCode
};
// Act
var post = await delete.OnPostAsync().ConfigureAwait(false);
// Assert
deviceFlowCodes.Verify(x => x.FindAsync(deviceFlowCode.UserCode), Times.Once);
deviceFlowCodes.Verify(x => x.Remove(deviceFlowCode), Times.Once);
context.Verify(x => x.SaveChangesAsync(), Times.Once);
var result = Assert.IsType <RedirectToPageResult>(post);
Assert.Equal("./Index", result.PageName);
}
public async Task OnPostAsync_InvalidId()
{
// Arrange
var client = new Client {
Id = Random.Next()
};
var clients = new Mock <DbSet <Client> >();
clients.Setup(x => x.FindAsync(client.Id)).ReturnsAsync(client);
var context = new Mock <IConfigurationDbContext>();
context.Setup(x => x.Clients).Returns(clients.Object);
var delete = new DeleteModel(context.Object)
{
Client = new Client {
Id = 0
}
};
// Act
var post = await delete.OnPostAsync().ConfigureAwait(false);
// Assert
clients.Verify(x => x.FindAsync(client.Id), Times.Never);
clients.Verify(x => x.Remove(client), Times.Never);
context.Verify(x => x.SaveChangesAsync(), Times.Never);
Assert.IsType <PageResult>(post);
}
public async Task OnPostAsync()
{
// Arrange
var client = new Client {
Id = Random.Next()
};
var clients = new Mock <DbSet <Client> >();
clients.Setup(x => x.FindAsync(client.Id)).ReturnsAsync(client);
var context = new Mock <IConfigurationDbContext>();
context.Setup(x => x.Clients).Returns(clients.Object);
var delete = new DeleteModel(context.Object)
{
Client = client
};
// Act
var post = await delete.OnPostAsync().ConfigureAwait(false);
// Assert
clients.Verify(x => x.FindAsync(client.Id), Times.Once);
clients.Verify(x => x.Remove(client), Times.Once);
context.Verify(x => x.SaveChangesAsync(), Times.Once);
var result = Assert.IsType <RedirectToPageResult>(post);
Assert.Equal("./Index", result.PageName);
}
public async Task OnPostAsync()
{
// Arrange
var persistedGrant = new PersistedGrant {
Key = $"{Guid.NewGuid()}"
};
var persistedGrants = new Mock <DbSet <PersistedGrant> >();
persistedGrants.Setup(x => x.FindAsync(persistedGrant.Key)).ReturnsAsync(persistedGrant);
var context = new Mock <IPersistedGrantDbContext>();
context.Setup(x => x.PersistedGrants).Returns(persistedGrants.Object);
var delete = new DeleteModel(context.Object)
{
PersistedGrant = persistedGrant
};
// Act
var post = await delete.OnPostAsync().ConfigureAwait(false);
// Assert
persistedGrants.Verify(x => x.FindAsync(persistedGrant.Key), Times.Once);
persistedGrants.Verify(x => x.Remove(persistedGrant), Times.Once);
context.Verify(x => x.SaveChangesAsync(), Times.Once);
var result = Assert.IsType <RedirectToPageResult>(post);
Assert.Equal("./Index", result.PageName);
}
public async Task OnPostDeleteEspecialidades_VerSiRealmenteBorra()
{
// 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 = 1, Area = "Foto Fija", Nivel = "Basico"
};
//Guardamos una Especialidad en bd
TestIdentityContext.Especialidad.Add(Especialidad);
await TestIdentityContext.SaveChangesAsync();
// Act
//Creamos una pagina de tipo DeleteModel (de Especialidades), la cual es la que se encarga de la logica
//de borrar Especialidades en bd.
DeleteModel PageDeleteModel = new DeleteModel(TestIdentityContext);
//Simulamos un post que envíe el formulario de la pagina y por ende borre en bd la Especialidad que ingresamos en bd anteriormente
await PageDeleteModel.OnPostAsync(Especialidad.ID);
// Assert
//Buscamos si aún esta en bd la Especialidad que debió haber sido borrada por la pagina
Especialidad EspecialidadRecibida = await TestIdentityContext.Especialidad.FindAsync(Especialidad.ID);
Assert.Null(EspecialidadRecibida);
//Si es Null significa que la pagina lo borro correctamente
}
public async Task OnPostAsync_InvalidKey()
{
// Arrange
var persistedGrant = new PersistedGrant {
Key = $"{Guid.NewGuid()}"
};
var persistedGrants = new Mock <DbSet <PersistedGrant> >();
persistedGrants.Setup(x => x.FindAsync(persistedGrant.Key)).ReturnsAsync(persistedGrant);
var context = new Mock <IPersistedGrantDbContext>();
context.Setup(x => x.PersistedGrants).Returns(persistedGrants.Object);
var delete = new DeleteModel(context.Object)
{
PersistedGrant = new PersistedGrant {
Key = string.Empty
}
};
// Act
var post = await delete.OnPostAsync().ConfigureAwait(false);
// Assert
persistedGrants.Verify(x => x.FindAsync(persistedGrant.Key), Times.Never);
persistedGrants.Verify(x => x.Remove(persistedGrant), Times.Never);
context.Verify(x => x.SaveChangesAsync(), Times.Never);
Assert.IsType <PageResult>(post);
}
public async Task OnPostDeleteCalificaciones_VerSiRealmenteBorra()
{
// 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 = 1, Nota = 5, Descripcion = "Descripcion de prueba"
};
//Guardamos una calificacion en bd
TestIdentityContext.Calificacion.Add(Calificacion);
await TestIdentityContext.SaveChangesAsync();
// Act
//Creamos una pagina de tipo DeleteModel (de Calificaciones), la cual es la que se encarga de la logica
//de borrar calificaciones en bd.
DeleteModel pageDeleteModel = new DeleteModel(TestIdentityContext);
//Simulamos un post que envíe el formulario de la pagina y por ende borre en bd la calificacion que ingresamos en bd anteriormente
await pageDeleteModel.OnPostAsync(Calificacion.ID);
// Assert
//Buscamos si aún esta en bd la calificacion que debió haber sido borrada por la pagina
Calificacion CalificacionRecibida = await TestIdentityContext.Calificacion.FindAsync(Calificacion.ID);
Assert.Null(CalificacionRecibida);
//Si es Null significa que la pagina lo borro correctamente
}
public async Task OnPost_IfValidModel_ReturnsDetailsPage()
{
var id = Guid.NewGuid();
var mockRepo = new Mock <IFacilityRepository>();
mockRepo.Setup(l => l.DeleteFacilityAsync(It.IsAny <Guid>()));
var pageModel = new DeleteModel(mockRepo.Object)
{
Id = id,
};
var result = await pageModel.OnPostAsync().ConfigureAwait(false);
result.Should().BeOfType <RedirectToPageResult>();
pageModel.ModelState.IsValid.ShouldBeTrue();
((RedirectToPageResult)result).PageName.Should().Be("./Details");
((RedirectToPageResult)result).RouteValues["id"].Should().Be(id);
}
public async Task OnPostAsync()
{
// Arrange
var users = new List <User> {
new User()
};
var role = new Role
{
Id = Guid.NewGuid(),
Name = "Name",
UserRoles = users.Select(x => new UserRole {
User = x
}).ToList()
};
_roleManager.Setup(x => x.FindByIdAsync($"{role.Id}")).ReturnsAsync(role);
_userManager.Setup(x => x.GetUsersInRoleAsync(role.Name)).ReturnsAsync(users);
var delete = new DeleteModel(_roleManager.Object, _userManager.Object)
{
Role = role
};
// Act
var post = await delete.OnPostAsync().ConfigureAwait(false);
// Assert
_roleManager.Verify(x => x.FindByIdAsync($"{role.Id}"), Times.Once);
_userManager.Verify(x => x.GetUsersInRoleAsync(role.Name), Times.Once);
foreach (var user in role.UserRoles.Select(x => x.User))
{
_userManager.Verify(
x => x.RemoveClaimAsync(
user,
It.Is <Claim>(y => y.Type.Equals(ClaimTypes.Role) && y.Value.Equals(role.Name))),
Times.Once);
}
var result = Assert.IsType <RedirectToPageResult>(post);
Assert.Equal("./Index", result.PageName);
}
public async Task OnPostAsync()
{
// Arrange
var user = new User {
Id = Guid.NewGuid()
};
_userManager.Setup(x => x.FindByIdAsync($"{user.Id}")).ReturnsAsync(user);
var delete = new DeleteModel(_userManager.Object)
{
UserModel = user
};
// Act
var post = await delete.OnPostAsync().ConfigureAwait(false);
// Assert
_userManager.Verify(x => x.FindByIdAsync($"{user.Id}"), Times.Once);
_userManager.Verify(x => x.DeleteAsync(user), Times.Once);
var result = Assert.IsType <RedirectToPageResult>(post);
Assert.Equal("./Index", result.PageName);
}
public async Task OnPostAsync_InvalidModel()
{
// Arrange
var user = new User {
Id = Guid.NewGuid()
};
_userManager.Setup(x => x.FindByIdAsync($"{user.Id}")).ReturnsAsync(user);
var id = Guid.NewGuid();
var delete = new DeleteModel(_userManager.Object)
{
UserModel = new User {
Id = id
}
};
// Act
var post = await delete.OnPostAsync().ConfigureAwait(false);
// Assert
_userManager.Verify(x => x.FindByIdAsync($"{id}"), Times.Once);
_userManager.Verify(x => x.DeleteAsync(user), Times.Never);
Assert.IsType <PageResult>(post);
}
public async Task OnPostAsync_InvalidId()
{
// Arrange
var role = new Role {
Id = Guid.NewGuid()
};
_roleManager.Setup(x => x.FindByIdAsync($"{role.Id}")).ReturnsAsync(role);
var id = Guid.Empty;
var delete = new DeleteModel(_roleManager.Object, _userManager.Object)
{
Role = new Role {
Id = id
}
};
// Act
var post = await delete.OnPostAsync().ConfigureAwait(false);
// Assert
_roleManager.Verify(x => x.FindByIdAsync($"{id}"), Times.Never);
_roleManager.Verify(x => x.DeleteAsync(role), Times.Never);
Assert.IsType <PageResult>(post);
}