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
        }
Example #2
0
        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);
        }
Example #3
0
        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);
        }
Example #4
0
        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);
        }
Example #5
0
        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);
        }
Example #6
0
        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);
        }
Example #7
0
        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);
        }
Example #8
0
        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
        }
Example #10
0
        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);
        }
Example #11
0
        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
        }
Example #12
0
        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);
        }
Example #13
0
        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);
        }
Example #14
0
        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);
        }
Example #15
0
        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);
        }
Example #16
0
        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);
        }