Exemple #1
0
        public void PrestarLibroNoDisponibleTest()
        {
            // Arrange
            Libro libro = new LibroTestDataBuilder().ConTitulo(CRONICA_UNA_MUERTE_ANUNCIADA).Build();

            repositorioLibro.Agregar(libro);
            Bibliotecario bibliotecario = new Bibliotecario(repositorioLibro, repositorioPrestamo);

            Prestamo prestamo = new Prestamo(DateTime.Now, libro, null, "Juan");

            repositorioPrestamo.Agregar(prestamo);

            // Act
            bibliotecario.Prestar(libro.Isbn, "Juan");
            try
            {
                bibliotecario.Prestar(libro.Isbn, "Juan");
                Assert.Fail();
            }
            catch (Exception err)
            {
                // Assert
                Assert.AreEqual("El libro no se encuentra disponible", err.Message);
            }
        }
        public void PrestarLibroNoDisponibleTest()
        {
            // Arrange
            Libro libro = new LibroTestDataBuilder().ConTitulo(CRONICA_UNA_MUERTE_ANUNCIADA).Build();

            repositorioLibro.Agregar(libro);
            Bibliotecario bibliotecario = new Bibliotecario(repositorioLibro, repositorioPrestamo);

            // Act
            bibliotecario.Prestar(libro.Isbn, "Juan");
            try
            {
                var esprestado = bibliotecario.EsPrestado(libro.Isbn);

                // Assert
                Assert.AreEqual(esprestado, true);

                /*
                 * bibliotecario.Prestar(libro.Isbn, "Juan");
                 * Assert.Fail();*/
            }
            catch (Exception err)
            {
                // Assert
                Assert.AreEqual("El libro no se encuentra disponible", err.Message);
            }
        }
Exemple #3
0
        public void EsPrestado()
        {
            var   libroTestDataBuilder = new LibroTestDataBuilder();
            Libro libro = libroTestDataBuilder.Build();

            repositorioPrestamo.Setup(r => r.ObtenerLibroPrestadoPorIsbn(libro.Isbn)).Returns(libro);
            Bibliotecario bibliotecario = new Bibliotecario(repositorioLibro.Object, repositorioPrestamo.Object);
            var           esprestado    = bibliotecario.EsPrestado(libro.Isbn);

            Assert.AreEqual(esprestado, true);
        }
Exemple #4
0
        public void LibroNoPrestadoTest()
        {
            var           libroTestDataBuilder = new LibroTestDataBuilder();
            Libro         libro         = libroTestDataBuilder.Build();
            Bibliotecario bibliotecario = new Bibliotecario(repositorioLibro.Object, repositorioPrestamo.Object);

            repositorioPrestamo.Setup(r => r.ObtenerLibroPrestadoPorIsbn(libro.Isbn)).Equals(null);
            var esprestado = bibliotecario.EsPrestado(libro.Isbn);

            Assert.IsFalse(esprestado);
        }
Exemple #5
0
        public void PrestarLibroTest()
        {
            var libro = new LibroTestDataBuilder().ConTitulo(CRONICAUNAMUERTEANUNCIADA).Build();

            _repositorioLibro.Agregar(libro);
            var bibliotecario = new Bibliotecario(_repositorioLibro, _repositorioPrestamo);

            bibliotecario.Prestar(libro.Isbn, "AlbertoPalencia");
            Assert.AreEqual(bibliotecario.EsPrestado(libro.Isbn), true);
            Assert.IsNotNull(_repositorioPrestamo.ObtenerLibroPrestadoPorIsbn(libro.Isbn));
        }
Exemple #6
0
        public void LibroNoPalindromeTest()
        {
            // Arrange
            Bibliotecario bibliotecario = new Bibliotecario(repositorioLibro.Object, repositorioPrestamo.Object);
            Libro         libro         = new LibroTestDataBuilder().ConIsbn(ISBN_NO_PALINDROMO).Build();

            // Act
            bibliotecario.ValidarSiEsPalindromo(libro.Isbn);

            // Assert
            Assert.AreEqual("1234", libro.Isbn);
        }
Exemple #7
0
        public void CalcularFechaMaximaEntregaTest()
        {
            Libro libro = new LibroTestDataBuilder().ConTitulo("Decisiones, la vida continua").ConIsbn("T878B85Z").Build();

            repositorioLibro.Agregar(libro);
            Bibliotecario bibliotecario = new Bibliotecario(repositorioLibro, repositorioPrestamo);

            var fechaPrestamo       = new DateTime(2017, 5, 26);
            var fechaMaximaEsperada = new DateTime(2017, 6, 12);
            var fechaEntregaMaxima  = bibliotecario.CalcularFechaEntregaMaxima(isbn: libro.Isbn, fechaPrestamo: fechaPrestamo);

            Assert.AreEqual(fechaEntregaMaxima, fechaMaximaEsperada);
        }
Exemple #8
0
        public void CalcularFechaIsbnMenor30Test()
        {
            // Arrange
            Bibliotecario bibliotecario = new Bibliotecario(repositorioLibro.Object, repositorioPrestamo.Object);
            Libro         libro         = new LibroTestDataBuilder().ConIsbn(ISBN_MENOR_30).Build();

            // Act
            DateTime fechaDePrestamo = DateTime.UtcNow;
            DateTime?fechaDeEntrega  = bibliotecario.CalcularFechaDeEntrega(libro.Isbn, fechaDePrestamo);

            // Assert
            Assert.AreEqual(null, fechaDeEntrega);
        }
Exemple #9
0
        public void CalcularFechaIsbnMayor30Test()
        {
            // Arrange
            Bibliotecario bibliotecario = new Bibliotecario(repositorioLibro.Object, repositorioPrestamo.Object);
            Libro         libro         = new LibroTestDataBuilder().ConIsbn(ISBN_MAYOR_30).Build();

            // Act
            DateTime fechaDePrestamo = DateTime.Parse(FECHA_PRESTAMO_MAYOR_30, CulturaColombiana);
            DateTime?fechaDeEntrega  = bibliotecario.CalcularFechaDeEntrega(libro.Isbn, fechaDePrestamo);

            // Assert
            Assert.AreEqual(FECHA_DEVOLUCION_MAYOR_30, fechaDeEntrega.Value.ToString("dd/MM/yyyy"));
        }
        public void EsPalindromo(string parameter, bool response)
        {
            // Arrange
            var           libroTestDataBuilder = new LibroTestDataBuilder();
            Libro         libro         = libroTestDataBuilder.Build();
            Bibliotecario bibliotecario = new Bibliotecario(repositorioLibro.Object, repositorioPrestamo.Object);

            // Act
            var result = bibliotecario.IsPalindrome(parameter);

            // Assert
            Assert.AreEqual(result, response);
        }
Exemple #11
0
        public void CrearLibroTest()
        {
            // Arrange
            LibroTestDataBuilder libroTestBuilder = new LibroTestDataBuilder().ConTitulo(TITULO).
                                                    ConAnio(ANIO).ConIsbn(ISBN);

            // Act
            Libro libro = libroTestBuilder.Build();

            // Assert
            Assert.AreEqual(TITULO, libro.Titulo);
            Assert.AreEqual(ISBN, libro.Isbn);
            Assert.AreEqual(ANIO, libro.Anio);
        }
Exemple #12
0
        public void VerificarSiExisteELLibro()
        {
            var   libroTest         = new LibroTestDataBuilder();
            Libro libroEnBiblioteca = libroTest.Build();

            repositorioPrestamo.Setup(r => r.ObtenerLibroPrestadoPorIsbn(libroEnBiblioteca.Isbn)).Equals(null);
            repositorioLibro.Setup(r => r.ObtenerPorIsbn(libroEnBiblioteca.Isbn)).Returns(libroEnBiblioteca);


            Bibliotecario bibliotecario = new Bibliotecario(repositorioLibro.Object, repositorioPrestamo.Object);
            Libro         libro         = bibliotecario.ValidacionesDePrestamo(libroEnBiblioteca.Isbn);


            Assert.IsNotNull(libro);
        }
        public void ValidateFechaNula()
        {
            Libro libro = new LibroTestDataBuilder().ConTitulo(CRONICA_UNA_MUERTE_ANUNCIADA).ConIsbn("123456").Build();

            repositorioLibro.Agregar(libro);
            Bibliotecario bibliotecario = new Bibliotecario(repositorioLibro, repositorioPrestamo);

            bibliotecario.Prestar(libro.Isbn, "pedrito");
            Assert.AreEqual(bibliotecario.EsPrestado(libro.Isbn), true);

            /*
             * Prestamo prestamo = repositorioPrestamo.Obtener(libro.Isbn);
             * Assert.AreEqual(null, prestamo.FechaEntregaMaxima);
             */
        }
Exemple #14
0
        public void PrestarLibroTest()
        {
            // Arrange
            Libro libro = new LibroTestDataBuilder().ConTitulo(CRONICA_UNA_MUERTE_ANUNCIADA).Build();

            repositorioLibro.Agregar(libro);
            Bibliotecario bibliotecario = new Bibliotecario(repositorioLibro, repositorioPrestamo);

            // Act
            bibliotecario.Prestar(libro.Isbn, "Juan");

            // Assert
            Assert.AreEqual(bibliotecario.EsPrestado(libro.Isbn), true);
            Assert.IsNotNull(repositorioPrestamo.ObtenerLibroPrestadoPorIsbn(libro.Isbn));
        }
Exemple #15
0
        public void PrestarLibroCuandoIsbnEsMayorA30Digitos(string parameter)
        {
            // Arrange
            Libro libro = new LibroTestDataBuilder().ConIsbn(parameter).Build();

            repositorioLibro.Agregar(libro);
            Bibliotecario bibliotecario = new Bibliotecario(repositorioLibro, repositorioPrestamo);

            // Act

            bibliotecario.Prestar(libro.Isbn, "Juan");

            // Assert
            Assert.AreEqual(bibliotecario.EsPrestado(libro.Isbn), true);
            Assert.IsNotNull(repositorioPrestamo.ObtenerLibroPrestadoPorIsbn(libro.Isbn));
        }
Exemple #16
0
        public void FechaEntregaPrestamoIsbnMenorQue30Test()
        {
            // Arrange

            Libro libro = new LibroTestDataBuilder().ConIsbn(ISBN_NUMERICOS_MENOR_QUE_30).Build();

            repositorioLibro.Agregar(libro);
            Bibliotecario bibliotecario = new Bibliotecario(repositorioLibro, repositorioPrestamo);

            DateTime fechaPrestamo = new DateTime(2017, 5, 24);

            DateTime?fechaEntrega = bibliotecario.ObtenerFechaEntregaPrestamo(libro.Isbn, fechaPrestamo);

            // Assert
            Assert.AreEqual(null, fechaEntrega);
        }
        public void ObtenerFechaMaxima(string DateTest, string DateFinally)
        {
            // Arrange
            DateTime dateFirst = DateTime.Parse(DateTest);
            DateTime dateMax   = DateTime.Parse(DateFinally);

            var           libroTestDataBuilder = new LibroTestDataBuilder();
            Libro         libro         = libroTestDataBuilder.Build();
            Bibliotecario bibliotecario = new Bibliotecario(repositorioLibro.Object, repositorioPrestamo.Object);

            // Act
            var result = bibliotecario.FechaMaximaEntrega(dateFirst);

            // Assert
            Assert.AreEqual(result.ToString("MM/dd/yyyy"), dateMax.ToString("MM/dd/yyyy"));
        }
Exemple #18
0
        public void EsIsbnPalindromo()
        {
            // Arrange
            // Arrange
            LibroTestDataBuilder libroTestBuilder = new LibroTestDataBuilder().ConTitulo("Mi tiempo, mi decisión").
                                                    ConAnio(2019).ConIsbn("12ASA21");

            // Act
            Libro libro = libroTestBuilder.Build();

            // Act
            Bibliotecario bibliotecario = new Bibliotecario(repositorioLibro.Object, repositorioPrestamo.Object);
            var           isPalindromo  = bibliotecario.EsIsbnPalindromo(libro.Isbn);

            // Assert
            Assert.AreEqual(isPalindromo, true);
        }
        public void PrestarLibroNoExistenteTest()
        {
            Libro libro = new LibroTestDataBuilder().ConTitulo(CRONICA_UNA_MUERTE_ANUNCIADA).Build();

            repositorioLibro.Agregar(libro);
            Bibliotecario bibliotecario = new Bibliotecario(repositorioLibro, repositorioPrestamo);

            try
            {
                bibliotecario.Prestar(ISBN_INCORECTO, "Esteban");
                Assert.Fail();
            }
            catch (Exception error)
            {
                Assert.AreEqual("El libro solicitado no se encuentra registrado", error.Message);
            }
        }
        public void IsPalindromo()
        {
            Libro libro = new LibroTestDataBuilder().ConTitulo(CRONICA_UNA_MUERTE_ANUNCIADA).ConIsbn("11211").Build();

            repositorioLibro.Agregar(libro);
            Bibliotecario bibliotecario = new Bibliotecario(repositorioLibro, repositorioPrestamo);

            try
            {
                bibliotecario.Prestar("11211", "juan");
                Assert.Fail();
            }
            catch (Exception ex)
            {
                Assert.AreEqual(Bibliotecario.STR_IS_PALINDROMO, ex.Message);
            }
        }
        public void PrestarLibroIsbnPalindromoTest()
        {
            Libro libro = new LibroTestDataBuilder().ConTitulo(CRONICA_UNA_MUERTE_ANUNCIADA).ConIsbn(ISBN_PALINDROMO).Build();

            repositorioLibro.Agregar(libro);
            Bibliotecario bibliotecario = new Bibliotecario(repositorioLibro, repositorioPrestamo);

            try
            {
                bibliotecario.Prestar(libro.Isbn, "Esteban");
                Assert.Fail();
            }
            catch (Exception error)
            {
                Assert.AreEqual("los libros palíndromos solo se pueden utilizar en la biblioteca", error.Message);
            }
        }
Exemple #22
0
        public void PrestarLibroConISBNPalindromo()
        {
            var libro = new LibroTestDataBuilder().ConIsbn(ISBN).Build();

            _repositorioLibro.Agregar(libro);
            var bibliotecario = new Bibliotecario(_repositorioLibro, _repositorioPrestamo);

            try
            {
                bibliotecario.Prestar(libro.Isbn, "AlbertoPalencia");
                Assert.Fail();
            }
            catch (Exception err)
            {
                Assert.AreEqual("Los libros palíndromos solo se pueden utilizar en la biblioteca", err.Message);
            }
        }
Exemple #23
0
        public void PrestarLibroConISBNSinNombreUsuario()
        {
            var libro = new LibroTestDataBuilder().ConTitulo(CRONICAUNAMUERTEANUNCIADA).Build();

            _repositorioLibro.Agregar(libro);
            var bibliotecario = new Bibliotecario(_repositorioLibro, _repositorioPrestamo);

            try
            {
                bibliotecario.Prestar(libro.Isbn, USER);
                Assert.Fail();
            }
            catch (Exception err)
            {
                Assert.AreEqual("El nombre del usuario no puede ser null", err.Message);
            }
        }
Exemple #24
0
        public void ZPrestarLibroVerificarFechaIsbnCortoTest()
        {
            // Arrange
            Libro libro = new LibroTestDataBuilder().ConIsbn(ISBN_UNDER30_X)
                          .Build();

            repositorioLibro.Agregar(libro);
            Bibliotecario bibliotecario = new Bibliotecario(repositorioLibro, repositorioPrestamo);


            // Act
            bibliotecario.Prestar(libro.Isbn, "Ana");


            //Assert
            Assert.IsNull(repositorioPrestamo.Obtener(libro.Isbn).FechaEntregaMaxima);//si no sobre pasa los 30 caracteres, guarda la entrega null
        }
Exemple #25
0
        public void LibroPalindromeTest()
        {
            // Arrange
            Bibliotecario bibliotecario = new Bibliotecario(repositorioLibro.Object, repositorioPrestamo.Object);
            Libro         libro         = new LibroTestDataBuilder().ConIsbn(ISBN_PALINDROMO).Build();

            // Act
            try
            {
                bibliotecario.ValidarSiEsPalindromo(libro.Isbn);
                Assert.Fail();
            }
            catch (Exception err)
            {
                // Assert
                Assert.AreEqual("los libros palíndromos solo se pueden utilizar en la biblioteca", err.Message);
            }
        }
Exemple #26
0
        public void PrestarLibroNoDisponibleTest()
        {
            var libro = new LibroTestDataBuilder().ConTitulo(CRONICAUNAMUERTEANUNCIADA).Build();

            _repositorioLibro.Agregar(libro);
            var bibliotecario = new Bibliotecario(_repositorioLibro, _repositorioPrestamo);

            bibliotecario.Prestar(libro.Isbn, "AlbertoPalencia");
            try
            {
                bibliotecario.Prestar(libro.Isbn, "AlbertoPalencia");
                Assert.Fail();
            }
            catch (Exception err)
            {
                Assert.AreEqual("El libro no se encuentra disponible", err.Message);
            }
        }
Exemple #27
0
        public void FechaEntregaDiferenteNull()
        {
            // Arrange
            Libro libro = new LibroTestDataBuilder().ConIsbn(ISBN_CON_FECHA_ENTREGA).Build();

            repositorioLibro.Agregar(libro);
            Bibliotecario bibliotecario = new Bibliotecario(repositorioLibro, repositorioPrestamo);

            // Act
            bibliotecario.Prestar(libro.Isbn, "Javier");

            // Assert
            Prestamo prestamo = repositorioPrestamo.Obtener(ISBN_CON_FECHA_ENTREGA);
            DateTime fechaConDomingosSumados = DateTime.Now.AddDays(15);

            Assert.IsNotNull(prestamo.FechaEntregaMaxima);
            Assert.AreNotEqual(fechaConDomingosSumados, prestamo.FechaEntregaMaxima);
        }
Exemple #28
0
        public void LibroEsPalindromo()
        {
            // Arrange
            Libro libro = new LibroTestDataBuilder().ConIsbn(PALINDROMO).Build();

            repositorioLibro.Agregar(libro);
            Bibliotecario bibliotecario = new Bibliotecario(repositorioLibro, repositorioPrestamo);

            try
            {
                bibliotecario.Prestar(libro.Isbn, "Jorge");
                Assert.Fail();
            }
            catch (Exception err)
            {
                // Assert
                Assert.AreEqual("Los libros palíndromos solo se pueden utilizar en la biblioteca", err.Message);
            }
        }
Exemple #29
0
        public void PrestarLibroNoDisponiblePorSerPalindromo(string parameter)
        {
            // Arrange
            Libro libro = new LibroTestDataBuilder().ConIsbn(parameter).Build();

            repositorioLibro.Agregar(libro);
            Bibliotecario bibliotecario = new Bibliotecario(repositorioLibro, repositorioPrestamo);

            // Act
            try
            {
                bibliotecario.Prestar(libro.Isbn, "Juan");
                Assert.Fail();
            }
            catch (Exception err)
            {
                // Assert
                Assert.AreEqual("El libro no se encuentra disponible", err.Message);
            }
        }
Exemple #30
0
        public void ZPrestarLibroIsbnPalindromoTest()
        {
            // Arrange
            Libro libro = new LibroTestDataBuilder().ConIsbn(ISBN_30PLUS_PALINDROME)
                          .Build();

            repositorioLibro.Agregar(libro);
            Bibliotecario bibliotecario = new Bibliotecario(repositorioLibro, repositorioPrestamo);

            try
            {
                // Act
                bibliotecario.Prestar(libro.Isbn, "Juan");
                Assert.Fail();
            }
            catch (Exception ex)
            {
                //Assert
                Assert.AreEqual("los libros palíndromos solo se pueden utilizar en la biblioteca", ex.Message);
            }
        }