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_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] );
        }
        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 );
        }
        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);
        }
        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 );
        }
        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 );
        }
        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 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 );
        }
        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 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 );
        }
        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 );
        }
        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 );
        }
        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] );
        }
        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 );
        }
        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 );
        }
        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 );
        }