public void VerOertaShowldReturnViewWithViewModel()
{
Aeroporto aeroporto1 = new Aeroporto()
{
AeroportoId = 1,
Nome = "Aeroporto1",
Latitude = 38.779444,
Longitude = -9.136111,
};
Aeroporto aeroporto2 = new Aeroporto()
{
AeroportoId = 2,
Nome = "Aeroporto1",
Latitude = 39.779444,
Longitude = -10.136111,
};
Companhia companhia = new Companhia()
{
Nome = "Companhia1",
CompanhiaId = 1,
ListaReservas = new List <Reserva>()
};
Jato jato1 = new Jato()
{
CompanhiaId = 1,
AeroportoId = 1,
Nome = "Jato1",
EmFuncionamento = true,
CreditosBase = 2200,
CreditosPorKilometro = 1.1,
DistanciaMaxima = 1000000,
TempoPreparacao = 1,
VelocidadeMedia = 200
};
Disponibilidade disponibilidade1 = new Disponibilidade()
{
DisponibilidadeId = 1,
Inicio = "2017-09-22",
Fim = "2017-09-24"
};
jato1.ListaDisponibilidade.Add(disponibilidade1);
DateTime dataPartida = new DateTime(2017, 9, 23);
MyController <ClienteController>
.Instance()
.WithDbContext(dbContext => dbContext // <---
.WithEntities(entities => entities.AddRange(
aeroporto2, aeroporto1, companhia, jato1, disponibilidade1)))
.Calling(c => c.VerOferta(aeroporto1.AeroportoId, aeroporto2.AeroportoId, dataPartida, jato1.JatoId))
.ShouldReturn()
.View();
}
/// <summary>
/// Calcula o tempo de deslocação de uma jato desde um aeroporto até outro em ticks
/// </summary>
/// <param name="jatoId">id do jato</param>
/// <param name="aeroportoPartidaId">id do aeroporto de partida</param>
/// <param name="aeroportoDestinoId">id do aeroporto de destino</param>
/// <returns>Tempo de deslocação em ticks</returns>
private long CalcularTempoDeslocacaoTicks(int jatoId, int aeroportoPartidaId, int aeroportoDestinoId)
{
Jato jato = _context.Jato
.Single(j => j.JatoId == jatoId);
Aeroporto aeroportoPartida = _context.Aeroporto
.Single(j => j.AeroportoId == aeroportoPartidaId);
Aeroporto aeroportoDestino = _context.Aeroporto
.Single(j => j.AeroportoId == aeroportoDestinoId);
long distancia = Convert.ToInt64(DistanciaEntreCoordenadas(
aeroportoPartida.Latitude,
aeroportoPartida.Longitude,
aeroportoDestino.Latitude,
aeroportoDestino.Longitude
));
//Metros por segundo
long velocidade = Convert.ToInt64(jato.VelocidadeMedia);
if (velocidade == 0)
{
return(long.MaxValue);
}
return(((distancia * 1000) / velocidade) * TimeSpan.TicksPerSecond);
}
public void AeroportosDisponiveisDestinoShowReturnListEmpty()
{
Aeroporto aeroporto1 = new Aeroporto()
{
AeroportoId = 1,
Nome = "Aeroporto1",
Latitude = 38.779444,
Longitude = -9.136111,
};
Aeroporto aeroporto2 = new Aeroporto()
{
AeroportoId = 2,
Nome = "Aeroporto2",
Latitude = 39.779444,
Longitude = -10.136111,
};
Companhia companhia = new Companhia()
{
Nome = "Companhia1",
CompanhiaId = 1,
ListaReservas = new List <Reserva>()
};
Jato jato1 = new Jato()
{
CompanhiaId = 1,
AeroportoId = 1,
Nome = "Jato1",
EmFuncionamento = true,
CreditosBase = 2200,
CreditosPorKilometro = 1.1,
DistanciaMaxima = 1000000,
TempoPreparacao = 1,
VelocidadeMedia = 0
};
Disponibilidade disponibilidade1 = new Disponibilidade()
{
DisponibilidadeId = 1,
Inicio = "2017-09-22",
Fim = "2017-09-26"
};
jato1.ListaDisponibilidade.Add(disponibilidade1);
DateTime dataPartida = new DateTime(2017, 9, 23);
MyController <ClienteController>
.Instance()
.WithDbContext(dbContext => dbContext // <---
.WithEntities(entities => entities.AddRange(
aeroporto2, aeroporto1, companhia, jato1, disponibilidade1)))
.Calling(c => c.AeroportosDestinoDisponiveis(aeroporto1.AeroportoId, dataPartida))
.ShouldReturn()
.ResultOfType <IEnumerable <Aeroporto> >()
.Passing(c => c.Count() == 0);
}
public void DisponibilidadePontualTesteDeslocacao()
{
Aeroporto aeroporto1 = new Aeroporto()
{
AeroportoId = 1,
Nome = "Aeroporto1",
Latitude = 38.779444,
Longitude = -9.136111,
};
Aeroporto aeroporto2 = new Aeroporto()
{
AeroportoId = 2,
Nome = "Aeroporto2",
Latitude = 40.472222,
Longitude = -3.560833,
};
Companhia companhia = new Companhia()
{
Nome = "Companhia1",
CompanhiaId = 1,
ListaReservas = new List <Reserva>()
};
Jato jato1 = new Jato()
{
CompanhiaId = 1,
AeroportoId = 1,
Nome = "Jato1",
EmFuncionamento = true,
CreditosBase = 2200,
CreditosPorKilometro = 1.1
};
Disponibilidade disponibilidade1 = new Disponibilidade()
{
DisponibilidadeId = 1,
Inicio = "22/09/2017",
Fim = "24/09/2017"
};
jato1.ListaDisponibilidade.Add(disponibilidade1);
DateTime dataPartida = new DateTime(2017, 9, 23);
MyController <ClienteController> .Instance()
.WithDbContext(dbContext => dbContext
.WithEntities(entities => entities.AddRange(
aeroporto1,
aeroporto2,
companhia,
jato1,
disponibilidade1)))
.Calling(c => c.AeroportosDisponiveis(dataPartida))
.ShouldReturn()
.ResultOfType <IEnumerable <Aeroporto> >()
.Passing(c => c.Any(a => a.AeroportoId == aeroporto2.AeroportoId));
}
/// <summary>
/// Devolve o custo de uma reserva tendo em conta a distância, o jato e os extras
/// </summary>
/// <returns>Custo da reserva</returns>
private double CalcularCusto(double distancia, Jato jato, List <int> extrasids)
{
ICollection <Extra> extras = _context.Extra.Where(e => FiltrarExtras(e, extrasids)).ToList();
double custo = jato.CreditosBase +
jato.CreditosPorKilometro * distancia +
Double.Parse(extras.Select(e => e.Valor).Sum().ToString());
return(custo);
}
public EditarJatoDialog(Jato jato = null)
{
InitializeComponent();
Jato = new Jato();
if (jato != null)
{
Jato.Nome = jato.Nome;
}
GridFormJato.DataContext = Jato;;
}
/// <summary>
/// Verifica se o jato consegue executar a distância
/// </summary>
/// <param name="jatoId">id do jato</param>
/// <param name="aeroportoPartidaId">id do aeroporto de partida</param>
/// <param name="aeroportoDestinoId">id do aeroporto de destino</param>
/// <returns>true se conseguir, false senão</returns>
private bool DistanciaDeslocaoValida(int jatoId, int aeroportoPartidaId, int aeroportoDestinoId)
{
Jato jato = _context.Jato
.Single(j => j.JatoId == jatoId);
Aeroporto aeroportoPartida = _context.Aeroporto
.Single(j => j.AeroportoId == aeroportoPartidaId);
Aeroporto aeroportoDestino = _context.Aeroporto
.Single(j => j.AeroportoId == aeroportoDestinoId);
double distanciaMaxima = jato.DistanciaMaxima;
double distancia = DistanciaEntreCoordenadas(
aeroportoPartida.Latitude,
aeroportoPartida.Longitude,
aeroportoDestino.Latitude,
aeroportoDestino.Longitude
);
return(distancia <= distanciaMaxima);
}
public IActionResult ReservaConcluida(int idpartida, int iddestino, DateTime data, int jatoid, List <int> extrasids)
{
try
{
setupNav();
//Aeroporto partida = _context.Aeroporto.Single(a => a.AeroportoId == id);
string idCliente = _userManager.GetUserAsync(this.User).Result.Id;
Aeroporto aeroportoPartida = _context.Aeroporto.Single(a => a.AeroportoId == idpartida);
Aeroporto aeroportoChegada = _context.Aeroporto.Single(a => a.AeroportoId == iddestino);
Jato jato = _context.Jato
.Include(a => a.ListaDisponibilidade)
.Include(a => a.Aeroporto)
.Single(a => a.JatoId == jatoid);
TipoDisponibilidade disponibilidade = JatoDisponivelIntervalo(jatoid, idpartida, iddestino, data);
if (disponibilidade == TipoDisponibilidade.NaoDisponivel)
{
throw new Exception("O jato não está disponível");
}
double distancia = DistanciaEntreCoordenadas(aeroportoPartida.Latitude,
aeroportoPartida.Longitude,
aeroportoChegada.Latitude,
aeroportoChegada.Longitude);
double custo = CalcularCusto(distancia, jato, extrasids);
long tempoDeViagem = CalcularTempoDeslocacaoTicks(jatoid, aeroportoPartida.AeroportoId, aeroportoChegada.AeroportoId);
DateTime chegada = new DateTime(tempoDeViagem + data.Ticks);
Cliente cliente = _context.Cliente.Include(c => c.ContaDeCreditos).Single(c => c.Id == idCliente);
if (double.Parse(cliente.ContaDeCreditos.JetCashActual.ToString()) < custo)
{
throw new Exception("Os créditos não são suficientes");
}
Reserva reserva = new Reserva()
{
AeroportoDestinoId = aeroportoChegada.AeroportoId,
AeroportoPartidaId = aeroportoPartida.AeroportoId,
Aprovada = false,
Custo = decimal.Parse(custo.ToString()),
DataPartida = data,
DataChegada = chegada,
JatoId = jatoid,
Paga = false,
Realizada = false,
ApplicationUserId = idCliente,
};
_context.Reserva.Add(reserva);
Notificacao notificacaoCliente = new Notificacao()
{
Lida = false,
UtilizadorId = idCliente,
Mensagem = "Efetuou recentemente uma reserva, aguarde validação",
Tipo = Notificacao.TYPE_SUCCESS,
};
_context.Notificacao.Add(notificacaoCliente);
_context.SaveChanges();
return(View("ReservaConcluida"));
}
catch (Exception ex)
{
ViewData["erro"] = ex.Message;
return(View("ReservaNaoConcluida"));
}
}
/// <summary>
/// Responsável por redireccionar o utilizador para a página que apresenta a informação de uma oferta
/// </summary>
/// <returns>Retorna a view das ofertas</returns>
public IActionResult VerOferta(int idpartida, int iddestino, DateTime data, int jatoid)
{
try
{
setupNav();
Aeroporto aeroportoPartida = _context.Aeroporto.Include(a => a.Cidade).Include(a => a.Cidade.Pais).Single(a => a.AeroportoId == idpartida);
Aeroporto aeroportoChegada = _context.Aeroporto.Include(a => a.Cidade).Include(a => a.Cidade.Pais).Single(a => a.AeroportoId == iddestino);
Jato Jato = _context.Jato
.Select(c => c)
.Include(a => a.Companhia)
.Include(a => a.Modelo)
.Include(a => a.Aeroporto)
.Include(a => a.Companhia.ListaExtras)
.Include(a => a.Companhia.ListaReservas)
.First(a => a.JatoId == jatoid);
if (Jato == null)
{
return(RedirectToAction("Index"));
}
if (Jato.RelativePathImagemPerfil == null)
{
Jato.RelativePathImagemPerfil = Path.Combine("images", "aviao-default.svg");
}
ICollection <Reserva> Reservas = Jato.Companhia.ListaReservas;
int reservasAvalidas = Reservas.Count(c => c.Avaliacao >= 0 && c.Avaliacao < 6);
int estrelas;
if (reservasAvalidas == 0)
{
estrelas = 5;
}
else
{
estrelas = Reservas.Where(c => c.Avaliacao >= 0 && c.Avaliacao < 6).Select(c => c.Avaliacao).Sum() / reservasAvalidas;
}
VerOfertaViewModel verOfertaViewModel = new VerOfertaViewModel()
{
Jato = Jato,
AeroportoChegada = aeroportoChegada,
AeroportoPartida = aeroportoPartida,
DataPartida = data,
Estrelas = estrelas,
Kilometros = DistanciaEntreCoordenadas(aeroportoPartida.Latitude,
aeroportoPartida.Longitude,
aeroportoChegada.Latitude,
aeroportoChegada.Longitude)
};
return(View(verOfertaViewModel));
}
catch (Exception ex)
{
return(RedirectToAction("Index"));
}
}
/// <summary>
/// Verifica se um jato está disponível para a partida de um aeroporto para outro numa data
/// tendo em conta o tempo calculado da viagem, isto implica que é possível conjugar com as restantes reservas
/// </summary>
/// <param name="jatoId">id do jato</param>
/// <param name="aeroportoPartidaId">id do aeroporto de partida</param>
/// /// <param name="aeroportoDestinoId">id do aeroporto de destino</param>
/// <param name="dataReserva">data de partida do jato do aeroporto</param>
/// <returns>True se o jato está disponivel no aeroporto de partida na data de partida e consegue efetuar o voo</returns>
private TipoDisponibilidade JatoDisponivelIntervalo(int jatoId, int aeroportoPartidaId, int aeroportoDestinoId, DateTime dataReserva)
{
Jato jato = _context.Jato
.Include(j => j.ListaDisponibilidade)
.Include(j => j.Companhia)
.Include(j => j.Companhia.ListaReservas)
.Single(j => j.JatoId == jatoId);
if (dataReserva.Ticks < DateTime.Now.Ticks + jato.TempoPreparacao)
{
return(TipoDisponibilidade.NaoDisponivel);
}
Aeroporto aeroportoPartida = _context.Aeroporto
.Single(j => j.AeroportoId == aeroportoPartidaId);
Aeroporto aeroportoDestino = _context.Aeroporto
.Single(j => j.AeroportoId == aeroportoDestinoId);
double tempoDePreparacao = jato.TempoPreparacao;
double tempoDeDeslocacao = CalcularTempoDeslocacaoTicks(jatoId, aeroportoPartidaId, aeroportoDestinoId);
double tempoTotalDispendido = tempoDePreparacao + tempoDeDeslocacao;
foreach (Disponibilidade disponibilidade in jato.ListaDisponibilidade)
{
DateTime disponibilidadeInicio = Convert.ToDateTime(disponibilidade.Inicio);
DateTime disponibilidadeFim = Convert.ToDateTime(disponibilidade.Fim);
bool p1 = dataReserva.Ticks > disponibilidadeInicio.Ticks;
bool p2 = dataReserva.Ticks < disponibilidadeFim.Ticks;
bool p3 = dataReserva.Ticks + tempoTotalDispendido < disponibilidadeFim.Ticks;
//Não existe disponibilidade para a viagem
if (!(p1 && p2 && p3))
{
return(TipoDisponibilidade.NaoDisponivel);
}
bool existeReserva = jato.Companhia.ListaReservas
.Where(r => r.JatoId == jatoId)
.Any(r =>
(r.DataChegada.Ticks >= dataReserva.Ticks &&
r.DataPartida.Ticks <= dataReserva.Ticks) ||
(r.DataChegada.Ticks >= dataReserva.Ticks + tempoTotalDispendido &&
r.DataPartida.Ticks <= dataReserva.Ticks + tempoTotalDispendido)
);
if (existeReserva)
{
return(TipoDisponibilidade.NaoDisponivel);
}
//Última reserva antes da data
Reserva reservaAnterior = jato.Companhia.ListaReservas
.Where(r => r.JatoId == jatoId)
.Where(r => r.DataChegada.Ticks < dataReserva.Ticks)
.OrderByDescending(r => r.DataChegada.Ticks).FirstOrDefault();
bool semDeslocacaoPrevia = false;
//Não existe reserva que antecede a data
if (reservaAnterior == null)
{
// Nao existe reserva logo vemos a posição atual do avião e
//calculamos o tempo de voo até chegar ao aeroporto de partida
//Se o jato está na posição de partida
//---PosicaoJato---A___A---NovaReserva---B
if (jato.AeroportoId == aeroportoPartidaId)
{
semDeslocacaoPrevia = true;
}
//Se a deslocação não é possivel para a distância
if (!DistanciaDeslocaoValida(jatoId, jato.AeroportoId, aeroportoPartidaId))
{
return(TipoDisponibilidade.NaoDisponivel);
}
tempoDeDeslocacao = CalcularTempoDeslocacaoTicks(jatoId, jato.AeroportoId, aeroportoPartidaId);
tempoTotalDispendido = tempoDeDeslocacao + tempoDePreparacao;
if (!(tempoTotalDispendido < dataReserva.Ticks - DateTime.Now.Ticks))
{
return(TipoDisponibilidade.NaoDisponivel);
}
}
else
{
//Se a última reserva tem destino ao aeroporto de partida
// C---ReservaAnterior---A___A---NovaReserva---B
if (reservaAnterior.AeroportoDestinoId == aeroportoPartidaId)
{
semDeslocacaoPrevia = true;
}
//Se a deslocação não é possivel para a distância
if (!DistanciaDeslocaoValida(jatoId, jato.AeroportoId, aeroportoPartidaId))
{
return(TipoDisponibilidade.NaoDisponivel);
}
tempoDeDeslocacao = CalcularTempoDeslocacaoTicks(jatoId, reservaAnterior.AeroportoDestinoId, aeroportoPartidaId);
tempoTotalDispendido = tempoDeDeslocacao + tempoDePreparacao;
//Se o tempo total dispendido for inferior ao disponível
if (tempoTotalDispendido >= dataReserva.Ticks - reservaAnterior.DataChegada.Ticks)
{
return(TipoDisponibilidade.NaoDisponivel);
}
}
//Primeira reserva depois da data de chegadas deste voo
Reserva reservaPosterior = jato.Companhia.ListaReservas
.Where(r => dataReserva.Ticks + tempoTotalDispendido < r.DataPartida.Ticks)
.OrderBy(r => r.DataChegada.Ticks).FirstOrDefault();
// A---NovaReserva---B______________
if (reservaPosterior == null)
{
return(semDeslocacaoPrevia
? TipoDisponibilidade.Disponivel
: TipoDisponibilidade.DisponivelDeslocacao);
}
//Se o jato vai estar no mesmo aeroporto
// A---NovaReserva---B____B---ReservaPosterior---C
if (aeroportoDestinoId == reservaPosterior.AeroportoPartidaId)
{
return(semDeslocacaoPrevia
? TipoDisponibilidade.Disponivel
: TipoDisponibilidade.DisponivelDeslocacao);
}
// A---NovaReserva---B____C---ReservaPosterior---D
//Temos que calcular a deslocação
//Se a deslocação não é possivel para a distância
if (!DistanciaDeslocaoValida(jatoId, aeroportoDestinoId, reservaPosterior.AeroportoPartida.AeroportoId))
{
return(TipoDisponibilidade.NaoDisponivel);
}
double tempoDeDeslocacaoAteProximaReserva = CalcularTempoDeslocacaoTicks(jatoId, aeroportoDestinoId, reservaPosterior.AeroportoPartida.AeroportoId);
double tempoTotalDispendidoAteProximaReserva = tempoDeDeslocacaoAteProximaReserva + tempoDePreparacao;
double tempoDisponivel = reservaPosterior.DataPartida.Ticks - (dataReserva.Ticks + tempoDeDeslocacao);
//Tempo dispendido até ao aeroporto de partida da proxima reserva superior ao tempo disponivel
if (tempoTotalDispendidoAteProximaReserva > tempoDisponivel)
{
return(TipoDisponibilidade.NaoDisponivel);
}
return(TipoDisponibilidade.DisponivelDeslocacao);
}
return(TipoDisponibilidade.NaoDisponivel);
}
/// <summary>
/// Verifica se um jato está disponível para a partida de um aeroporto numa data
/// </summary>
/// <param name="jatoId">id do jato</param>
/// <param name="aeroportoPartidaId">id do aeroporto de partida</param>
/// <param name="dataReserva">data de partida do jato do aeroporto</param>
/// <returns>True se o jato está disponivel no aeroporto de partida na data de partida</returns>
private TipoDisponibilidade JatoDisponivelPontual(int jatoId, int aeroportoPartidaId, DateTime dataReserva)
{
Jato jato = _context.Jato
.Include(j => j.ListaDisponibilidade)
.Include(j => j.Companhia)
.Include(j => j.Companhia.ListaReservas)
.Single(j => j.JatoId == jatoId);
if (dataReserva.Ticks < DateTime.Now.Ticks + jato.TempoPreparacao)
{
return(TipoDisponibilidade.NaoDisponivel);
}
foreach (Disponibilidade disponibilidade in jato.ListaDisponibilidade)
{
DateTime d1 = Convert.ToDateTime(disponibilidade.Inicio);
DateTime d2 = Convert.ToDateTime(disponibilidade.Fim);
bool p1 = dataReserva.Ticks > d1.Ticks;
bool p2 = dataReserva.Ticks < d2.Ticks;
//Data enquadra-se na disponibilidade
if (p1 && p2)
{
bool existeReserva = jato.Companhia.ListaReservas
.Where(r => r.JatoId == jatoId)
.Any(r => r.DataChegada.Ticks >= dataReserva.Ticks &&
r.DataPartida.Ticks <= dataReserva.Ticks);
if (existeReserva)
{
return(TipoDisponibilidade.NaoDisponivel);
}
//Última reserva antes da data
Reserva reserva = jato.Companhia.ListaReservas
.Where(r => r.JatoId == jatoId)
.Where(r => r.DataChegada.Ticks < dataReserva.Ticks)
.OrderByDescending(r => r.DataChegada.Ticks).FirstOrDefault();
double tempoDePreparacao = jato.TempoPreparacao;
double tempoDeDeslocacao;
double tempoTotalDispendido;
if (reserva == null)
{
//Nao existe reserva logo vemos a posição atual do avião e
//calculamos o tempo de voo até chegar ao aeroporto de partida
//Se o jato está na posição de partida
if (jato.AeroportoId == aeroportoPartidaId)
{
return(TipoDisponibilidade.Disponivel);
}
//Se a deslocação não possivel para a distância
if (!DistanciaDeslocaoValida(jatoId, jato.AeroportoId, aeroportoPartidaId))
{
return(TipoDisponibilidade.NaoDisponivel);
}
tempoDeDeslocacao = CalcularTempoDeslocacaoTicks(jatoId, jato.AeroportoId, aeroportoPartidaId);
tempoTotalDispendido = tempoDeDeslocacao + tempoDePreparacao;
double tempoDisponivel = dataReserva.Ticks - DateTime.Now.Ticks;
if (tempoTotalDispendido < tempoDisponivel)
{
return(TipoDisponibilidade.DisponivelDeslocacao);
}
return(TipoDisponibilidade.NaoDisponivel);
}
//Se a última reserva tem destino ao aeroporto de partida
if (reserva.AeroportoDestinoId == aeroportoPartidaId)
{
//Nesta fase não conseguimos garantir que não haja
//uma reserva sobreposta pois ainda não sabemos o destino.
//Portanto assume-se que o jato está disponível no aeroporto
//sem recurrer a deslocações.
return(TipoDisponibilidade.Disponivel);
}
//Se a deslocação não é possivel para a distância
if (!DistanciaDeslocaoValida(jatoId, jato.AeroportoId, aeroportoPartidaId))
{
return(TipoDisponibilidade.NaoDisponivel);
}
tempoDeDeslocacao = CalcularTempoDeslocacaoTicks(jatoId, reserva.AeroportoDestinoId, aeroportoPartidaId);
tempoTotalDispendido = tempoDeDeslocacao + tempoDePreparacao;
//Se o tempo total dispendido for inferior ao disponível
if (tempoTotalDispendido < dataReserva.Ticks - reserva.DataChegada.Ticks)
{
return(TipoDisponibilidade.DisponivelDeslocacao);
}
}
}
return(TipoDisponibilidade.NaoDisponivel);
}
public void DisponibilidadeIntervaloTesteIndisponivelReservado()
{
Aeroporto aeroporto1 = new Aeroporto()
{
AeroportoId = 1,
Nome = "Aeroporto1",
Latitude = 38.779444,
Longitude = -9.136111,
};
Aeroporto aeroporto2 = new Aeroporto()
{
AeroportoId = 2,
Nome = "Aeroporto2",
Latitude = 40.472222,
Longitude = -3.560833,
};
Companhia companhia = new Companhia()
{
Nome = "Companhia1",
CompanhiaId = 1,
ListaReservas = new List <Reserva>()
};
Jato jato1 = new Jato()
{
CompanhiaId = 1,
AeroportoId = 1,
Nome = "Jato1",
EmFuncionamento = true,
CreditosBase = 2200,
CreditosPorKilometro = 1.1
};
Disponibilidade disponibilidade1 = new Disponibilidade()
{
DisponibilidadeId = 1,
Inicio = "22/09/2017",
Fim = "24/09/2017"
};
Reserva reserva = new Reserva()
{
DataPartida = new DateTime(2017, 9, 20),
DataChegada = new DateTime(2017, 9, 25),
JatoId = 1,
AeroportoPartidaId = 1,
AeroportoDestinoId = 2
};
companhia.ListaReservas.Add(reserva);
jato1.ListaDisponibilidade.Add(disponibilidade1);
DateTime dataPartida = new DateTime(2017, 9, 23);
MyController <ClienteController> .Instance()
.WithDbContext(dbContext => dbContext
.WithEntities(entities => entities.AddRange(
aeroporto1, aeroporto2, reserva, companhia, jato1, disponibilidade1)))
.Calling(c => c.AeroportosDestinoDisponiveis(aeroporto1.AeroportoId, dataPartida))
.ShouldReturn()
.ResultOfType <IEnumerable <Aeroporto> >()
.Passing(c => c.Count() == 0);
}
