public void PerfilesController_ListarPerfiles()
        {
            HelperTestSistema.LimpiarArchivoBD();
            HelperTestSistema.IniciarServidor();
            //Generamos dos perfiles de prueba
            var perfiles = HelperInstanciacionPerifles.GetPerfiles(2);

            //Guardamos los perfiles directamente en la base de datos
            using (IContextoProceso contexto = new ContextoProceso(HelperTestSistema.ObjectFactory))
            {
                foreach (Rol perfil in perfiles)
                {
                    contexto.ContenedorObjetos.Store(perfil);
                }
            }

            //Reiniciamos la conexion
            HelperTestSistema.ReiniciarConexion();

            //Obtenermos los perfiles desede el controller
            var controller = new PerfilesController(HelperTestSistema.ObjectFactory);
            var perfilesBD = controller.Get();

            HelperTestSistema.ReiniciarConexion();

            HelperTestSistema.FinalizarServidor();

            //Asserts
            Assert.Inconclusive("Refactorizar y terminar este test");
            //En la BD dede haber solo dos perfiles
            Assert.AreEqual(2, perfilesBD.ToList().Count);
            //Las instancias retornadas  deben ser diferencias a las almacenadas manualmente
            Assert.AreNotSame(perfiles[0], perfilesBD.ToList()[0]);
            Assert.AreNotSame(perfiles[1], perfilesBD.ToList()[1]);
        }
Esempio n. 2
0
        public void Test_AltaProyectos()
        {
            HelperTestSistema.LimpiarArchivoBD();
            HelperTestSistema.IniciarServidor();

            using (IBugtracker bugzzinga = HelperTestSistema.ObjectFactory.Create <IBugtracker>())
            {
                Proyecto p1 = bugzzinga.NuevoProyecto();
                p1.Codigo = "P1";
                p1.Nombre = "Proyecto1";
                bugzzinga.AgregarProyecto(p1);

                Proyecto p2 = bugzzinga.NuevoProyecto();
                p2.Codigo = "P2";
                p2.Nombre = "Proyecto2";
                bugzzinga.AgregarProyecto(p2);

                Proyecto p3 = bugzzinga.NuevoProyecto();
                p3.Codigo = "P3";
                p3.Nombre = "Proyecto3";
                bugzzinga.AgregarProyecto(p3);
            }

            using (IBugtracker bugzzinga = HelperTestSistema.ObjectFactory.Create <IBugtracker>())
            {
                IEnumerable <Proyecto> proyectos     = bugzzinga.Proyectos;
                IList <Proyecto>       proyectosList = proyectos.ToList();
            }

            HelperTestSistema.FinalizarServidor();
        }
Esempio n. 3
0
        public void UsuariosController_AsignarOtroPerfilAUnUsuario()
        {
            HelperTestSistema.LimpiarArchivoBD();
            HelperTestSistema.IniciarServidor();

            //Generamos los perfiles y los usuarios de prueba en la base de datos
            var perfiles = HelperInstanciacionPerifles.GetPerfiles(2);
            var usuarios = HelperInstanciacionUsuarios.GetUsuarios(2);

            using (IContextoProceso contexto = new ContextoProceso(HelperTestSistema.ObjectFactory))
            {
                contexto.ContenedorObjetos.Store(perfiles);
                //usuarios[0].Perfil = perfiles[0];
                //usuarios[1].Perfil = perfiles[1];
                contexto.ContenedorObjetos.Store(usuarios);
            }
            HelperTestSistema.ReiniciarConexion();

            //Obtengo los perfiles registrados en el sistema
            var perfilesController    = new PerfilesController(HelperTestSistema.ObjectFactory);
            var perfilesPrimerRequest = perfilesController.Get();

            HelperTestSistema.ReiniciarConexion();

            //Obtengo los usuarios registrados en el sistema
            var controller            = new UsuariosController(HelperTestSistema.ObjectFactory);
            var usuariosPrimerRequest = controller.Get();

            HelperTestSistema.ReiniciarConexion();

            //Le asigno el perfil 2 al usuario 1
            var usuarioAModificar = usuariosPrimerRequest.ToList()[0];

            //usuarioAModificar.Perfil = perfilesPrimerRequest.ToList()[1];
            controller.Put(usuarioAModificar);
            HelperTestSistema.ReiniciarConexion();

            //Obtenemos los datos para la validacion
            var perfilesBD = new List <Rol>();
            var usuariosBD = new List <Usuario>();

            using (IContextoProceso contexto = new ContextoProceso(HelperTestSistema.ObjectFactory))
            {
                perfilesBD = (from Rol p in contexto.ContenedorObjetos select p).ToList();
                usuariosBD = (from Usuario u in contexto.ContenedorObjetos select u).ToList();
            }
            HelperTestSistema.ReiniciarConexion();

            HelperTestSistema.FinalizarServidor();

            //Asserts
            Assert.Inconclusive("Refactorizar y terminar este test");
            //Tiene que haber 2 usuarios en la BD
            Assert.AreEqual(2, usuariosBD.Count);
            //Tiene que haber 2 perfiles en la BD
            Assert.AreEqual(2, perfilesBD.Count);
            //El usuario 1 debe tener asociado el perfil 2
            //Assert.AreEqual( "Perfil 2", usuariosBD[0].Perfil.Nombre );
            //Assert.AreSame( perfilesBD[1], usuariosBD[0].Perfil );
        }
Esempio n. 4
0
        public void UsuariosController_NuevoUsuario()
        {
            HelperTestSistema.LimpiarArchivoBD();
            HelperTestSistema.IniciarServidor();

            //Generamos un usuario de prueba
            var usuarioDto = HelperInstanciacionUsuarios.GetUsuarios(1)[0];

            //Guardamos el usuario a traves del controller
            var controller = new UsuariosController(HelperTestSistema.ObjectFactory);

            controller.Post(usuarioDto);
            HelperTestSistema.ReiniciarConexion();

            //Traemos los usuarios registrrados en el sistema
            var usuariosBD = controller.Get();

            HelperTestSistema.ReiniciarConexion();

            HelperTestSistema.FinalizarServidor();

            //Asserts
            Assert.Inconclusive("Refactorizar y terminar este test");
            //Debe haber un solo usuario en la base de datos
            Assert.AreEqual(1, usuariosBD.Count());
            //El usuario se debe llamar usuario 1
            Assert.AreEqual("Usuario 1", usuariosBD.ToList()[0].Nombre);
            //La instancia del usuario debe ser distinta a la instancia del usuario dto
            Assert.AreNotSame(usuarioDto, usuariosBD.ToList()[0]);
        }
Esempio n. 5
0
        public void UsuariosController_ListarUsuarios()
        {
            HelperTestSistema.LimpiarArchivoBD();
            HelperTestSistema.IniciarServidor();

            //Generamos dos usuarios de prueba directamente sobre la BD
            var usuarios = HelperInstanciacionUsuarios.GetUsuarios(2);

            using (IContextoProceso contexto = new ContextoProceso(HelperTestSistema.ObjectFactory))
            {
                contexto.ContenedorObjetos.Store(usuarios);
            }
            //Reseteamos la conexion a la BD
            HelperTestSistema.ReiniciarConexion();

            //Cargo los usuarios solicitandolos al controller
            var controller = new UsuariosController(HelperTestSistema.ObjectFactory);
            var usuariosBD = controller.Get();

            HelperTestSistema.ReiniciarConexion();

            HelperTestSistema.FinalizarServidor();

            //Asserts
            Assert.Inconclusive("Refactorizar y terminar este test");
            //En la base de datos tiene que haber 2 usuarios
            Assert.AreEqual(2, usuariosBD.Count());
            //El nombre del primer usuario debe ser usuario 1
            Assert.AreEqual("Usuario 1", usuariosBD.ToList()[0].Nombre);
            //El nombre del segundo usuario debe ser usuario 2
            Assert.AreEqual("Usuario 2", usuariosBD.ToList()[1].Nombre);
        }
        public void PerfilesController_NuevoPerfil()
        {
            HelperTestSistema.LimpiarArchivoBD();
            HelperTestSistema.IniciarServidor();

            //Instanciamos un perfil de prueba
            var perfilDto = HelperInstanciacionPerifles.GetPerfiles(1)[0];

            //Guardarmos el perfil
            var controller = new PerfilesController(HelperTestSistema.ObjectFactory);

            controller.Post(perfilDto);
            HelperTestSistema.ReiniciarConexion();

            //Obtenemos los perfiles almacenados
            var perfilesBD = controller.Get();

            HelperTestSistema.ReiniciarConexion();

            HelperTestSistema.FinalizarServidor();

            //Asserts
            Assert.Inconclusive("Refactorizar y terminar este test");
            //Solo debe haber un perfil almecenado
            Assert.AreEqual(1, perfilesBD.ToList().Count);
            //La instancia del perfil almacenado debe ser diferente
            Assert.AreNotSame(perfilDto, perfilesBD.ToList()[0]);
            //EL nombre de la instancia del perfil seleccionado debe ser el correcto
            Assert.AreEqual("Perfil 1", perfilesBD.ToList()[0].Nombre);
        }
Esempio n. 7
0
        public void Test_AltaPerfilDuplicado()
        {
            HelperTestSistema.LimpiarArchivoBD();
            HelperTestSistema.IniciarServidor();

            using (IBugtracker bugzzinga = new BugTrackerPersistente())
            {
                Perfil p1 = bugzzinga.NuevoPerfil();
                p1.Nombre      = "Perfil1";
                p1.Descripcion = "perfil de prueba";

                bugzzinga.RegistrarPerfil(p1);
            }


            using (IBugtracker bugzzinga = new BugTrackerPersistente())
            {
                Perfil p1 = bugzzinga.NuevoPerfil();
                p1.Nombre      = "Perfil1";
                p1.Descripcion = "perfil de prueba";

                bugzzinga.RegistrarPerfil(p1);
            }

            HelperTestSistema.FinalizarServidor();
        }
Esempio n. 8
0
        public void UsuariosController_ListarUsuariosDeUnProyecto()
        {
            HelperTestSistema.LimpiarArchivoBD();
            HelperTestSistema.IniciarServidor();

            HelperTestSistema.FinalizarServidor();

            //Asserts
            Assert.Inconclusive("Terminar este test cuando pensemos bien la implementacion de usuarios asociados a un proyecto");
        }
Esempio n. 9
0
        public void TiposItemController_QuitarTipoDeItemDeProyecto()
        {
            HelperTestSistema.LimpiarArchivoBD();
            HelperTestSistema.IniciarServidor();

            //Creamos 1 proyecto1 directamente en la BD con tres tipos de item
            var tiposDeItemProyecto1 = HelperInstanciacionItems.GetTiposDeItem("Proyecto 1", 3);
            var proyecto             = HelperInstanciacionProyectos.GetProyectos(1)[0];

            proyecto.AgregarTipoDeItem(tiposDeItemProyecto1[0]);
            proyecto.AgregarTipoDeItem(tiposDeItemProyecto1[1]);
            proyecto.AgregarTipoDeItem(tiposDeItemProyecto1[2]);

            //Guardamos los objetos en la BD
            using (IContextoProceso contexto = new ContextoProceso(HelperTestSistema.ObjectFactory))
            {
                contexto.ContenedorObjetos.Store(proyecto);
            }

            HelperTestSistema.ReiniciarConexion();


            //Obtenemos los tipos de item desde el controller y damos de baja el tipo de item 2
            var controller = new TiposItemController(HelperTestSistema.ObjectFactory);
            var tiposItem  = controller.Get("P1");

            var tipoItemABorrar = tiposItem.ToList()[1];

            controller.Delete("P1", tipoItemABorrar.Nombre);
            HelperTestSistema.ReiniciarConexion();

            //Obtenemos los datos directamente de la BD para validarlos
            var proyectosBD = new List <Proyecto>();
            var tiposItemBD = new List <TipoItem>();

            using (IContextoProceso contexto = new ContextoProceso(HelperTestSistema.ObjectFactory))
            {
                proyectosBD = (from Proyecto p in contexto.ContenedorObjetos select p).ToList();
                tiposItemBD = (from TipoItem t in contexto.ContenedorObjetos select t).ToList();
            }


            HelperTestSistema.ReiniciarConexion();
            HelperTestSistema.FinalizarServidor();

            //Asserts
            Assert.Inconclusive("Refactorizar y terminar este test");
            //Debe haber 1 proyecto en la BD
            Assert.AreEqual(1, proyectosBD.Count);
            //El proyecto debe tener dos tipos de item
            Assert.AreEqual(2, proyectosBD[0].TiposDeItem.Count());
            //Solo debe haber dos tipos de item en la BD
            Assert.AreEqual(2, tiposItemBD.Count);
        }
Esempio n. 10
0
        public void TiposItemController_ListarTiposItemDeProyecto()
        {
            HelperTestSistema.LimpiarArchivoBD();
            HelperTestSistema.IniciarServidor();

            //Creamos dos proyectos directamente en la BD
            //Cada proyecto tiene dos tipos de item
            var tiposDeItemProyecto1 = HelperInstanciacionItems.GetTiposDeItem("Proyecto 1", 2);
            var tiposDeItemProyecto2 = HelperInstanciacionItems.GetTiposDeItem("Proyecto 2", 2);
            var proyectos            = HelperInstanciacionProyectos.GetProyectos(2);

            proyectos[0].AgregarTipoDeItem(tiposDeItemProyecto1[0]);
            proyectos[0].AgregarTipoDeItem(tiposDeItemProyecto1[1]);

            proyectos[1].AgregarTipoDeItem(tiposDeItemProyecto2[0]);
            proyectos[1].AgregarTipoDeItem(tiposDeItemProyecto2[1]);

            //Guardamos los objetos en la BD
            using (IContextoProceso contexto = new ContextoProceso(HelperTestSistema.ObjectFactory))
            {
                contexto.ContenedorObjetos.Store(proyectos);
            }

            HelperTestSistema.ReiniciarConexion();

            //Ahora obtenemos los datos desde la API
            var controller = new TiposItemController(HelperTestSistema.ObjectFactory);

            //Obtenemos los tipos de item del proyecto 1 desde la API
            var tiposDeItemProyecto1Request = controller.Get("P1");

            HelperTestSistema.ReiniciarConexion();

            //Obtenemos los tipso de item del proyecto 2 desde la API
            var tiposDeItemProyecto2Request = controller.Get("P2");

            HelperTestSistema.ReiniciarConexion();


            HelperTestSistema.FinalizarServidor();

            //Asserts
            Assert.Inconclusive("Refactorizar y terminar este test");
            //La cantidad de tipos de item del proyecto 1 debe ser 2
            Assert.AreEqual(2, tiposDeItemProyecto1.Count);
            //Los nombres y descripciones de los tipos de item del proyecto 1 deben ser los correctos
            Assert.AreEqual(2, tiposDeItemProyecto2.Count);
            //Los nombres y descripciones de los tipos de item del proyecto 2 deben ser los correctos
            Assert.AreEqual("Proyecto 1-Tipo de item de prueba 1", tiposDeItemProyecto1[0].Descripcion);
            Assert.AreEqual("Proyecto 1-Tipo de item de prueba 2", tiposDeItemProyecto1[1].Descripcion);
            //La cantidad de tipos de item del proyecto 2 debe ser 2
            Assert.AreEqual("Proyecto 2-Tipo de item de prueba 1", tiposDeItemProyecto2[0].Descripcion);
            Assert.AreEqual("Proyecto 2-Tipo de item de prueba 2", tiposDeItemProyecto2[1].Descripcion);
        }
Esempio n. 11
0
        public void ItemsController_AgrearItemAProyecto()
        {
            HelperTestSistema.LimpiarArchivoBD();
            HelperTestSistema.IniciarServidor();

            //Creamos un proyecto y lo guardamos directamente en la base de datos
            var proyecto = HelperInstanciacionProyectos.GetProyectos(1)[0];

            using (IContextoProceso contexto = new ContextoProceso(HelperTestSistema.ObjectFactory))
            {
                contexto.ContenedorObjetos.Store(proyecto);
            }

            //Instanciamos un nuevo item y lo agregamos al proyecto

            Item nuevoItem = new Item(
                "Item  test", "Descripcion item test",
                new TipoItem("Tipo 1", "Tipo 1 test"),
                new Prioridad("Prioridad 1", "Prioridad de prueba"));

            var controller = new ItemsController(HelperTestSistema.ObjectFactory);

            controller.Post("P1", nuevoItem);

            //Obtenemos los datos de la BD para validarlos
            var proyectosBD = new List <Proyecto>();
            var tipoItem    = new TipoItem();
            var prioridad   = new Prioridad("", "");

            using (IContextoProceso contexto = new ContextoProceso(HelperTestSistema.ObjectFactory))
            {
                proyectosBD = (from Proyecto p in contexto.ContenedorObjetos select p).ToList();
                prioridad   = (from Prioridad p in contexto.ContenedorObjetos select p).SingleOrDefault();
                tipoItem    = (from TipoItem ti in contexto.ContenedorObjetos select ti).SingleOrDefault();
            }

            HelperTestSistema.ReiniciarConexion();
            HelperTestSistema.FinalizarServidor();

            //Asserts
            Assert.Inconclusive("Refactorizar y terminar este test");
            //Tiene que haber un solo proyecto en la BD
            Assert.AreEqual(1, proyectosBD.Count);
            //El proyecto debe tener un item
            Assert.AreEqual(1, proyectosBD[0].Items.Count());
            //El  item debe tener el nombre y la descripcion correcta
            Assert.AreEqual("Descripcion item test", proyectosBD[0].Items.ToList()[0].Descripcion);
            //El  item debe tener la prioridad correcta
            Assert.AreSame(prioridad, proyectosBD[0].Items.ToList()[0].Prioridad);
            Assert.AreEqual("Prioridad 1", proyectosBD[0].Items.ToList()[0].Prioridad.Nombre);
            //El item debe tener asignado el tipo de item correcto
            Assert.AreSame(tipoItem, proyectosBD[0].Items.ToList()[0].TipoItem);
            Assert.AreEqual("Tipo 1", proyectosBD[0].Items.ToList()[0].TipoItem.Nombre);
        }
Esempio n. 12
0
        public void ItemsController_CambiarEstado()
        {
            HelperTestSistema.LimpiarArchivoBD();
            HelperTestSistema.IniciarServidor();

            HelperTestSistema.ReiniciarConexion();
            HelperTestSistema.FinalizarServidor();

            //Asserts
            Assert.Inconclusive("Terminar test");
        }
Esempio n. 13
0
        public void UsuariosController_ModificarUsuarioConPerfil()
        {
            HelperTestSistema.LimpiarArchivoBD();
            HelperTestSistema.IniciarServidor();

            //Generamos los perfiles y los usuarios de prueba en la base de datos
            var perfiles = HelperInstanciacionPerifles.GetPerfiles(2);
            var usuarios = HelperInstanciacionUsuarios.GetUsuarios(2);

            using (IContextoProceso contexto = new ContextoProceso(HelperTestSistema.ObjectFactory))
            {
                contexto.ContenedorObjetos.Store(perfiles);
                //usuarios[0].Perfil = perfiles[0];
                //usuarios[1].Perfil = perfiles[1];
                contexto.ContenedorObjetos.Store(usuarios);
            }

            HelperTestSistema.ReiniciarConexion();

            //Obtenemos los usuarios registrados
            var controller            = new UsuariosController(HelperTestSistema.ObjectFactory);
            var usuariosPrimerRequest = controller.Get();

            HelperTestSistema.ReiniciarConexion();

            //Modificamos el primer usuario y lo guardamos
            usuariosPrimerRequest.ToList()[0].Apellido = "apellido 1 modificado";
            controller.Put(usuariosPrimerRequest.ToList()[0]);
            HelperTestSistema.ReiniciarConexion();

            //Obtenemos los datos para validar
            var perfilesBD = new List <Rol>();
            var usuariosBD = new List <Usuario>();

            using (IContextoProceso contexto = new ContextoProceso(HelperTestSistema.ObjectFactory))
            {
                perfilesBD = (from Rol p in contexto.ContenedorObjetos select p).ToList();
                usuariosBD = (from Usuario u in contexto.ContenedorObjetos select u).ToList();
            }


            HelperTestSistema.FinalizarServidor();

            //Asserts
            Assert.Inconclusive("Refactorizar y terminar este test");
            //Los usuarios de la BD deben ser 2
            Assert.AreEqual(2, usuariosBD.Count);
            //Los perfiles de la BD deben ser 2
            Assert.AreEqual(2, perfilesBD.Count);
            //El apellido del primer usuario debe estar modificado
            Assert.AreEqual("apellido 1 modificado", usuariosBD[0].Apellido);
            //El primer usuario debe tener asignado el perfil 1
            //Assert.AreSame( perfilesBD[0], usuariosBD[0].Perfil );
        }
Esempio n. 14
0
        public void UsuariosController_EliminarUsuario()
        {
            HelperTestSistema.LimpiarArchivoBD();
            HelperTestSistema.IniciarServidor();



            HelperTestSistema.FinalizarServidor();

            //Asserts
            Assert.Inconclusive("Refactorizar y terminar este test");
        }
Esempio n. 15
0
        public void TiposItemController_AgregarTipoDeItemAProyecto()
        {
            HelperTestSistema.LimpiarArchivoBD();
            HelperTestSistema.IniciarServidor();

            //Creamos 1 proyecto1 directamente en la BD con dos tipos de item
            var tiposDeItemProyecto1 = HelperInstanciacionItems.GetTiposDeItem("Proyecto 1", 2);
            var proyecto             = HelperInstanciacionProyectos.GetProyectos(1)[0];

            proyecto.AgregarTipoDeItem(tiposDeItemProyecto1[0]);
            proyecto.AgregarTipoDeItem(tiposDeItemProyecto1[1]);

            //Guardamos los objetos en la BD
            using (IContextoProceso contexto = new ContextoProceso(HelperTestSistema.ObjectFactory))
            {
                contexto.ContenedorObjetos.Store(proyecto);
            }

            HelperTestSistema.ReiniciarConexion();



            //Creamos un tipo de item y lo agregamos al proyecto a traves de la API
            var controller = new TiposItemController(HelperTestSistema.ObjectFactory);

            //Obtenemos el 2 ya que tenemos que simular un nuevo tipo de item
            var nuevoTipoItem = HelperInstanciacionItems.GetTiposDeItem("Proyecto 1", 3)[2];

            controller.Post("P1", nuevoTipoItem);
            HelperTestSistema.ReiniciarConexion();

            //Obtenemos los datos directamente de la base de datos para verificarlos

            var proyectosBD = new List <Proyecto>();

            using (IContextoProceso contexto = new ContextoProceso(HelperTestSistema.ObjectFactory))
            {
                proyectosBD = (from Proyecto p in contexto.ContenedorObjetos select p).ToList();
            }


            HelperTestSistema.ReiniciarConexion();
            HelperTestSistema.FinalizarServidor();

            //Asserts
            Assert.Inconclusive("Refactorizar y terminar este test");
            //Debe haber un solo proyecto en la base de datos
            Assert.AreEqual(1, proyectosBD.ToList().Count);
            //El proyecto debe tener 3 tipos de item
            Assert.AreEqual(3, proyectosBD[0].TiposDeItem.Count());
            //El tercer tipo de item debe ser el que agregamos
            Assert.AreEqual("Proyecto 1-Tipo de item de prueba 3", proyectosBD[0].TiposDeItem.ToList()[2].Descripcion);
        }
        public void ProyectosController_ModificarProyecto()
        {
            HelperTestSistema.LimpiarArchivoBD();
            HelperTestSistema.IniciarServidor();

            //Generamos los proyectos de ejemplo directamente sobre la base de datos
            Bugtracker bugtracker    = new Bugtracker();
            var        proyectosTest = HelperInstanciacionProyectos.GetProyectos(2);

            bugtracker.AgregarProyecto(proyectosTest[0]);
            bugtracker.AgregarProyecto(proyectosTest[1]);


            using (IContextoProceso contexto = new ContextoProceso(HelperTestSistema.ObjectFactory))
            {
                contexto.ContenedorObjetos.Store(bugtracker);
            }

            //Reiniciamos la conexion a la base de datos
            HelperTestSistema.ReiniciarConexion();

            var controller = new ProyectosController(HelperTestSistema.ObjectFactory);
            //obtenemos los proyectos y reiniciamos la conexion
            var listadoProyectosBD = controller.Get();

            HelperTestSistema.ReiniciarConexion();

            //obtenemos el primer proyecto y lo modificamos
            var proyectoBD = listadoProyectosBD.ToList()[0];

            proyectoBD.Descripcion = "Proyecto de prueba 1 modificado";

            //modificamos el proyecto en la BD a traves del controller y reiniciamos la conexion
            controller.Put(proyectoBD);
            HelperTestSistema.ReiniciarConexion();

            //limpiamos las variables para garantizar que las instancias quedan limpias
            listadoProyectosBD = null;

            //Obtenemos los proyectos nuevamentes
            listadoProyectosBD = controller.Get();
            var otroProyectoBD = listadoProyectosBD.ToList()[0];

            HelperTestSistema.FinalizarServidor();

            //Asserts

            //La cantidad de proyectos debe ser 2 (ya que solo se modifico un proyecto)
            Assert.AreEqual(2, listadoProyectosBD.ToList().Count);
            //El primer proyecto debe tener la descripcion modificada
            Assert.AreEqual("Proyecto de prueba 1 modificado", listadoProyectosBD.ToList()[0].Descripcion);
            Assert.AreEqual("Proyecto de prueba 2", listadoProyectosBD.ToList()[1].Descripcion);
        }
Esempio n. 17
0
        public void UsuariosController_NuevoUsuarioConPerfil()
        {
            HelperTestSistema.LimpiarArchivoBD();
            HelperTestSistema.IniciarServidor();

            //Generamos los perfiles de prueba en la base de datos
            var perfiles = HelperInstanciacionPerifles.GetPerfiles(2);

            using (IContextoProceso contexto = new ContextoProceso(HelperTestSistema.ObjectFactory))
            {
                contexto.ContenedorObjetos.Store(perfiles);
            }

            HelperTestSistema.ReiniciarConexion();

            //Obtenemos los perfiles del sistema
            var perfilesController = new PerfilesController(HelperTestSistema.ObjectFactory);
            var perfilesBD         = perfilesController.Get();

            HelperTestSistema.ReiniciarConexion();

            //Generamos un usuario nuevo y le asignamos el primer perfil
            var     controller = new UsuariosController(HelperTestSistema.ObjectFactory);
            Usuario usuarioDto = HelperInstanciacionUsuarios.GetUsuarios(1).ToList()[0];

            //usuarioDto.Perfil = perfilesBD.ToList()[0];
            controller.Post(usuarioDto);
            HelperTestSistema.ReiniciarConexion();

            //Obtenemos de la BD los datos a validar
            perfilesBD = null;
            perfilesBD = new List <Rol>();
            var usuariosBD = new List <Usuario>();

            using (IContextoProceso contexto = new ContextoProceso(HelperTestSistema.ObjectFactory))
            {
                perfilesBD = (from Rol p in contexto.ContenedorObjetos select p).ToList();
                usuariosBD = (from Usuario u in contexto.ContenedorObjetos select u).ToList();
            }
            HelperTestSistema.ReiniciarConexion();

            HelperTestSistema.FinalizarServidor();

            //Asserts
            Assert.Inconclusive("Refactorizar y terminar este test");
            //Tiene que haber un solo usuario en la base de datos
            Assert.AreEqual(1, usuariosBD.Count());
            //Tienen que haber solamente dos perfiles en la base de datos
            Assert.AreEqual(2, perfilesBD.Count());
            //El perfil asignado al usuario debe ser el perfil 1
            //Assert.AreEqual("Perfil 1", usuariosBD[0].Perfil.Nombre);
            //Assert.AreSame( perfilesBD.ToList()[0] , usuariosBD[0].Perfil );
        }
Esempio n. 18
0
        public void TiposItemController_ModificarTipoDeItemDeProyecto()
        {
            HelperTestSistema.LimpiarArchivoBD();
            HelperTestSistema.IniciarServidor();

            //Creamos 1 proyecto1 directamente en la BD con dos tipos de item
            var tiposDeItemProyecto1 = HelperInstanciacionItems.GetTiposDeItem("Proyecto 1", 3);
            var proyecto             = HelperInstanciacionProyectos.GetProyectos(1)[0];

            proyecto.AgregarTipoDeItem(tiposDeItemProyecto1[0]);
            proyecto.AgregarTipoDeItem(tiposDeItemProyecto1[1]);
            proyecto.AgregarTipoDeItem(tiposDeItemProyecto1[2]);

            //Guardamos los objetos en la BD
            using (IContextoProceso contexto = new ContextoProceso(HelperTestSistema.ObjectFactory))
            {
                contexto.ContenedorObjetos.Store(proyecto);
            }

            HelperTestSistema.ReiniciarConexion();

            //Obtenemos los tipos de item del proyecto directamente a traves de la API
            var controller = new TiposItemController(HelperTestSistema.ObjectFactory);
            var tiposItem  = controller.Get("P1");

            //Obtenemos el primer tipo de item y lo modificamos a traves de la API
            var tipoItem = tiposItem.ToList()[1];

            tipoItem.Descripcion = "Tipo de item 2 modificado";
            controller.Put("P1", tipoItem);
            HelperTestSistema.ReiniciarConexion();

            //Obtenemos los datos para validar directamente desde la base de datos
            var proyectosBD = new List <Proyecto>();

            using (IContextoProceso contexto = new ContextoProceso(HelperTestSistema.ObjectFactory))
            {
                proyectosBD = (from Proyecto p in contexto.ContenedorObjetos select p).ToList();
            }

            HelperTestSistema.ReiniciarConexion();
            HelperTestSistema.FinalizarServidor();

            //Asserts
            Assert.Inconclusive("Refactorizar y terminar este test");
            //Tiene que haber un solo proyecto en la BD
            Assert.AreEqual(1, proyectosBD.Count);
            //El proyecto debe tener 3 tipos de item
            Assert.AreEqual(3, proyectosBD[0].TiposDeItem.Count());
            //El tipo de item 2 debe tener la descripcion modificada
            Assert.AreEqual("Tipo de item 2 modificado", proyectosBD[0].TiposDeItem.ToList()[1].Descripcion);
        }
        public void PerfilesController_ModificarPerfil()
        {
            HelperTestSistema.LimpiarArchivoBD();
            HelperTestSistema.IniciarServidor();

            //Generamos dos perfiles de prueba
            var perfiles = HelperInstanciacionPerifles.GetPerfiles(2);

            //Guardamos los perfiles directamente en la base de datos
            using (IContextoProceso contexto = new ContextoProceso(HelperTestSistema.ObjectFactory))
            {
                foreach (Rol perfil in perfiles)
                {
                    contexto.ContenedorObjetos.Store(perfil);
                }
            }

            //Reiniciamos la conexion
            HelperTestSistema.ReiniciarConexion();

            //Obtenermos los perfiles desede el controller
            var controller = new PerfilesController(HelperTestSistema.ObjectFactory);
            var perfilesBD = controller.Get();

            HelperTestSistema.ReiniciarConexion();

            //Modificamos el primer perfil
            Rol perfilAModificar = perfilesBD.ToList()[0];

            perfilAModificar.Descripcion = "perfil de prueba 1 modificado";
            controller.Put(perfilAModificar);
            HelperTestSistema.ReiniciarConexion();

            //Obtenemos los perfiles de nuevo desde la base de datos
            perfilesBD = null;
            perfilesBD = controller.Get();
            HelperTestSistema.ReiniciarConexion();

            HelperTestSistema.FinalizarServidor();

            //Asserts
            Assert.Inconclusive("Refactorizar y terminar este test");
            //En la bd debe haber solamente dos perfiles
            Assert.AreEqual(2, perfilesBD.ToList().Count);
            //La instancia del perfil a modificar y el primer perfil de la BD deben ser diferentes
            Assert.AreNotSame(perfilAModificar, perfilesBD.ToList()[0]);
            //La descripcion del perfil de la BD se tiene que haber modificado correctamente
            Assert.AreEqual("perfil de prueba 1 modificado", perfilesBD.ToList()[0].Descripcion);
        }
Esempio n. 20
0
        public void UsuariosController_ModificarUsuario()
        {
            HelperTestSistema.LimpiarArchivoBD();
            HelperTestSistema.IniciarServidor();

            //Generamos dos usuarios de prueba directamente sobre la BD
            var usuarios = HelperInstanciacionUsuarios.GetUsuarios(2);

            using (IContextoProceso contexto = new ContextoProceso(HelperTestSistema.ObjectFactory))
            {
                contexto.ContenedorObjetos.Store(usuarios);
            }
            //Reseteamos la conexion a la BD
            HelperTestSistema.ReiniciarConexion();

            //Cargamos los usuarios registrados
            var controller            = new UsuariosController(HelperTestSistema.ObjectFactory);
            var usuariosPrimerRequest = controller.Get();

            HelperTestSistema.ReiniciarConexion();

            //MOdificamos el primer usuario
            var usuarioAModificar = usuariosPrimerRequest.ToList()[0];

            usuarioAModificar.Nombre = "usuario 1 modificado";
            controller.Put(usuarioAModificar);
            HelperTestSistema.ReiniciarConexion();

            //Cargamos nuevamente los usuarios registrados
            var usuariosSegundoRequest = controller.Get();

            HelperTestSistema.ReiniciarConexion();

            HelperTestSistema.FinalizarServidor();

            //Asserts
            Assert.Inconclusive("Refactorizar y terminar este test");
            //En la base de datos debe haber solo 2 usuarios
            Assert.AreNotSame(2, usuariosSegundoRequest.ToList().Count);
            //El nombre del usuario 1 se debe encontrar modificado
            Assert.AreEqual("usuario 1 modificado", usuariosSegundoRequest.ToList()[0].Nombre);
            //La instancia del usuario 1 debe ser distinta de la instancia del put
            Assert.AreNotSame(usuarioAModificar, usuariosSegundoRequest.ToList()[0]);
        }
Esempio n. 21
0
        public void ItemsController_ListarItems()
        {
            HelperTestSistema.LimpiarArchivoBD();
            HelperTestSistema.IniciarServidor();

            // Creamos en la BD 2 proyectos con 2 items cada uno
            var proyectos      = HelperInstanciacionProyectos.GetProyectos(2);
            var itemsProyecto1 = HelperInstanciacionItems.GetItems("Proyecto 1", 2);
            var itemsProyecto2 = HelperInstanciacionItems.GetItems("Proyecto 2", 2);

            proyectos[0].AgregarItem(itemsProyecto1[0]);
            proyectos[0].AgregarItem(itemsProyecto1[1]);

            proyectos[1].AgregarItem(itemsProyecto2[0]);
            proyectos[1].AgregarItem(itemsProyecto2[1]);

            using (IContextoProceso contexto = new ContextoProceso(HelperTestSistema.ObjectFactory))
            {
                contexto.ContenedorObjetos.Store(proyectos);
            }

            //Solicitamos al controller los items del proyecto
            var controller           = new ItemsController(HelperTestSistema.ObjectFactory);
            var itemsProyectoRequest = controller.Get("P1");

            HelperTestSistema.ReiniciarConexion();

            HelperTestSistema.ReiniciarConexion();
            HelperTestSistema.FinalizarServidor();

            //Asserts
            Assert.Inconclusive("Refactorizar y terminar este test");
            //En total el request debe devolver 2 items
            Assert.AreEqual(2, itemsProyectoRequest.Count());
            //Los nombres de los dos items deben ser los correctos
            Assert.AreEqual("Proyecto 1-Item de prueba 1", itemsProyectoRequest.ToList()[0].Descripcion);
            Assert.AreEqual("Proyecto 1-Item de prueba 2", itemsProyectoRequest.ToList()[1].Descripcion);
        }
        public void ProyectosController_NuevoProyecto()
        {
            HelperTestSistema.LimpiarArchivoBD();
            HelperTestSistema.IniciarServidor();

            //Obtenemos los proyectos de prueba
            var proyectoDto = HelperInstanciacionProyectos.GetProyectos(1)[0];

            // Hacemos post del proyecto
            var controller = new ProyectosController(HelperTestSistema.ObjectFactory);

            controller.Post(proyectoDto);

            //Reiniciamos la conexion para simular los postbacks
            HelperTestSistema.ReiniciarConexion();

            //Solicitamos los proyectos al controller
            var proyectos = controller.Get();

            //Obtenemos el listado de objetos bugtracker del sistema a ver si hay uno solo
            int cantidadBugtrackers = 0;

            using (IContextoProceso contexto = HelperTestSistema.ObjectFactory.Create <IContextoProceso>())
            {
                cantidadBugtrackers = (from Bugtracker b in contexto.ContenedorObjetos select b).Count();
            }


            HelperTestSistema.ReiniciarConexion();
            HelperTestSistema.FinalizarServidor();

            //Asserts
            //Deberia haber una unica instancia del bugtracker
            Assert.AreEqual(1, cantidadBugtrackers);
            //El nombre del proyecto deberia ser Proyecto 1
            Assert.AreEqual("Proyecto 1", proyectos.ToList()[0].Nombre);
        }
        public void ProyectosController_ListarProyectos()
        {
            HelperTestSistema.LimpiarArchivoBD();
            HelperTestSistema.IniciarServidor();

            //Obtenemos los proyectos de prueba
            Bugtracker bugtracker    = new Bugtracker();
            var        proyectosTest = HelperInstanciacionProyectos.GetProyectos(2);

            bugtracker.AgregarProyecto(proyectosTest[0]);
            bugtracker.AgregarProyecto(proyectosTest[1]);

            //Guardamos los proyectos de prueba directamente en la base de datos
            using (IContextoProceso contextoProceso = new ContextoProceso(HelperTestSistema.ObjectFactory))
            {
                contextoProceso.ContenedorObjetos.Store(bugtracker);
            }
            //Reiniciamos la conexion a la base de datos
            HelperTestSistema.ReiniciarConexion();

            //Traemos los proyectos registrados desde el controller
            var controller         = new ProyectosController(HelperTestSistema.ObjectFactory);
            var proyectosResultado = controller.Get();

            HelperTestSistema.FinalizarServidor();


            //Asserts
            //Assert.Inconclusive( "Refactorizar y terminar este test" );
            //La cantidad de proyectos registrados deben ser 2
            Assert.AreEqual(2, proyectosResultado.ToList().Count());
            //El primer proyecto se debe llamar proyecto 1
            Assert.AreEqual("Proyecto 1", proyectosResultado.ToList()[0].Nombre);
            //El segundo proyecto se debe llamar proyecto 2
            Assert.AreEqual("Proyecto 2", proyectosResultado.ToList()[1].Nombre);
        }
        public void PerfilesController_ModificarPerfilAsignadoAUsuario()
        {
            HelperTestSistema.LimpiarArchivoBD();
            HelperTestSistema.IniciarServidor();

            //Generamos dos perfiles  y un  usuario de prueba
            var perfiles = HelperInstanciacionPerifles.GetPerfiles(2);
            var usuario  = HelperInstanciacionUsuarios.GetUsuarios(1)[0];

            //Guardamos los perfiles y el usuario directamente en la base de datos
            using (IContextoProceso contexto = new ContextoProceso(HelperTestSistema.ObjectFactory))
            {
                foreach (Rol perfil in perfiles)
                {
                    contexto.ContenedorObjetos.Store(perfil);
                }
                //Asociamos el primer perfil al usuario
                //usuario.Perfil = perfiles[0];

                contexto.ContenedorObjetos.Store(usuario);
            }

            //Reiniciamos la conexion
            HelperTestSistema.ReiniciarConexion();

            //Obtenemos los perfiles desde el controller
            var controller = new PerfilesController(HelperTestSistema.ObjectFactory);
            var perfilesBD = controller.Get();

            HelperTestSistema.ReiniciarConexion();

            //Modificamos el primer perfil
            var perfilAModificar = perfilesBD.ToList()[0];

            perfilAModificar.Descripcion = "perfil de prueba 1 modificado";
            controller.Put(perfilAModificar);
            HelperTestSistema.ReiniciarConexion();

            //Obtenemos los datos directamente de la base de datos para verificarlos
            perfilesBD = null;
            var usuariosBD = new List <Usuario>();

            using (IContextoProceso contexto = new ContextoProceso(HelperTestSistema.ObjectFactory))
            {
                perfilesBD = (from Rol p in contexto.ContenedorObjetos select p).ToList();
                usuariosBD = (from Usuario u in contexto.ContenedorObjetos select u).ToList();
            }

            HelperTestSistema.ReiniciarConexion();

            HelperTestSistema.FinalizarServidor();

            //Asserts
            Assert.Inconclusive("Refactorizar y terminar este test");
            // La cantidad de perfiles en la BD debe seguir siendo la misma (solo 2 )
            Assert.AreEqual(2, perfiles.Count);
            //Se tiene que haber modificado el nombre en el perfil asociado al usuario
            //Assert.AreEqual( "perfil de prueba 1 modificado", usuariosBD[0].Perfil.Descripcion );
            //El perfil se tiene que haber modificado correctamente
            Assert.AreEqual("perfil de prueba 1 modificado", perfilesBD.ToList()[0].Descripcion);
            //La instancia del perfil asociado al usuario y el primer perfil deben ser  la misma
            //Assert.AreSame(perfilesBD.ToList()[0], usuariosBD[0].Perfil );
        }
Esempio n. 25
0
        public void TiposItemController_ModificarTipoDeItemDeProyecto_ConReferencias()
        {
            HelperTestSistema.LimpiarArchivoBD();
            HelperTestSistema.IniciarServidor();

            //Creamos 1 proyecto1 directamente en la BD con dos tipos de item
            var tiposDeItemProyecto1 = HelperInstanciacionItems.GetTiposDeItem("Proyecto 1", 3);
            var proyecto             = HelperInstanciacionProyectos.GetProyectos(1)[0];

            proyecto.AgregarTipoDeItem(tiposDeItemProyecto1[0]);
            proyecto.AgregarTipoDeItem(tiposDeItemProyecto1[1]);
            proyecto.AgregarTipoDeItem(tiposDeItemProyecto1[2]);

            //Cregamos un item y le asignamos el tipo de item 2
            var item = new Item("Item 1", "Item de prueba 1", tiposDeItemProyecto1[1], new Prioridad("Baja", "Test"));

            proyecto.AgregarItem(item);

            //Guardamos los objetos en la BD
            using (IContextoProceso contexto = new ContextoProceso(HelperTestSistema.ObjectFactory))
            {
                contexto.ContenedorObjetos.Store(proyecto);
            }

            HelperTestSistema.ReiniciarConexion();

            //Obtenemos los tipos de item del proyecto desde el controller
            var controller = new TiposItemController(HelperTestSistema.ObjectFactory);
            var tiposItem  = controller.Get("P1");

            var tipoItemAModificar = tiposItem.ToList()[1];

            tipoItemAModificar.Descripcion = "Tipo de item 2 modificado";

            controller.Put("P1", tipoItemAModificar);
            HelperTestSistema.ReiniciarConexion();

            //Obtenemos los datos directamente desde la BD para validarlos
            //Obtenemos los datos para validar directamente desde la base de datos
            var proyectosBD = new List <Proyecto>();

            using (IContextoProceso contexto = new ContextoProceso(HelperTestSistema.ObjectFactory))
            {
                proyectosBD = (from Proyecto p in contexto.ContenedorObjetos select p).ToList();
            }


            HelperTestSistema.ReiniciarConexion();
            HelperTestSistema.FinalizarServidor();

            //Asserts
            Assert.Inconclusive("Refactorizar y terminar este test");
            //Tiene que haber un solo proyecto
            Assert.AreEqual(1, proyectosBD.Count);
            //El proyeto debe tener 3 tipos de item
            Assert.AreEqual(3, proyectosBD[0].TiposDeItem.Count());
            //El tipo de item 2 debe estar modificado
            Assert.AreEqual("Tipo de item 2 modificado", proyectosBD[0].TiposDeItem.ToList()[1].Descripcion);
            //El proyecto debe tener 1 item
            Assert.AreEqual(1, proyectosBD[0].Items.Count());
            //La instanacia del tipo de item 2 debe ser la misma asociada al item del proyecto
            Assert.AreSame(proyectosBD[0].TiposDeItem.ToList()[1], proyectosBD[0].Items.ToList()[0].TipoItem);
        }