Mercurial > altnet-hispano

view Agendas/trunk/src/Agendas.Web.Tests/Controllers/PersonaControllerTests.cs @ 272:33e6ee3d1776

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Ticket #181: No twittear eventos pasados. Tests armado, y su corrección. Corrección de otros tests que intentaban twittear con fechas fijas.
author juanjose.montesdeocaarbos
date Fri, 18 Nov 2011 23:09:58 -0300
parents 3bb779434ae8
children
line wrap: on
line source

using System.Linq;
using System.Web.Mvc;
using Agendas.NHibernate;
using Agendas.Repositories.Tests.Infraestructure;
using AltNetHispano.Agendas.Domain;
using AltNetHispano.Agendas.Repositories.NHibernate;
using AltNetHispano.Agendas.Web.Controllers;
using AltNetHispano.Agendas.Web.Models;
using Moq;
using NUnit.Framework;

namespace Agendas.Web.Tests.Controllers
{
    [TestFixture]
    public class PersonaControllerTests : MvcControllerTestsBase
    {
        private void SetearUsuario()
        {
            var seguridad = new Mock<ISeguridad>();
            seguridad.Setup(s => s.GetUserName()).Returns("neluz");
            IdentityContext.Init(seguridad.Object, new PersonaRepository(NhHelper.GetSessionFactory()));
        }

        private void PersonaNueva(ref PersonaController controller)
        {
            var personaNew = new PersonaNewModel
            {
                Blog = "http://juanjose.montesdeocaarbos.com.ar/blog/",
                EMail = "juanjose.montesdeocaarbos@gmail.com",
                Nombre = "Juan José Montes de Oca Arbós",
                Roles = new string[] { "Administrador", "Usuario" },
                Twitter = "jjmoa"
            };

            using (new RequestEmulator(NhHelper.GetSessionFactory()))
            {
                controller.Nueva(personaNew);
                controller = new PersonaController { ControllerContext = ControllerCtx };
            }
            
            personaNew = new PersonaNewModel
            {
                Blog = "http://nelopauselli.blogspot.com/",
                EMail = "nelo@gmail.com",
                Nombre = "Nelo Mariano Pauselli",
                Roles = new string[] { "Administrador", "Usuario" },
                Twitter = "npauselli"
            };

            using (new RequestEmulator(NhHelper.GetSessionFactory()))
            {
                controller.Nueva(personaNew);
                controller = new PersonaController { ControllerContext = ControllerCtx };
            }
        }

        [SetUp]
        public void Setup()
        {
            NhHelperTest.CleanDb();
            SetearUsuario();
            ControllerCtx = new ControllerContext();
        }

        [Test]
        public void PersonaNuevaGET()
        {
            var personaController = new PersonaController { ControllerContext = ControllerCtx };
            using (new RequestEmulator(NhHelper.GetSessionFactory()))
            {
                var resultNuevo = personaController.Nueva();
                Assert.IsInstanceOf(typeof(ViewResult), resultNuevo);
                Assert.AreEqual("Defaulteditor", ((ViewResult)resultNuevo).ViewName);
            }
        }

        [Test]
        public void PersonaModificarGET()
        {
            var personaController = new PersonaController { ControllerContext = ControllerCtx };
            PersonaNueva(ref personaController);

            using (new RequestEmulator(NhHelper.GetSessionFactory()))
            {
                var personaRepository = new PersonaRepository(NhHelper.GetSessionFactory());

                var resultModificar = personaController.Modificar(personaRepository.GetAll().FirstOrDefault().Id.ToString());
                Assert.IsInstanceOf(typeof(ViewResult), resultModificar);
                Assert.AreEqual("Defaulteditor", ((ViewResult)resultModificar).ViewName);
            }
        }

        [Test]
        public void PersonaModificarGET_PersonaInexistente()
        {
            var personaController = new PersonaController { ControllerContext = ControllerCtx };

            using (new RequestEmulator(NhHelper.GetSessionFactory()))
            {
                var resultModificar = personaController.Modificar("11111111-1111-1111-1111-111111111111");
                Assert.IsInstanceOf(typeof(RedirectToRouteResult), resultModificar);
                Assert.AreEqual("Index", ((RedirectToRouteResult)resultModificar).RouteValues["action"]);
                Assert.AreEqual("No se encontró la persona que intenta modificar", personaController.TempData["error"]);
            }
        }

        [Test]
        public void PersonaNuevaPOST_RequiredFields()
        {
            var personaController = new PersonaController { ControllerContext = ControllerCtx };

            var form = new FormCollection
                           {
                               {"Blog", ""},
                               {"EMail", ""},
                               {"Nombre", ""},
                               {"Roles", "Administrador"},
                               {"Roles", "Usuario"},
                               {"Twitter", ""}
                           };
            var personaNew = BindModel<PersonaNewModel>(personaController, form);

            using (new RequestEmulator(NhHelper.GetSessionFactory()))
            {
                var resultNuevo = personaController.Nueva(personaNew);
                Assert.IsInstanceOf(typeof(ViewResult), resultNuevo);
                var viewResultNuevo = (ViewResult) resultNuevo;
                Assert.AreEqual("Defaulteditor", viewResultNuevo.ViewName);
                Assert.AreEqual(1, viewResultNuevo.ViewData.ModelState["EMail"].Errors.Count);
                Assert.AreEqual("El campo EMail es obligatorio.", viewResultNuevo.ViewData.ModelState["EMail"].Errors[0].ErrorMessage);
                Assert.AreEqual(1, viewResultNuevo.ViewData.ModelState["Nombre"].Errors.Count);
                Assert.AreEqual("El campo Nombre es obligatorio.", viewResultNuevo.ViewData.ModelState["Nombre"].Errors[0].ErrorMessage);
                Assert.AreEqual(1, viewResultNuevo.ViewData.ModelState["Twitter"].Errors.Count);
                Assert.AreEqual("El campo Twitter es obligatorio.", viewResultNuevo.ViewData.ModelState["Twitter"].Errors[0].ErrorMessage);
            }
        }

        [Test]
        public void PersonaNuevaPOST_FormatFields()
        {
            var personaController = new PersonaController { ControllerContext = ControllerCtx };

            var form = new FormCollection
                           {
                               {"Blog", "montesdeocaarbos.com.ar/blog/"},
                               {"EMail", "juanjose.montesdeocaarbos gmail.com"},
                               {"Nombre", "Juan José Montes de Oca Arbós"},
                               {"Roles", "Administrador"},
                               {"Roles", "Usuario"},
                               {"Twitter", "@jjmoa"}
                           };
            var personaNew = BindModel<PersonaNewModel>(personaController, form);

            using (new RequestEmulator(NhHelper.GetSessionFactory()))
            {
                var resultNuevo = personaController.Nueva(personaNew);
                Assert.IsInstanceOf(typeof(ViewResult), resultNuevo);
                var viewResultNuevo = (ViewResult)resultNuevo;
                Assert.AreEqual("Defaulteditor", viewResultNuevo.ViewName);
                Assert.AreEqual(1, viewResultNuevo.ViewData.ModelState["Twitter"].Errors.Count);
                Assert.AreEqual("No debe ingresar el arroba al escribir la cuenta de twitter.", viewResultNuevo.ViewData.ModelState["Twitter"].Errors[0].ErrorMessage);
                Assert.AreEqual(1, viewResultNuevo.ViewData.ModelState["Blog"].Errors.Count);
                Assert.AreEqual("The Blog field is not a valid fully-qualified http, https, or ftp URL.", viewResultNuevo.ViewData.ModelState["Blog"].Errors[0].ErrorMessage);
                Assert.AreEqual(1, viewResultNuevo.ViewData.ModelState["EMail"].Errors.Count);
                Assert.AreEqual("The EMail field is not a valid e-mail address.", viewResultNuevo.ViewData.ModelState["EMail"].Errors[0].ErrorMessage);
            }
        }

        [Test]
        public void PersonaNuevaPOST_PersonaExistente()
        {
            var personaController = new PersonaController { ControllerContext = ControllerCtx };
            PersonaNueva(ref personaController);

            var form = new FormCollection
                           {
                               {"Blog", "http://montesdeocaarbos.com.ar/blog/"},
                               {"EMail", "juanjose.montesdeocaarbos@gmail.com"},
                               {"Nombre", "Juan José Montes de Oca Arbós"},
                               {"Roles", "Administrador"},
                               {"Roles", "Usuario"},
                               {"Twitter", "jjmoa"}
                           };
            var personaNew = BindModel<PersonaNewModel>(personaController, form);

            using (new RequestEmulator(NhHelper.GetSessionFactory()))
            {
                var resultNuevo = personaController.Nueva(personaNew);
                Assert.IsInstanceOf(typeof(ViewResult), resultNuevo);
                var viewResultNuevo = (ViewResult)resultNuevo;
                Assert.AreEqual("Defaulteditor", viewResultNuevo.ViewName);
                Assert.AreEqual("Ya existe una persona con el nombre " + personaNew.Nombre, personaController.TempData["error"]);
            }
        }

        [Test]
        public void PersonaModificarPOST_RequiredFields()
        {
            var personaController = new PersonaController { ControllerContext = ControllerCtx };
            PersonaNueva(ref personaController);

            PersonaEditModel personaEdit = null;
            using (new RequestEmulator(NhHelper.GetSessionFactory()))
            {
                var form = new FormCollection
                               {
                                   {"Id", ""},
                                   {"Blog", ""},
                                   {"EMail", ""},
                                   {"Nombre", ""},
                                   {"Roles", "Administrador"},
                                   {"Roles", "Usuario"},
                                   {"Twitter", ""}
                               };
                personaEdit = BindModel<PersonaEditModel>(personaController, form);
            }

            using (new RequestEmulator(NhHelper.GetSessionFactory()))
            {
                var resultNuevo = personaController.Modificar(personaEdit);
                Assert.IsInstanceOf(typeof(ViewResult), resultNuevo);
                var viewResultNuevo = (ViewResult)resultNuevo;
                Assert.AreEqual("Defaulteditor", viewResultNuevo.ViewName);
                Assert.AreEqual(1, viewResultNuevo.ViewData.ModelState["Id"].Errors.Count);
                Assert.AreEqual("El campo Id es obligatorio.", viewResultNuevo.ViewData.ModelState["Id"].Errors[0].ErrorMessage);
                Assert.AreEqual(1, viewResultNuevo.ViewData.ModelState["EMail"].Errors.Count);
                Assert.AreEqual("El campo EMail es obligatorio.", viewResultNuevo.ViewData.ModelState["EMail"].Errors[0].ErrorMessage);
                Assert.AreEqual(1, viewResultNuevo.ViewData.ModelState["Nombre"].Errors.Count);
                Assert.AreEqual("El campo Nombre es obligatorio.", viewResultNuevo.ViewData.ModelState["Nombre"].Errors[0].ErrorMessage);
                Assert.AreEqual(1, viewResultNuevo.ViewData.ModelState["Twitter"].Errors.Count);
                Assert.AreEqual("El campo Twitter es obligatorio.", viewResultNuevo.ViewData.ModelState["Twitter"].Errors[0].ErrorMessage);
            }
        }

        [Test]
        public void PersonaModificarPOST_FormatFields()
        {
            var personaController = new PersonaController { ControllerContext = ControllerCtx };
            PersonaNueva(ref personaController);

            PersonaEditModel personaEdit = null;
            using (new RequestEmulator(NhHelper.GetSessionFactory()))
            {
                var personaRepository = new PersonaRepository(NhHelper.GetSessionFactory());

                var form = new FormCollection
                               {
                                   {"Id", personaRepository.GetAll().FirstOrDefault().Id.ToString()},
                                   {"Blog", "montesdeocaarbos.com.ar/blog/"},
                                   {"EMail", "juanjose.montesdeocaarbos gmail.com"},
                                   {"Nombre", "Juan José Montes de Oca Arbós"},
                                   {"Roles", "Administrador"},
                                   {"Roles", "Usuario"},
                                   {"Twitter", "@jjmoa"}
                               };
                personaEdit = BindModel<PersonaEditModel>(personaController, form);
            }

            using (new RequestEmulator(NhHelper.GetSessionFactory()))
            {
                var resultModificar = personaController.Modificar(personaEdit);
                Assert.IsInstanceOf(typeof(ViewResult), resultModificar);
                var viewResultModificar = (ViewResult)resultModificar;
                Assert.AreEqual("Defaulteditor", viewResultModificar.ViewName);
                Assert.AreEqual(1, viewResultModificar.ViewData.ModelState["Twitter"].Errors.Count);
                Assert.AreEqual("No debe ingresar el arroba al escribir la cuenta de twitter.", viewResultModificar.ViewData.ModelState["Twitter"].Errors[0].ErrorMessage);
                Assert.AreEqual(1, viewResultModificar.ViewData.ModelState["Blog"].Errors.Count);
                Assert.AreEqual("The Blog field is not a valid fully-qualified http, https, or ftp URL.", viewResultModificar.ViewData.ModelState["Blog"].Errors[0].ErrorMessage);
                Assert.AreEqual(1, viewResultModificar.ViewData.ModelState["EMail"].Errors.Count);
                Assert.AreEqual("The EMail field is not a valid e-mail address.", viewResultModificar.ViewData.ModelState["EMail"].Errors[0].ErrorMessage);
            }
        }

        [Test]
        public void PersonaModificarPOST_PersonaExistente()
        {
            var personaController = new PersonaController { ControllerContext = ControllerCtx };
            PersonaNueva(ref personaController);

            PersonaEditModel personaEdit = null;
            using (new RequestEmulator(NhHelper.GetSessionFactory()))
            {
                var personaRepository = new PersonaRepository(NhHelper.GetSessionFactory());

                var form = new FormCollection
                               {
                                   {"Id", personaRepository.GetAll().FirstOrDefault().Id.ToString()},
                                   {"Blog", "http://nelopauselli.blogspot.com/"},
                                   {"EMail", "nelo@gmail.com"},
                                   {"Nombre", "Nelo Mariano Pauselli"},
                                   {"Roles", "Administrador"},
                                   {"Roles", "Usuario"},
                                   {"Twitter", "npauselli"}
                               };
                personaEdit = BindModel<PersonaEditModel>(personaController, form);
            }

            using (new RequestEmulator(NhHelper.GetSessionFactory()))
            {
                var resultEdit = personaController.Modificar(personaEdit);
                Assert.IsInstanceOf(typeof(ViewResult), resultEdit);
                var viewResultNuevo = (ViewResult)resultEdit;
                Assert.AreEqual("Defaulteditor", viewResultNuevo.ViewName);
                Assert.AreEqual("Ya existe una persona con el twitter " + personaEdit.Twitter, personaController.TempData["error"]);
            }
        }

        [Test]
        public void PersonaModificarPOST_Successful()
        {
            var personaController = new PersonaController { ControllerContext = ControllerCtx };
            PersonaNueva(ref personaController);

            PersonaEditModel personaEdit = null;
            using (new RequestEmulator(NhHelper.GetSessionFactory()))
            {
                var personaRepository = new PersonaRepository(NhHelper.GetSessionFactory());

                var form = new FormCollection
                               {
                                   {"Id", personaRepository.GetAll().FirstOrDefault().Id.ToString()},
                                   {"Blog", "http://montesdeocaarbos.com.ar/blog/"},
                                   {"EMail", "juanjose.montesdeocaarbos@gmail.com"},
                                   {"Nombre", "Juan José Montes de Oca Arbós"},
                                   {"Roles", "Administrador"},
                                   {"Roles", "Usuario"},
                                   {"Twitter", "jjmoa"}
                               };
                personaEdit = BindModel<PersonaEditModel>(personaController, form);
            }

            using (new RequestEmulator(NhHelper.GetSessionFactory()))
            {
                var resultModificar = personaController.Modificar(personaEdit);
                Assert.IsInstanceOf(typeof(RedirectToRouteResult), resultModificar);
                Assert.AreEqual("Index", ((RedirectToRouteResult)resultModificar).RouteValues["action"]);
            }
        }

        [Test]
        public void PersonaQuitarGET()
        {
            var personaController = new PersonaController { ControllerContext = ControllerCtx };
            PersonaNueva(ref personaController);

            using (new RequestEmulator(NhHelper.GetSessionFactory()))
            {
                var personaRepository = new PersonaRepository(NhHelper.GetSessionFactory());

                var resultQuitar = personaController.Quitar(personaRepository.GetAll().FirstOrDefault().Id.ToString());

                Assert.IsInstanceOf(typeof(RedirectToRouteResult), resultQuitar);
                var redirectResultQuitar = (RedirectToRouteResult)resultQuitar;
                Assert.AreEqual("Index", redirectResultQuitar.RouteValues["action"]);
                Assert.AreEqual(1, personaController.TempData.Count);
                Assert.AreEqual("Se ha eliminado correctamente a la persona", personaController.TempData["notification"]);
                Assert.IsNull(personaController.TempData["warning"]);
                Assert.IsNull(personaController.TempData["error"]);
            }
        }

        [Test]
        public void PersonaQuitarGET_PersonaInexistente()
        {
            var personaController = new PersonaController { ControllerContext = ControllerCtx };

            using (new RequestEmulator(NhHelper.GetSessionFactory()))
            {
                const string personaId = "11111111-1111-1111-1111-111111111111";
                var resultVer = personaController.Quitar(personaId);
                Assert.IsInstanceOf(typeof(RedirectToRouteResult), resultVer);
                Assert.AreEqual("Index", ((RedirectToRouteResult)resultVer).RouteValues["action"]);
                Assert.AreEqual(string.Format("No se pudo encontrar la persona cuyo Id sea {0}", personaId), personaController.TempData["error"]);
            }
        }

        [Test]
        public void PersonaVerGET()
        {
            var personaController = new PersonaController { ControllerContext = ControllerCtx };
            PersonaNueva(ref personaController);

            using (new RequestEmulator(NhHelper.GetSessionFactory()))
            {
                var personaRepository = new PersonaRepository(NhHelper.GetSessionFactory());

                var resultModificar = personaController.Ver(personaRepository.GetAll().FirstOrDefault().Id.ToString());
                Assert.IsInstanceOf(typeof(ViewResult), resultModificar);
                Assert.AreEqual("DefaultViewer", ((ViewResult)resultModificar).ViewName);
            }
        }

        [Test]
        public void PersonaVerGET_PersonaInexistente()
        {
            var personaController = new PersonaController { ControllerContext = ControllerCtx };

            using (new RequestEmulator(NhHelper.GetSessionFactory()))
            {
                var resultVer = personaController.Ver("11111111-1111-1111-1111-111111111111");
                Assert.IsInstanceOf(typeof(RedirectToRouteResult), resultVer);
                Assert.AreEqual("Index", ((RedirectToRouteResult)resultVer).RouteValues["action"]);
                Assert.AreEqual("No se encontró la persona que intenta visualizar", personaController.TempData["error"]);
            }
        }
    }
}