Mercurial > altnet-hispano

view Agendas/trunk/src/Agendas.Tests/AgendarTests.cs @ 106:80c22175c9b5

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
agregado de tipo de evento (van, cafe, grupoestudio) agregado de tipo de evento en el alta de evento y en el alta de propuestas desde la app web algunas correcciones en el publicador del blog agregado de textos para publicar en el blog eventos de tipo alt.net cafe
author jorge.rowies
date Mon, 06 Jun 2011 14:07:12 -0300
parents 1d820f17fc75
children b74734a1a755
line wrap: on
line source

using System;
using System.Collections.Generic;
using System.Linq;
using AltNetHispano.Agendas.Domain;
using AltNetHispano.Agendas.Domain.Exceptions;
using AltNetHispano.Agendas.Domain.Repositories;
using AltNetHispano.Agendas.Repositories.Memory;
using Moq;
using NUnit.Framework;

namespace AltNetHispano.Agendas.Tests
{
	[TestFixture]
	public class AgendarTests : TestBase
	{
		private const string urlInvitacion = "http://groups.google.com/group/altnet-hispano/browse_thread/thread/65d6d26eb381386e";

		[Test]
		public void CompositePublicador_constructor_parametro_null_debe_generar_ArgumentNullException()
		{
			Assert.Throws<ArgumentNullException>(() => new CompositePublicador(null));
		}

		[Test]
		public void Intentar_agendar_evento_donde_ocurre_una_excepcion_no_manejada()
		{
			var publicador = new Mock<IPublicador>();
			var repository = new Mock<IEventoRepository>();

			publicador.Setup(p => p.Publicar(It.IsAny<IEnumerable<Track>>())).Throws(new Exception("Error intencional"));

			var agenda = new Agenda(publicador.Object, repository.Object, DefaultPersonaRepository);

      Assert.Throws<Exception>(() => agenda.Agendar("Van para publicar", "jjmontes", DateTime.Now, urlInvitacion, TipoEvento.Van));
			Assert.AreEqual(0, agenda.GetEventosAgendados().Count);

			publicador.Verify(p => p.Publicar(It.IsAny<IEnumerable<Track>>()), Times.Exactly(1));
			repository.Verify(p => p.Save(It.IsAny<Evento>()), Times.Exactly(0));
		}

		[Test]
		public void Intentar_agendar_evento_sin_servicio_de_seguridad()
		{
			IdentityContext.Init(null, new PersonaRepository());

			var publicador = new Mock<IPublicador>();
			var repository = new Mock<IEventoRepository>();

			var agenda = new Agenda(publicador.Object, repository.Object, DefaultPersonaRepository);

			Assert.Throws<IdentityContextNotConfiguredException>(
				() => agenda.Agendar("Van para publicar", "jjmontes", DateTime.Now,
          urlInvitacion, TipoEvento.Van));
			repository.Verify(p => p.Save(It.IsAny<Evento>()), Times.Exactly(0));
		}

		[Test]
		public void Intentar_agendar_evento_sin_usuario_autenticado()
		{
			SetCurrentUser(null, null);

			var publicador = new Mock<IPublicador>();
			var repository = new Mock<IEventoRepository>();

			var agenda = new Agenda(publicador.Object, repository.Object, DefaultPersonaRepository);

			Assert.Throws<UsuarioNoAutenticadoException>(() => agenda.Agendar("Van para publicar", "jjmontes", DateTime.Now,
        urlInvitacion, TipoEvento.Van));

			publicador.Verify(p => p.Publicar(It.IsAny<IEnumerable<Track>>()), Times.Exactly(0));
			repository.Verify(p => p.Save(It.IsAny<Evento>()), Times.Exactly(0));
		}

		[Test]
		public void Intentar_agendar_evento_sin_ponente()
		{
			var agenda = new Agenda(null, DefaultEventoRepository, DefaultPersonaRepository);

			var r = agenda.Agendar("Van para publicar", string.Empty, DateTime.Now,
        urlInvitacion, TipoEvento.Van);

			Assert.IsFalse(r.Succeful);
		}

		[Test]
		public void Agendar_evento_con_multiples_publicadores()
		{
			var publicador1 = new Mock<IPublicador>();
			var publicador2 = new Mock<IPublicador>();

			var repository = new Mock<IEventoRepository>();

			var agenda = new Agenda(new CompositePublicador(new[] {publicador1.Object, publicador2.Object}),
															repository.Object, DefaultPersonaRepository);

			agenda.Agendar("Van para publicar", "jjmontes", DateTime.Now,
        urlInvitacion, TipoEvento.Van);

			publicador1.Verify(p => p.Publicar(It.IsAny<IEnumerable<Track>>()), Times.Exactly(1));
			publicador2.Verify(p => p.Publicar(It.IsAny<IEnumerable<Track>>()), Times.Exactly(1));
			repository.Verify(p => p.Save(It.IsAny<Evento>()), Times.Exactly(1));
		}

		[Test]
		public void Agendar_evento_correctamente()
		{
			var publicador = new Mock<IPublicador>();

			var agenda = new Agenda(publicador.Object, DefaultEventoRepository, DefaultPersonaRepository);

			agenda.Agendar("Van para publicar", "jjmontes", DateTime.Now,
        urlInvitacion, TipoEvento.Van);

			Assert.AreEqual(0, agenda.GetEventosPropuestos().Count);

			var eventos = agenda.GetEventosAgendados();
			Assert.AreEqual(1, eventos.Count);

			publicador.Verify(p => p.Publicar(It.IsAny<IEnumerable<Track>>()), Times.Exactly(1));

			var evento = eventos[0];
			
			Assert.IsNotNull(evento.Ponente);
		}

		[Test]
		public void Agendar_y_modificar_evento()
		{
			var repository = DefaultEventoRepository;
			var publicador = new Mock<IPublicador>();

			var agenda = new Agenda(publicador.Object, repository, DefaultPersonaRepository);

			agenda.Agendar("Van para publicar", "jjmontes", DateTime.Now,
        urlInvitacion, TipoEvento.Van);

			publicador.Verify(p => p.Publicar(It.IsAny<IEnumerable<Track>>()), Times.Exactly(1));

			var evento = repository.GetEventosConFecha().First();
			Assert.AreNotEqual(Guid.Empty, evento.Id);
			Assert.IsNotNull(evento.Fecha);

			DateTime fecha = evento.Fecha.Value.AddDays(7);
			agenda.ModificarEvento(evento.Id, "otro titulo", "otro ponente", fecha, urlInvitacion);

			publicador.Verify(p => p.Publicar(It.IsAny<IEnumerable<Track>>()), Times.Exactly(2));

			evento = repository.GetEventosConFecha().First();
			Assert.AreEqual("otro titulo", evento.Titulo);
			Assert.AreEqual("otro ponente", evento.Ponente.Nombre);
			Assert.AreEqual(fecha, evento.Fecha);

			var idEventoNoExistente = new Guid("99999999999999999999999999999999");
			Assert.Throws<EventoNotFoundException>(
				() => agenda.ModificarEvento(idEventoNoExistente, "algún título", "un ponente", DateTime.Now, urlInvitacion));
		}

		[Test, Ignore("Por ahora no existe el concepto de recordar")]
		public void Agendar_y_recordar_evento()
		{
			var publicador1 = new Mock<IPublicador>();
			var publicador2 = new Mock<IPublicador>();

			var agenda = new Agenda(new CompositePublicador(new[] {publicador1.Object, publicador2.Object}),
															DefaultEventoRepository, DefaultPersonaRepository);

			agenda.Agendar("Van para publicar", "jjmontes", DateTime.Now,
        urlInvitacion, TipoEvento.Van);

			var van = agenda.GetEventosAgendados().Single(v => v.Titulo == "Van para publicar");
			//agenda.Recordar(van.Id);

			publicador1.Verify(p => p.Publicar(It.IsAny<IEnumerable<Track>>()), Times.Exactly(1));
			publicador2.Verify(p => p.Publicar(It.IsAny<IEnumerable<Track>>()), Times.Exactly(1));
			//recordador1.Verify(r => r.Recordar(It.IsAny<Evento>()), Times.Exactly(1));
		}

		[Test]
		public void Agendar_evento_propuesto()
		{
			var publicador1 = new Mock<IPublicador>();
			var publicador2 = new Mock<IPublicador>();

			var agenda = new Agenda(new CompositePublicador(new[] { publicador1.Object, publicador2.Object }),
															DefaultEventoRepository, DefaultPersonaRepository);

      agenda.Proponer("Html 5", "jjmontes", urlInvitacion, TipoEvento.Van);
			Assert.AreEqual(1, agenda.GetEventosPropuestos().Count);
			Assert.AreEqual(0, agenda.GetEventosAgendados().Count);

			var publicado = agenda.GetEventosPropuestos().First();
			Assert.AreEqual(1, publicado.Tracks.Count());

			agenda.ModificarEvento(publicado.Id, "Html 5", "jjmontes", DateTime.Today.AddDays(5), urlInvitacion);
			Assert.AreEqual(0, agenda.GetEventosPropuestos().Count);
			Assert.AreEqual(1, agenda.GetEventosAgendados().Count);

			var agendado = agenda.GetEventosAgendados().First();
			Assert.AreSame(publicado, agendado);
			Assert.AreEqual(2, agendado.Tracks.Count());

			Assert.IsNotNull(agendado.Tracks.Where(t => t.Accion == Accion.Proponer).SingleOrDefault());
			Assert.IsNotNull(agendado.Tracks.Where(t => t.Accion == Accion.Agendar).SingleOrDefault());
		}

    [Test]
    public void Al_proponer_un_evento_debe_quedar_con_estado_EventoPropuestoState_y_debe_generar_el_track_correspondiente()
    {
 			var publicador1 = new Mock<IPublicador>();

      var agenda = new Agenda(publicador1.Object, DefaultEventoRepository, DefaultPersonaRepository);
      agenda.Proponer("Html 5", "jjmontes", urlInvitacion, TipoEvento.Van);

      var evento = DefaultEventoRepository.GetEventosSinFecha().Single(e => e.Titulo == "Html 5");

      Assert.IsInstanceOf(typeof(EventoPropuestoState), evento.GetEstado());
      Assert.That(evento.GetTrackNews().Count(t => t.Accion == Accion.Proponer) == 1);
    }

    [Test]
    public void Al_agendar_un_evento_debe_quedar_con_estado_EventoAgendadoState_y_debe_generar_el_track_correspondiente()
    {
 			var publicador1 = new Mock<IPublicador>();

      var agenda = new Agenda(publicador1.Object, DefaultEventoRepository, DefaultPersonaRepository);
      agenda.Agendar("Html 5", "jjmontes", DateTime.MinValue, urlInvitacion, TipoEvento.Van);

      var evento = DefaultEventoRepository.GetEventosConFecha().Single(e => e.Titulo == "Html 5");

      Assert.IsInstanceOf(typeof(EventoAgendadoState), evento.GetEstado());
      Assert.That(evento.GetTrackNews().Count(t => t.Accion == Accion.Agendar) == 1);
    }

    [Test]
    public void Al_confirmar_un_evento_debe_quedar_con_estado_EventoConfirmadoState_y_debe_generar_el_track_correspondiente()
    {
 			var publicador1 = new Mock<IPublicador>();

      var agenda = new Agenda(publicador1.Object, DefaultEventoRepository, DefaultPersonaRepository);
      agenda.Agendar("Html 5", "jjmontes", DateTime.MinValue, urlInvitacion, TipoEvento.Van);

      var evento = DefaultEventoRepository.GetEventosConFecha().Single(e => e.Titulo == "Html 5");

      agenda.Confirmar(evento.Id);

      Assert.IsInstanceOf(typeof(EventoConfirmadoState), evento.GetEstado());
      Assert.That(evento.GetTrackNews().Count(t => t.Accion == Accion.Confirmar) == 1);
    }

    [Test]
    public void Al_publicar_un_evento_debe_quedar_con_estado_EventoPublicadoState_y_debe_generar_el_track_correspondiente()
    {
 			var publicador1 = new Mock<IPublicador>();

      var agenda = new Agenda(publicador1.Object, DefaultEventoRepository, DefaultPersonaRepository);
      agenda.Agendar("Html 5", "jjmontes", DateTime.MinValue, urlInvitacion, TipoEvento.Van);

      var evento = DefaultEventoRepository.GetEventosConFecha().Single(e => e.Titulo == "Html 5");

      agenda.Confirmar(evento.Id);
      agenda.Publicar(evento.Id, 0, string.Empty);

      Assert.IsInstanceOf(typeof(EventoPublicadoState), evento.GetEstado());
      Assert.That(evento.GetTrackNews().Count(t => t.Accion == Accion.Publicar) == 1);
    }

    [Test]
    public void Al_publicar_un_evento_debe_asignarse_el_nro_de_reunion_y_la_url_de_la_wiki()
    {
      var publicador1 = new Mock<IPublicador>();

      var agenda = new Agenda(publicador1.Object, DefaultEventoRepository, DefaultPersonaRepository);
      agenda.Agendar("Html 5", "jjmontes", DateTime.MinValue, urlInvitacion, TipoEvento.Van);

      var evento = DefaultEventoRepository.GetEventosConFecha().Single(e => e.Titulo == "Html 5");
      agenda.Confirmar(evento.Id);

      const string urlWiki = "http://www.altnethispano.org/wiki/van-2010-10-21-mono-cecil.ashx";
      agenda.Publicar(evento.Id, 71, urlWiki);

      Assert.AreEqual(71, evento.NumeroOrden);
      Assert.AreEqual(urlWiki, evento.UrlWiki);
    }

    [Test]
    [ExpectedException(typeof(AccionNoSoportadaException))]
    public void Al_confirmar_sin_agendar_debe_lanzarse_excepcion()
    {
 			var publicador1 = new Mock<IPublicador>();

      var agenda = new Agenda(publicador1.Object, DefaultEventoRepository, DefaultPersonaRepository);
      agenda.Proponer("Html 5", "jjmontes", urlInvitacion, TipoEvento.Van);

      var evento = DefaultEventoRepository.GetEventosSinFecha().Single(e => e.Titulo == "Html 5");

      Assert.IsFalse(evento.Estado.GetType() == typeof(EventoAgendadoState));

      agenda.Confirmar(evento.Id);
    }

    [Test]
    [ExpectedException(typeof(AccionNoSoportadaException))]
    public void Al_publicar_sin_confirmar_debe_lanzarse_excepcion()
    {
 			var publicador1 = new Mock<IPublicador>();

      var agenda = new Agenda(publicador1.Object, DefaultEventoRepository, DefaultPersonaRepository);
      agenda.Proponer("Html 5", "jjmontes", urlInvitacion, TipoEvento.Van);

      var evento = DefaultEventoRepository.GetEventosSinFecha().Single(e => e.Titulo == "Html 5");

      Assert.IsFalse(evento.Estado.GetType() == typeof(EventoConfirmadoState));

      agenda.Publicar(evento.Id, 0, string.Empty);
    }
	}
}