diff --git a/.gitignore b/.gitignore index 5ff6309..af665ab 100644 --- a/.gitignore +++ b/.gitignore @@ -35,4 +35,4 @@ build/ .vscode/ ### Mac OS ### -.DS_Store \ No newline at end of file +.DS_Store diff --git a/README.md b/README.md index a18a169..affa2ba 100644 --- a/README.md +++ b/README.md @@ -5,8 +5,6 @@ Alumnos: - Gerez Facundo Nahuel - 109429 - Orsi Tomas Fabrizio - 109735 -![Diagrama UML](Diagrama/diagramaClases.png) - # Consigna Lógica de negocio (etapa 1) diff --git a/pom.xml b/pom.xml index c98ab16..a1cd38d 100644 --- a/pom.xml +++ b/pom.xml @@ -21,5 +21,27 @@ test - - \ No newline at end of file + + + + org.jacoco + jacoco-maven-plugin + 0.8.9 + + + + prepare-agent + + + + report + prepare-package + + report + + + + + + + diff --git a/src/main/java/Activities.java b/src/main/java/Activities.java index ccf14d8..94beee7 100644 --- a/src/main/java/Activities.java +++ b/src/main/java/Activities.java @@ -1,31 +1,43 @@ import java.time.LocalDateTime; -import java.util.ArrayList; +import java.util.List; public abstract class Activities { //--------- Atributos --------- - enum tipo {TAREA,EVENTO} - protected final String name; - protected final String description; - protected ArrayList alarm; - protected final boolean isComplete; + + protected String name; + protected String description; + protected final Alarmas alarm = new Alarmas(); + protected boolean isComplete; + //--------- Atributos --------- + //--------- Constructores --------- - public Activities(String name, String description, ArrayList alarm, boolean isComplete) { - this.name = name; - this.description = description; - this.alarm = alarm; - this.isComplete = isComplete; - } - public Activities(String name, String description, boolean isComplete) { - this.name = name; - this.description = description; - this.isComplete = isComplete; + + public Activities() { + this.name = ""; + this.description = ""; + this.isComplete = false; } + //--------- Constructores --------- + //--------- Metodos --------- - public abstract tipo type(); + public abstract LocalDateTime cuandoTermina(); public abstract LocalDateTime cuandoEmpieza(); + public LocalDateTime ultimaAlarma(){ + if (alarm.quedanAlarmas()){ + return alarm.primerAlarmaASonar(); + } + return null; + } + public void sonarUltimaAlarma(){ + if (alarm.quedanAlarmas()){ + alarm.sonarAlarma(); + }//else + //error + //} + } public String getTitulo() { return name; } @@ -35,5 +47,24 @@ public String getDescripcion() { public boolean esDiaEntero() { return isComplete; } + public void setName(String name) { + this.name = name; + } + public void setDescription(String description) { + this.description = description; + } + public void setComplete(boolean complete) { + isComplete = complete; + } + public void agregarAlarma(LocalDateTime alarmaNueva) { + this.alarm.agregarAlarma(alarmaNueva); + } + public void agregarAlarmas(List alarmasNuevas) { + this.alarm.agregarAlarma(alarmasNuevas); + } + public void eliminarAlarma(LocalDateTime alarmaNueva) { + this.alarm.eliminarAlarma(alarmaNueva); + } + //--------- Metodos --------- } diff --git a/src/main/java/Alarmas.java b/src/main/java/Alarmas.java new file mode 100644 index 0000000..3d47306 --- /dev/null +++ b/src/main/java/Alarmas.java @@ -0,0 +1,133 @@ +//import java.time.Duration; +import java.time.LocalDateTime; +import java.util.HashSet; +import java.util.List; +import java.util.Set; + +public class Alarmas { + //--------- Atributos --------- + + private final Set alarmas; + private LocalDateTime alarmaMasTemprana; + private final Set alarmasYaSonadas; + private boolean mantenerAlarmas = false; + + //--------- Atributos --------- + + //--------- Constructores --------- + public Alarmas() { + alarmaMasTemprana = null; + alarmas = new HashSet<>(); + alarmasYaSonadas = new HashSet<>(); + } + public Alarmas(boolean mantener) { + alarmaMasTemprana = null; + alarmas = new HashSet<>(); + mantenerAlarmas = mantener; + alarmasYaSonadas = new HashSet<>(); + } + + //--------- Constructores --------- + + //--------- Metodos --------- + + /* + *public void actualizarAlarmas(LocalDateTime dif){ + if (dif != null && alarmas.size()==0 && mantenerAlarmas){ + for (LocalDateTime alarm : alarmasYaSonadas){ + LocalDateTime nuevaAlarm = alarm.plusYears(dif.getYear()).plusMonths(dif.getMonthValue()).plusDays(dif.getDayOfMonth()).plusHours(dif.getHour()).plusMinutes(dif.getMinute()); + alarmasYaSonadas.remove(alarm); + alarmasYaSonadas.add(nuevaAlarm); + } + alarmas.addAll(alarmasYaSonadas); + } + }*/ + public int size(){ + return alarmas.size(); + } + public void actualizarAlarmas(long cantidadDiasASumar){ + if (cantidadDiasASumar != 0 && alarmas.size()==0 && mantenerAlarmas){ + for (LocalDateTime alarm : alarmasYaSonadas){ + LocalDateTime nuevaAlarm = alarm.plusDays(cantidadDiasASumar); + alarmas.add(nuevaAlarm); + } + alarmasYaSonadas.clear(); + alarmasYaSonadas.addAll(alarmas); + } + } + public void agregarAlarma(LocalDateTime alarmaParaAgregar){ + if (alarmaParaAgregar== null){ + return; + } + alarmas.add(alarmaParaAgregar); + if (mantenerAlarmas){ + alarmasYaSonadas.add(alarmaParaAgregar); + } + if ((alarmaMasTemprana != null) && alarmaMasTemprana.isAfter(alarmaParaAgregar)) { + alarmaMasTemprana = alarmaParaAgregar; + } + } + public void agregarAlarma(List alarmasParaAgregar){ + if (alarmasParaAgregar!=null){ + for (LocalDateTime alarm : alarmasParaAgregar){ + if (alarm== null){ + continue; + } + alarmas.add(alarm); + if (mantenerAlarmas){ + alarmasYaSonadas.add(alarm); + } + if ((alarmaMasTemprana != null) && alarmaMasTemprana.isAfter(alarm)) { + alarmaMasTemprana = alarm; + } + } + } + + + } + public boolean quedanAlarmas(){ + //devuelve true si todavia quedan + return alarmas.size()!= 0; + } + public boolean existeAlarma(LocalDateTime a1){ + return alarmas.contains(a1); + } + public void eliminarAlarma(LocalDateTime paraEliminar){ + alarmas.remove(paraEliminar); + alarmasYaSonadas.remove(paraEliminar); + if (paraEliminar!= null && paraEliminar.equals(alarmaMasTemprana)){ + alarmaMasTemprana = null; + } + } + public LocalDateTime primerAlarmaASonar(){ + if (alarmaMasTemprana == null){ + for (LocalDateTime alarm : alarmas){ + if (alarmaMasTemprana == null){ + alarmaMasTemprana = alarm; + } else if (alarmaMasTemprana.isAfter(alarm)) { + alarmaMasTemprana = alarm; + } + } + } + return alarmaMasTemprana; + } + public void sonarAlarma(){ + if (alarmaMasTemprana == null){ + this.primerAlarmaASonar(); + } + if (alarmaMasTemprana != null){ + alarmas.remove(alarmaMasTemprana); + alarmaMasTemprana = null; + }//else { + //error + //} + } + public boolean repiteLasAlarmas() { + return mantenerAlarmas; + } + public void mantenerAlarmas(boolean mantenerAlarmas) { + this.mantenerAlarmas = mantenerAlarmas; + } + + //--------- Metodos --------- +} diff --git a/src/main/java/Calendario.java b/src/main/java/Calendario.java index 2567f5b..59dd17b 100644 --- a/src/main/java/Calendario.java +++ b/src/main/java/Calendario.java @@ -1,37 +1,195 @@ import java.time.LocalDateTime; import java.util.ArrayList; +import java.util.List; public class Calendario { //--------- Atributos --------- - private String nombre; - private ArrayList listaEventos = new ArrayList(); - private ArrayList listaTareas = new ArrayList(); + private final ArrayList listaTareas = new ArrayList<>(); + private final ArrayList listaEventos = new ArrayList<>(); + private LocalDateTime maximaAlarmaActual = null; //--------- Atributos --------- //--------- Constructores --------- - public Calendario(String nombreCalendario){ - this.nombre = nombreCalendario; - } - //--------- Constructores --------- - //--------- Metodos --------- - public void crearTarea(String nombre, String description, ArrayList alarm, boolean esDiaCompleto, LocalDateTime termina){ - var nuevaTarea = new Tarea(nombre, description, alarm, esDiaCompleto, termina); - this.listaTareas.add(nuevaTarea); + //--------- Métodos --------- + + public int crearTarea(LocalDateTime termina){ + Tarea nuevaTarea = new Tarea(termina); + listaTareas.add(nuevaTarea); + return nuevaTarea.hashCode(); } + public int crearEvento(LocalDateTime arranque, LocalDateTime termina){ + Evento nuevoEvento = new Evento(arranque,termina); + listaEventos.add(nuevoEvento); + return nuevoEvento.hashCode(); + } + public LocalDateTime proximaAlarma(){ + if (maximaAlarmaActual == null){ + for (Evento ev : listaEventos){ + LocalDateTime alarm = ev.ultimaAlarma(); + if (maximaAlarmaActual==null){ + maximaAlarmaActual = alarm; + } else if (maximaAlarmaActual.isAfter(alarm)) { + maximaAlarmaActual = alarm; + } + + } + for (Tarea t : listaTareas){ + LocalDateTime alarm = t.ultimaAlarma(); + if (maximaAlarmaActual==null){ + maximaAlarmaActual = alarm; + } else if (maximaAlarmaActual.isAfter(alarm)) { + maximaAlarmaActual = alarm; + } + } + } + return maximaAlarmaActual; - public void crearEvento(String nombre, String description, ArrayList alarm, boolean esDiaCompleto,LocalDateTime arranque, LocalDateTime termina){ - var nuevoEvento = new Evento(nombre, description, alarm, esDiaCompleto, arranque, termina); - this.listaEventos.add(nuevoEvento); } + public ArrayList sonarAlarmas(){ + ArrayList retorno = new ArrayList<>(); + if (maximaAlarmaActual != null){ + for (Evento ev : listaEventos){ + LocalDateTime alarmaProxima = ev.ultimaAlarma(); + if (alarmaProxima.equals(maximaAlarmaActual)){ + retorno.add(ev); + ev.sonarUltimaAlarma(); + } + } + for (Tarea t : listaTareas){ + LocalDateTime alarmaProxima = t.ultimaAlarma(); + if (alarmaProxima.equals(maximaAlarmaActual)){ + retorno.add(t); + t.sonarUltimaAlarma(); + } + } + maximaAlarmaActual = null; + } + return retorno; + } + public Activities obtenerActividad(int ID){ + for (Evento e: listaEventos){ + if (e.hashCode() == ID){ + return e; + } + } + for (Tarea t: listaTareas){ + if (t.hashCode() == ID){ + return t; + } + } + return null; + } + public Evento obtenerEvento(int ID){ + for (Evento e: listaEventos){ + if (e.hashCode() == ID){ + return e; + } + } + return null; + } + public Tarea obtenerTarea(int ID){ + for (Tarea t: listaTareas){ + if (t.hashCode() == ID){ + return t; + } + } + return null; + } + public void modificarActividadNombre(int ID,String nombre){ + var act = this.obtenerActividad(ID); + if (act!= null) { + act.setName(nombre); + } + } + public void modificarActividadDescripcion(int ID, String descripcion){ + var act = this.obtenerActividad(ID); + if (act!= null) { + act.setDescription(descripcion); + } + } + public void modificarActividadEsDiaEntero(int ID, boolean esDiaCompleto){ + var act = this.obtenerActividad(ID); + if (act!= null) { + act.setComplete(esDiaCompleto); + } + } + public void modificarEventoPlazoTemporal(int ID, LocalDateTime arrancaNuevo, LocalDateTime terminaNuevo){ + var ev = this.obtenerEvento(ID); + if (ev!= null){ + ev.setArranque(arrancaNuevo); + ev.setTermina(terminaNuevo); + } + } + public void modificarEventoFrecuencia(int ID, Frecuencia frecuenciaNueva){ + var ev = this.obtenerEvento(ID); + if (ev!= null){ + ev.setFrecuencia(frecuenciaNueva); + } + } + public void modificarTareaPlazoTemporal(int ID,LocalDateTime terminaNuevo){ + var t = this.obtenerTarea(ID); + if (t != null){ + t.setTermina(terminaNuevo); + } + } + public void modificarTareaCompletarODescompletar(int ID){ + var t = this.obtenerTarea(ID); + if (t != null){ + t.marcarCompleta(); + } + } + public void modificarActividadAgregarAlarma(int ID, String s){ + var act = this.obtenerActividad(ID); + var duracionAnterior = PlazoAnterior.compararHorariosDescriptos(s); + if (act!= null && duracionAnterior!= null){ + var alarma = act.cuandoEmpieza().minus(duracionAnterior.elHorarioEstablecido()); + act.agregarAlarma(alarma); + } + } + public void modificarActividadAgregarAlarma(int ID, LocalDateTime alarma){ + var act = this.obtenerActividad(ID); + if (act!= null){ + act.agregarAlarma(alarma); + } - public Tarea obtenerTareaPorIndice(int ID){ - return this.listaTareas.get(ID); } - + public void modificarActividadAgregarAlarma(int ID, List alarma){ + var act = this.obtenerActividad(ID); + if (act!= null){ + act.agregarAlarmas(alarma); + } + } + public void modificarActividadEliminarAlarma(int ID, LocalDateTime alarma){ + var act = this.obtenerActividad(ID); + if (act != null){ + act.eliminarAlarma(alarma); + } + } + public void modificarActividadEliminarAlarma(int ID, String s){ + var act = this.obtenerActividad(ID); + var duracionAnterior = PlazoAnterior.compararHorariosDescriptos(s); + if (act!= null && duracionAnterior!= null){ + var alarma = act.cuandoEmpieza().minus(duracionAnterior.elHorarioEstablecido()); + act.eliminarAlarma(alarma); + } + } + public void eliminarEvento(int ID){ + var ev = obtenerEvento(ID); + if (ev!=null){ + listaEventos.remove(ev); + } + } + public void eliminarTarea(int ID){ + var t = obtenerTarea(ID); + if (t!=null){ + listaTareas.remove(t); + } + } + } diff --git a/src/main/java/Evento.java b/src/main/java/Evento.java index 4242c0c..58e04b7 100644 --- a/src/main/java/Evento.java +++ b/src/main/java/Evento.java @@ -1,30 +1,74 @@ import java.time.LocalDateTime; -import java.util.ArrayList; +import java.time.temporal.ChronoUnit; public class Evento extends Activities { //--------- Atributos --------- - private LocalDateTime arranque; - private LocalDateTime termina; + + private LocalDateTime arranquePrincipio; + private LocalDateTime terminaPrincipio; + private LocalDateTime arranqueActual; + private LocalDateTime terminaActual; + private Frecuencia frecuencia; + //--------- Atributos --------- + //--------- Constructores --------- - public Evento(String name, String description, ArrayList alarm, boolean isComplete, LocalDateTime arranque, LocalDateTime termina) { - super(name, description, alarm, isComplete); - this.arranque = arranque; - this.termina = termina; + public Evento(LocalDateTime arranque, LocalDateTime termina ) { + super(); + this.arranquePrincipio = arranque; + this.arranqueActual = arranque; + this.terminaPrincipio = termina; + this.terminaActual = termina; + frecuencia = null; } - //--------- Constructores --------- + //--------- Metodos --------- - @Override - public tipo type() { - return tipo.EVENTO; - } + @Override public LocalDateTime cuandoEmpieza(){ - return this.arranque; + return this.arranqueActual; } @Override public LocalDateTime cuandoTermina() { - return this.termina; + return this.terminaActual; } + public boolean caeElDia(LocalDateTime diaEspecifico){ + //Averiguo si la frecuencia hace que el evento caiga el día pedido + boolean caeElDiaPedido = this.frecuencia.dadoComienzoCaeElDia(this.arranquePrincipio, diaEspecifico); + return caeElDiaPedido; + } + public LocalDateTime proximoEventoMasCercanoAFechaEspecifica(LocalDateTime diaEspecifico) { + LocalDateTime proximoEvento; + proximoEvento = this.frecuencia.proximoEventoMasCercanoAFechaEspecifica(this.arranquePrincipio, diaEspecifico); + return proximoEvento; + } + public void actualizarEvento(){ + if (LocalDateTime.now().isAfter(this.terminaActual)&& alarm.repiteLasAlarmas()){ + if (alarm.quedanAlarmas()){ + while (alarm.quedanAlarmas()){ + alarm.sonarAlarma(); + } + } + var fechaAnteriorInicio = this.arranqueActual; + var fechaAnteriorFinal = this.terminaActual; + this.arranqueActual = this.proximoEventoMasCercanoAFechaEspecifica(fechaAnteriorInicio); + this.terminaActual = this.proximoEventoMasCercanoAFechaEspecifica(fechaAnteriorFinal); + long diferenciaArranques = fechaAnteriorInicio.until(arranqueActual, ChronoUnit.DAYS); + alarm.actualizarAlarmas(diferenciaArranques); + } + } + public void setArranque(LocalDateTime arranque) { + this.arranquePrincipio = arranque; + this.arranqueActual = arranque; + } + public void setTermina(LocalDateTime termina) { + this.terminaPrincipio = termina; + this.terminaActual = termina; + } + public void setFrecuencia(Frecuencia frecuenciaNueva){ + frecuencia = frecuenciaNueva; + alarm.mantenerAlarmas(frecuenciaNueva != null); + } + //--------- Metodos --------- } diff --git a/src/main/java/Frecuencia.java b/src/main/java/Frecuencia.java new file mode 100644 index 0000000..d5e7159 --- /dev/null +++ b/src/main/java/Frecuencia.java @@ -0,0 +1,11 @@ +import java.time.LocalDateTime; +/** + * Frecuencia + */ +public interface Frecuencia{ + + boolean dadoComienzoCaeElDia(LocalDateTime inicioEvento, LocalDateTime diaEspecifico); + + LocalDateTime proximoEventoMasCercanoAFechaEspecifica(LocalDateTime inicioEvento, LocalDateTime diaEspecifico); + +} diff --git a/src/main/java/FrecuenciaDiaria.java b/src/main/java/FrecuenciaDiaria.java new file mode 100644 index 0000000..411fafd --- /dev/null +++ b/src/main/java/FrecuenciaDiaria.java @@ -0,0 +1,59 @@ +import java.time.temporal.ChronoUnit; //Libreria para formatear dias en LocalDateTime +import java.time.LocalDateTime; +import java.lang.Math; +/** + * Frecuencia + */ +public class FrecuenciaDiaria implements Frecuencia{ + + private int cadaCuantosDias; //Cada 3 dias, cada 5 dias + private Repeticion repeticion; + + public FrecuenciaDiaria(int cadaCuantosDias, Repeticion repeticion){ + this.cadaCuantosDias = cadaCuantosDias; + this.repeticion = repeticion; + + } + + // Dado un dia de comienzo y un dia en especifico, te dice si hay manera + // de que la repeticion haga que "caiga" en ese dia + // Ej: Si tenes repeticion cada 2 dias, tu comienzo es el 10 y tu fin el 12, + // devuelve True. Si fuese cada 3 dias y le pasas los mismos dias devuelve False + @Override + public boolean dadoComienzoCaeElDia(LocalDateTime fechaComienzo, LocalDateTime diaEspecifico){ + if (this.repeticion.estaDentroDeRepeticiones(diaEspecifico) == false) { + return false; //Si cae DESPUES del ultimo dia, entonces ni nos + //molestamos en calcular si la frecuencia hace + //que caiga el dia que me piden + } + + //Se fija cuantos dias hay hasta el dia pasado como argumento + long cantDiasHastaDiaPedido = fechaComienzo.until(diaEspecifico, ChronoUnit.DAYS); + + //True: El evento tiene una "aparicion" ese dia. False: no. + boolean eventoCaeElDiaPedidio = (cantDiasHastaDiaPedido % this.cadaCuantosDias == 0); + return eventoCaeElDiaPedidio; + } + + @Override + public LocalDateTime proximoEventoMasCercanoAFechaEspecifica(LocalDateTime inicioEvento, LocalDateTime diaEspecifico) { + if (this.repeticion.estaDentroDeRepeticiones(diaEspecifico) == false) { + return diaEspecifico; //Si cae DESPUES del ultimo dia, + //devolvevemos el dia pedido + } + + //Se fija cuantos dias hay hasta el dia pasado como argumento + long cantDiasHastaDiaPedido = inicioEvento.until(diaEspecifico, ChronoUnit.DAYS); + + //Esta funcion me devuelve la division redondeada para arriba. + //Esto nos sirve para calcular la cantidad de repeticiones (pasandose, + //dado el caso) que necesitamos para hallar el evento mas proximo + //Funcion sacada de: https://stackoverflow.com/a/17149572/13683575 + int cantidadRepsHastaProxEvento = (int) Math.ceil((double)cantDiasHastaDiaPedido / this.cadaCuantosDias); + + LocalDateTime proximoEvento = inicioEvento.plusDays(cantidadRepsHastaProxEvento * this.cadaCuantosDias); + + return proximoEvento; + } + +} diff --git a/src/main/java/FrecuenciaSemanal.java b/src/main/java/FrecuenciaSemanal.java new file mode 100644 index 0000000..2b41e20 --- /dev/null +++ b/src/main/java/FrecuenciaSemanal.java @@ -0,0 +1,69 @@ +import java.time.LocalDateTime; +import java.time.DayOfWeek; +import java.util.Arrays; + + +/** + * FrecuenciaSemanal + */ +public class FrecuenciaSemanal implements Frecuencia { + + private DayOfWeek[] diasDeLaSemana; //arrays de dias de la semana en ingles. + //PRECONDICION: Estan en orden y el + //primer dia que aparece es el mismo + //dia que el comienzo del evento + private Repeticion repeticion; + + public FrecuenciaSemanal(DayOfWeek[] diasDeLaSemana, Repeticion repeticion){ + this.diasDeLaSemana = diasDeLaSemana; + this.repeticion = repeticion; + } + + + public boolean dadoComienzoCaeElDia(LocalDateTime fechaComienzo, LocalDateTime diaEspecifico){ + if (this.repeticion.estaDentroDeRepeticiones(diaEspecifico) == false) { + return false; //Si cae DESPUES del ultimo dia, entonces ni nos + //molestamos en calcular si la frecuencia hace + //que caiga el dia que me piden + } + + + + //Averiguamos el dia de la semana del evento que me piden + DayOfWeek diasDeLaSemanaDelDiaEspecifico = diaEspecifico.getDayOfWeek(); + + //Nos fijamos si el dia de la semana del dia que que me piden esta + //en mi lista original + boolean estaEnElDiaDeLaSemana = Arrays.asList(this.diasDeLaSemana).contains(diasDeLaSemanaDelDiaEspecifico); + + return estaEnElDiaDeLaSemana; + } + + @Override + public LocalDateTime proximoEventoMasCercanoAFechaEspecifica(LocalDateTime inicioEvento, LocalDateTime diaEspecifico) { + if (this.repeticion.estaDentroDeRepeticiones(diaEspecifico) == false) { + return diaEspecifico; //Si cae DESPUES del ultimo dia, + //devolvevemos el dia pedido + } + + + LocalDateTime proximoEvento = diaEspecifico; + //7 hardcodeado porque en 7 dias ya ves todos los dias de la semana + for (int i = 0; i <= 7; i++) { + proximoEvento = diaEspecifico.plusDays(i); + + //El primer evento que cumpla la siguiente condicion es el evento + //mas proximo al dia al pedido. Como i arranca en 0, incluye al + //dia mismo. Este if SI O SI tiene que cumplirse, porque abarca los + //7 dias de la semana. + boolean proxEventoCaeEnLaSemana = Arrays.asList(this.diasDeLaSemana).contains(proximoEvento.getDayOfWeek()); + if (proxEventoCaeEnLaSemana == true) { + break; + } + } + + return proximoEvento; + } + + +} diff --git a/src/main/java/Main.java b/src/main/java/Main.java deleted file mode 100644 index b404450..0000000 --- a/src/main/java/Main.java +++ /dev/null @@ -1,16 +0,0 @@ -// import Calendario; - -public class Main { - public static void main(String[] args) { - // var tarea = new Tarea("Esto es una tarea","descripcion",false); - // var evento = new Tarea("Esto es un evento","descripcion",false); - - // Actividad[] array = new Actividad[2]; - // array[0] = tarea; - // array[1] = evento; - - // var cal = new Calendario("Nombre",array); - // System.out.println(cal.tituloPrimeraActividad()); - // System.out.println(cal.tituloSegundaActividad()); - } -} diff --git a/src/main/java/PlazoAnterior.java b/src/main/java/PlazoAnterior.java new file mode 100644 index 0000000..5383086 --- /dev/null +++ b/src/main/java/PlazoAnterior.java @@ -0,0 +1,28 @@ +import java.time.Duration; + +public enum PlazoAnterior { + DIAANTES("1 Dia Antes",Duration.ofDays(1L)), + HORAANTES("1 Hora Antes",Duration.ofHours(1L)), + MEDIAHORAANTES("30 Minutos Antes",Duration.ofMinutes(30L)), + QUINCEMINUTOSANTES("15 Minutos Antes",Duration.ofMinutes(15L)), + DIEZMINUTOSANTES("10 Minutos Antes",Duration.ofMinutes(10L)), + CINCOMINUTOSANTES("5 Minutos Antes",Duration.ofMinutes(5L)), + ; + private final String horarios; + private final Duration tiempo; + PlazoAnterior(String s,Duration t) { + horarios = s; + tiempo = t; + } + public Duration elHorarioEstablecido(){ + return tiempo; + } + public static PlazoAnterior compararHorariosDescriptos(String s){ + for (PlazoAnterior p: PlazoAnterior.values()){ + if (s.equals(p.horarios)){ + return p; + } + } + return null; + } +} diff --git a/src/main/java/Repeticion.java b/src/main/java/Repeticion.java new file mode 100644 index 0000000..0263e8f --- /dev/null +++ b/src/main/java/Repeticion.java @@ -0,0 +1,9 @@ +import java.time.LocalDateTime; +/** + * Repeticion + */ +public interface Repeticion { + + public boolean estaDentroDeRepeticiones(LocalDateTime fechaPedida); + +} diff --git a/src/main/java/RepeticionCantVeces.java b/src/main/java/RepeticionCantVeces.java new file mode 100644 index 0000000..3277e7a --- /dev/null +++ b/src/main/java/RepeticionCantVeces.java @@ -0,0 +1,69 @@ +import java.time.LocalDateTime; +import java.time.DayOfWeek; +/** + * RepeticionCantVeces + */ +public class RepeticionCantVeces implements Repeticion{ + private LocalDateTime fechaFinRepeticion; + + //No estamos totalmente contentos con la presencia de dos constructores + //distintos, sin embargo, fue la mejor manera que se nos ocurrio de poder + //encapsular dos casos distinto en 1 + public RepeticionCantVeces(int cantidadDeRepeticionesMaximas, int cadaCuantosDias, LocalDateTime fechaComienzo) { + //Esto nos da la cantidad de dias extra para llegar al ultimo dia + //Le restamos uno a cantidadDeRepeticionesMaximas porque el dia en el + //que estamos cuenta como una repeticion + int cantidadDeDiasASumar = cadaCuantosDias * (cantidadDeRepeticionesMaximas - 1); + + //Le sumamos esos dias a la fecha que nos pasaron + LocalDateTime fechaFinal = fechaComienzo.plusDays(cantidadDeDiasASumar); + + this.fechaFinRepeticion = fechaFinal; + } + + public RepeticionCantVeces(int cantidadDeRepeticionesMaximas, LocalDateTime fechaComienzo, DayOfWeek[] diasDeLaSemana) { + //La idea de este for loop es que te diga en que dia DE LA SEMANA cae + //el ultimo dia + int diaDeLaSemana = -1; //Arranca en -1 porque lo primero que hace es + //sumar, y tiene que arrancar siendo 0 + int cantidadDeRepeticionesSemanales = 0; + for (int i = 0; i < cantidadDeRepeticionesMaximas; i ++) { + //Cuando esto se cumple, significa que dio una vuelta completa a la + //cantidad de dias. Le sumo un dia porque el if "le tiene que ganar" + //al for en la siguiente iteracion + + diaDeLaSemana++; + if (diaDeLaSemana == diasDeLaSemana.length ) { + diaDeLaSemana = 0; + cantidadDeRepeticionesSemanales++; + } + } + //TODO: Esto de aca arriba tal vez se puede hacer con la funcion modulo + //No estamos seguro si es el caso. + + LocalDateTime offsetDiaDeLaSemana = fechaComienzo; + DayOfWeek diaDeLaSemanaDeInicio = diasDeLaSemana[diaDeLaSemana]; + + //Cuando estos dos sean iguales significa que llegamos al dia mas + //proximo con el dia de la semana que necesitamos + while (offsetDiaDeLaSemana.getDayOfWeek() != diaDeLaSemanaDeInicio) { + offsetDiaDeLaSemana = offsetDiaDeLaSemana.plusDays(1); + } + + + //7 Harcodeado porque hay 7 dias entre dos fechas con el mismo dia de + //la semana (ej: 7 dias entre el martes 4 y martes 11) + LocalDateTime fechaFinal = offsetDiaDeLaSemana.plusDays(cantidadDeRepeticionesSemanales * 7); + + this.fechaFinRepeticion = fechaFinal; + } + + @Override + public boolean estaDentroDeRepeticiones(LocalDateTime fechaPedida) { + boolean estaDespuesDelLimite = fechaPedida.isBefore(this.fechaFinRepeticion); + boolean esJustoElLimite = fechaPedida.isEqual(this.fechaFinRepeticion); + boolean estaDentro = (estaDespuesDelLimite || esJustoElLimite); + return estaDentro; + } + +} diff --git a/src/main/java/RepeticionFecha.java b/src/main/java/RepeticionFecha.java new file mode 100644 index 0000000..a946d60 --- /dev/null +++ b/src/main/java/RepeticionFecha.java @@ -0,0 +1,20 @@ +import java.time.LocalDateTime; +/** + * RepeticionFecha + */ +public class RepeticionFecha implements Repeticion{ + private LocalDateTime fechaFinRepeticion; + + public RepeticionFecha(LocalDateTime fechaFinRepeticion) { + this.fechaFinRepeticion = fechaFinRepeticion; + } + + @Override + public boolean estaDentroDeRepeticiones(LocalDateTime fechaPedida) { + boolean estaDespuesDelLimite = fechaPedida.isBefore(this.fechaFinRepeticion); + boolean esJustoElLimite = fechaPedida.isEqual(this.fechaFinRepeticion); + boolean estaDentro = (estaDespuesDelLimite || esJustoElLimite); + return estaDentro; + } + +} diff --git a/src/main/java/RepeticionInfinita.java b/src/main/java/RepeticionInfinita.java new file mode 100644 index 0000000..ce70765 --- /dev/null +++ b/src/main/java/RepeticionInfinita.java @@ -0,0 +1,14 @@ +import java.time.LocalDateTime; +/** + * RepeticionInfinita + */ +public class RepeticionInfinita implements Repeticion{ + + public RepeticionInfinita() { + } + + @Override + public boolean estaDentroDeRepeticiones(LocalDateTime fechaPedida) { + return true; + } +} diff --git a/src/main/java/Tarea.java b/src/main/java/Tarea.java index 55eaa3c..c3de2b7 100644 --- a/src/main/java/Tarea.java +++ b/src/main/java/Tarea.java @@ -1,48 +1,45 @@ import java.time.LocalDateTime; -import java.util.ArrayList; public class Tarea extends Activities { //--------- Atributos --------- - private final LocalDateTime termina; + private LocalDateTime termina; private boolean estaCompletada; //--------- Atributos --------- //--------- Constructores --------- - public Tarea(String name, String description, ArrayList alarm, boolean isComplete, LocalDateTime termina) { - super(name, description, alarm, isComplete); + /* + * public Tarea(LocalDateTime termina) { this.termina = termina; } - - public Tarea(String name, String description, boolean isComplete, LocalDateTime termina) { - super(name, description, isComplete); + */ + public Tarea(LocalDateTime termina) { + super(); this.termina = termina; + estaCompletada = false; } //--------- Constructores --------- //--------- Metodos --------- - @Override - public tipo type() { - return tipo.TAREA; - } - + public boolean estaCompleta(){ return this.estaCompletada; } - - public void marcarCompleta(){ this.estaCompletada = !this.estaCompletada; } - @Override public LocalDateTime cuandoTermina() { return termina; } - @Override public LocalDateTime cuandoEmpieza() { return this.cuandoTermina(); } + public void setTermina(LocalDateTime termina) { + this.termina = termina; + } + + //--------- Metodos --------- } diff --git a/src/test/java/AlarmasTest.java b/src/test/java/AlarmasTest.java new file mode 100644 index 0000000..033a958 --- /dev/null +++ b/src/test/java/AlarmasTest.java @@ -0,0 +1,278 @@ +import org.junit.Test; +import java.time.LocalDateTime; +import java.util.ArrayList; + +import static org.junit.Assert.*; + +public class AlarmasTest { + @Test + public void CrearAlarmaVacia() { + Alarmas a1 = new Alarmas(); + Alarmas a2 = new Alarmas(true); + + assertFalse(a1.existeAlarma(null)); + assertFalse(a1.repiteLasAlarmas()); + assertFalse(a1.quedanAlarmas()); + assertNull(a1.primerAlarmaASonar()); + assertEquals(0,a1.size()); + + assertFalse(a2.existeAlarma(null)); + assertTrue(a2.repiteLasAlarmas()); + assertFalse(a2.quedanAlarmas()); + assertNull(a2.primerAlarmaASonar()); + assertEquals(0,a2.size()); + } + @Test + public void AlarmaConNull() { + Alarmas a1 = new Alarmas(); + Alarmas a2 = new Alarmas(true); + + a1.agregarAlarma((LocalDateTime) null); + assertFalse(a1.existeAlarma(null)); + assertFalse(a1.quedanAlarmas()); + assertNull(a1.primerAlarmaASonar()); + assertFalse(a1.repiteLasAlarmas()); + a1.eliminarAlarma(null); + a1.sonarAlarma(); + + a2.agregarAlarma((LocalDateTime) null); + assertTrue(a2.repiteLasAlarmas()); + assertFalse(a2.existeAlarma(null)); + assertFalse(a2.quedanAlarmas()); + assertNull(a2.primerAlarmaASonar()); + a2.eliminarAlarma(null); + a2.sonarAlarma(); + } + @Test + public void quedanAlarmas() { + Alarmas a1 = new Alarmas(); + LocalDateTime agregar; + ArrayList array = new ArrayList<>(); + + assertFalse(a1.quedanAlarmas()); + a1.agregarAlarma(array); + assertFalse(a1.quedanAlarmas()); + for (int i = 0 ; i < 1000 ; i++ ){ + agregar = LocalDateTime.of(3022-i,4,24,23,59); + a1.agregarAlarma(agregar); + assertTrue(a1.quedanAlarmas()); + } + for (int j = 0 ; j < 1000 ; j++ ){ + agregar = LocalDateTime.of(2023+j,4,24,23,59); + assertTrue(a1.quedanAlarmas()); + a1.eliminarAlarma(agregar); + } + } + @Test + public void primerAlarmaYSonarAlarma() { + Alarmas a1 = new Alarmas(); + LocalDateTime agregar; + ArrayList array = new ArrayList<>(); + for (int i = 12 ; i > 0 ; i-- ){ + agregar = LocalDateTime.of(i,i,i,i,i); + array.add(agregar); + } + a1.agregarAlarma(array); + for (int i = 1 ; i < 13 ; i++ ){ + agregar = LocalDateTime.of(i,i,i,i,i); + assertEquals(agregar,a1.primerAlarmaASonar()); + a1.sonarAlarma(); + } + } + @Test + public void AgregarUnaAlarmaPruebaCompleta() { + Alarmas a1 = new Alarmas(); + Alarmas a2 = new Alarmas(true); + LocalDateTime agregar = LocalDateTime.of(2023,4,24,23,59); + + a1.agregarAlarma(agregar); + assertFalse(a1.repiteLasAlarmas()); + assertTrue(a1.existeAlarma(agregar)); + assertTrue(a1.quedanAlarmas()); + assertEquals(agregar,a1.primerAlarmaASonar()); + a1.eliminarAlarma(agregar); + assertFalse(a1.existeAlarma(agregar)); + assertFalse(a1.quedanAlarmas()); + assertNull(a1.primerAlarmaASonar()); + a1.agregarAlarma(agregar); + a1.sonarAlarma(); + assertFalse(a1.existeAlarma(agregar)); + assertFalse(a1.quedanAlarmas()); + assertNull(a1.primerAlarmaASonar()); + + a2.agregarAlarma(agregar); + assertTrue(a2.repiteLasAlarmas()); + assertTrue(a2.existeAlarma(agregar)); + assertTrue(a2.quedanAlarmas()); + assertEquals(agregar,a2.primerAlarmaASonar()); + a2.eliminarAlarma(agregar); + assertFalse(a2.existeAlarma(agregar)); + assertFalse(a2.quedanAlarmas()); + assertNull(a2.primerAlarmaASonar()); + a2.agregarAlarma(agregar); + a2.sonarAlarma(); + assertFalse(a2.existeAlarma(agregar)); + assertFalse(a2.quedanAlarmas()); + assertNull(a2.primerAlarmaASonar()); + } + @Test + public void AgregarArrayVacio() { + Alarmas a1 = new Alarmas(); + Alarmas a2 = new Alarmas(true); + ArrayList array = new ArrayList<>(); + + a1.agregarAlarma(array); + a2.agregarAlarma(array); + assertEquals(0,a1.size()); + assertEquals(0,a2.size()); + assertFalse(a1.existeAlarma(null)); + assertFalse(a2.existeAlarma(null)); + assertFalse(a1.quedanAlarmas()); + assertFalse(a2.quedanAlarmas()); + assertNull(a1.primerAlarmaASonar()); + assertNull(a2.primerAlarmaASonar()); + } + @Test + public void AgregarArrayAlarmasCompleto() { + Alarmas a1 = new Alarmas(); + Alarmas a2 = new Alarmas(true); + ArrayList array = new ArrayList<>(); + LocalDateTime agregar; + + for (int i = 0 ; i < 1000 ; i++ ){ + agregar = LocalDateTime.of(2023+i,4,24,23,59); + array.add(agregar); + } + a1.agregarAlarma(array); + a2.agregarAlarma(array); + assertEquals(1000,a1.size()); + assertEquals(1000,a2.size()); + assertTrue(a1.existeAlarma(LocalDateTime.of(2023,4,24,23,59))); + assertTrue(a2.existeAlarma(LocalDateTime.of(2023,4,24,23,59))); + assertTrue(a1.quedanAlarmas()); + assertTrue(a2.quedanAlarmas()); + assertEquals(LocalDateTime.of(2023,4,24,23,59),a1.primerAlarmaASonar()); + assertEquals(LocalDateTime.of(2023,4,24,23,59),a2.primerAlarmaASonar()); + } + @Test + public void AgregarAlarmasIdenticas() { + Alarmas a1 = new Alarmas(); + Alarmas a2 = new Alarmas(true); + LocalDateTime agregar = LocalDateTime.of(2023,4,24,23,59); + for (int i = 0 ; i < 100 ; i++ ){ + a1.agregarAlarma(agregar); + assertEquals(1,a1.size()); + + a2.agregarAlarma(agregar); + assertEquals(1,a2.size()); + } + } + @Test + public void AgregarMuchasAlarmasPruebaCompleta() { + Alarmas a1 = new Alarmas(); + Alarmas a2 = new Alarmas(true); + LocalDateTime agregar; + for (int i = 0 ; i < 1000 ; i++ ){ + agregar = LocalDateTime.of(3022-i,4,24,23,59); + + assertEquals(i,a1.size()); + a1.agregarAlarma(agregar); + assertEquals(i+1,a1.size()); + assertTrue(a1.existeAlarma(agregar)); + assertTrue(a1.quedanAlarmas()); + assertEquals(agregar,a1.primerAlarmaASonar()); + + a2.agregarAlarma(agregar); + assertTrue(a2.existeAlarma(agregar)); + assertTrue(a2.quedanAlarmas()); + assertEquals(agregar,a2.primerAlarmaASonar()); + } + for (int j = 0 ; j < 1000 ; j++ ){ + agregar = LocalDateTime.of(2023+j,4,24,23,59); + + assertEquals(agregar,a1.primerAlarmaASonar()); + assertTrue(a1.existeAlarma(agregar)); + assertEquals(1000-j,a1.size()); + a1.sonarAlarma(); + assertEquals(999-j,a1.size()); + assertFalse(a1.existeAlarma(agregar)); + a1.agregarAlarma(agregar); + a1.eliminarAlarma(agregar); + assertEquals(999-j,a1.size()); + assertFalse(a1.existeAlarma(agregar)); + + assertEquals(agregar,a2.primerAlarmaASonar()); + assertTrue(a2.existeAlarma(agregar)); + assertEquals(1000-j,a2.size()); + a2.sonarAlarma(); + assertEquals(999-j,a2.size()); + assertFalse(a2.existeAlarma(agregar)); + a2.agregarAlarma(agregar); + a2.eliminarAlarma(agregar); + assertEquals(999-j,a2.size()); + assertFalse(a2.existeAlarma(agregar)); + + } + } + @Test + public void actualizarAlarmaTest() { + Alarmas a1 = new Alarmas(true); + LocalDateTime diaDelEvento = LocalDateTime.of(2023,4,4,23,1); + LocalDateTime agregar; + + a1.actualizarAlarmas(10L);//no hace nada porque no hay alarmas + + for (int i = 0;i<23;i++){ + agregar = LocalDateTime.of(2023,4,4,1+i,0); + a1.agregarAlarma(agregar); + } + + a1.actualizarAlarmas(10L);//no hace nada porque no paso el evento(No sonaron todas las alarmas) + + for (int i = 0;i<23;i++){ + agregar = LocalDateTime.of(2023,4,4,1+i,0); + LocalDateTime primeraAlarma = a1.primerAlarmaASonar(); + a1.sonarAlarma(); + assertEquals(agregar,primeraAlarma); + assertTrue(diaDelEvento.isAfter(primeraAlarma)); + } + + //Hora de actualizarlas a una fecha (Ya no hay más alarmas y se terminó el evento) + + diaDelEvento = LocalDateTime.of(2023,4,8,23,1);//el evento se repite el día 8 ahora + a1.actualizarAlarmas(4L); + + for (int i = 0;i<23;i++){ + agregar = LocalDateTime.of(2023,4,8,1+i,0); + LocalDateTime primeraAlarma = a1.primerAlarmaASonar(); + a1.sonarAlarma(); + assertEquals(agregar,primeraAlarma); + assertTrue(diaDelEvento.isAfter(primeraAlarma)); + } + + //Hora de actualizarlas a una fecha (Ya no hay más alarmas y se terminó el evento) + diaDelEvento = LocalDateTime.of(2023,5,8,23,1);//el evento se repite el día 8 pero dentro de un mes ahora + a1.actualizarAlarmas(30L); + + for (int i = 0;i<23;i++){ + agregar = LocalDateTime.of(2023,5,8,1+i,0); + LocalDateTime primeraAlarma = a1.primerAlarmaASonar(); + a1.sonarAlarma(); + assertEquals(agregar,primeraAlarma); + assertTrue(diaDelEvento.isAfter(primeraAlarma)); + } + + //Hora de actualizarlas a una fecha (Ya no hay más alarmas y se terminó el evento) + diaDelEvento = LocalDateTime.of(2024,5,8,23,1);//el evento se repite el día 8 pero dentro de un AÑO ahora + a1.actualizarAlarmas(366L);//esta exactitud de cuando cae la calcula un módulo exportado + + for (int i = 0;i<23;i++){ + agregar = LocalDateTime.of(2024,5,8,1+i,0); + LocalDateTime primeraAlarma = a1.primerAlarmaASonar(); + a1.sonarAlarma(); + assertEquals(agregar,primeraAlarma); + assertTrue(diaDelEvento.isAfter(primeraAlarma)); + } + } + +} \ No newline at end of file diff --git a/src/test/java/CalendarioTest.java b/src/test/java/CalendarioTest.java index 64b2982..a242331 100644 --- a/src/test/java/CalendarioTest.java +++ b/src/test/java/CalendarioTest.java @@ -1,5 +1,8 @@ import org.junit.Test; +import java.time.LocalDateTime; +import java.util.ArrayList; + import static org.junit.Assert.*; /** * CalendarioTest @@ -7,29 +10,72 @@ public class CalendarioTest { @Test - public void creacionDeTareaSimpleDesdeCalendario() { + public void creacionDeCalendarioVacio() { + //arrange + Calendario calendario = new Calendario(); + + + assertNull(calendario.proximaAlarma()); + assertEquals(0, calendario.sonarAlarmas().size()); + calendario.modificarActividadAgregarAlarma(123,"1 Dia Antes"); + assertNull(calendario.proximaAlarma()); + assertEquals(0, calendario.sonarAlarmas().size()); + calendario.modificarActividadNombre(123,"Nombre1"); + calendario.eliminarEvento(123); + } + @Test + public void creacionDeTareaEnCalendario() { //arrange - Calendario calendarioDePrueba = new Calendario("Calendario de Prueba"); + Calendario calendarioDePrueba = new Calendario(); //act - //calendarioDePrueba.crearTarea("Nombre Tarea", "Descripcion Tarea", false); - ////assert - //assertEquals("Nombre Tarea", calendarioDePrueba.obtenerActividadPorIndice(0).getTitulo()); - //assertEquals("Descripcion Tarea", calendarioDePrueba.obtenerActividadPorIndice(0).getDescripcion()); - //assertEquals(false, calendarioDePrueba.obtenerActividadPorIndice(0).esDiaEntero()); + LocalDateTime termina = LocalDateTime.of(2002,1,1,0,0); + var indice = calendarioDePrueba.crearTarea(termina); + var tarea = calendarioDePrueba.obtenerTarea(indice); + + assertEquals("",tarea.getTitulo()); + assertEquals("",tarea.getDescripcion()); + assertFalse(tarea.esDiaEntero()); + assertFalse(tarea.estaCompleta()); + assertEquals(termina,tarea.cuandoEmpieza()); + calendarioDePrueba.modificarActividadNombre(indice, "Nombre Tarea"); + assertEquals("Nombre Tarea",tarea.getTitulo()); + calendarioDePrueba.modificarActividadDescripcion(indice, "Descripcion Tarea"); + assertEquals("Descripcion Tarea",tarea.getDescripcion()); + calendarioDePrueba.modificarActividadEsDiaEntero(indice, true); + assertTrue(tarea.esDiaEntero()); + calendarioDePrueba.modificarTareaCompletarODescompletar(indice); + assertTrue(tarea.estaCompleta()); + termina = LocalDateTime.of(2002,1,2,0,0); + calendarioDePrueba.modificarTareaPlazoTemporal(indice,termina); + assertEquals(termina,tarea.cuandoEmpieza()); + + } + @Test + public void creacionesDeAlarmasCalendario() { + Calendario calendarioDePrueba = new Calendario(); + LocalDateTime termina = LocalDateTime.of(2002,1,2,0,0); + var indice = calendarioDePrueba.crearTarea(termina); + var tarea = calendarioDePrueba.obtenerTarea(indice); + + calendarioDePrueba.modificarActividadEliminarAlarma(indice,"1 Dia Antes"); + calendarioDePrueba.modificarActividadEliminarAlarma(indice,termina); - //@Test - //public void marcarTareaComoCompleta(){ - // //arrange - // Calendario calendarioDePrueba = new Calendario("Calendario de Prueba"); + LocalDateTime alarm = LocalDateTime.of(2002,1,1,0,0); + ArrayList array = new ArrayList<>(); + for (int i = 1; i<23;i++){ + array.add(LocalDateTime.of(2002,1,1,i,0)); + } + calendarioDePrueba.modificarActividadAgregarAlarma(indice,"1 Hora Antes"); + calendarioDePrueba.modificarActividadAgregarAlarma(indice,alarm); + calendarioDePrueba.modificarActividadAgregarAlarma(indice,array); + for (int i = 0 ; i <= 23; i++){ + assertEquals(LocalDateTime.of(2002,1,1,i,0),calendarioDePrueba.proximaAlarma()); + var a = calendarioDePrueba.sonarAlarmas(); + assertEquals(tarea,a.remove(0)); - // //act - // calendarioDePrueba.crearTarea("Nombre Tarea", "Descripcion Tarea", false); - // calendarioDePrueba.obtenerActividadPorIndice(0).marcarTareaComoCompleta(); + } + } - // //assert - // assertEquals("Nombre Tarea", calendarioDePrueba.obtenerActividadPorIndice(0).getTitulo()); - // assertEquals(true, calendarioDePrueba.obtenerActividadPorIndice(0).estaCompleta()); - //} } diff --git a/src/test/java/EventoTest.java b/src/test/java/EventoTest.java index e76299d..58d8613 100644 --- a/src/test/java/EventoTest.java +++ b/src/test/java/EventoTest.java @@ -1,5 +1,172 @@ +import org.junit.Test; +import java.time.DayOfWeek; +import java.time.LocalDateTime; +import java.util.ArrayList; + import static org.junit.Assert.*; + public class EventoTest { + @Test + public void crearEventoVacio() { + var arranca = LocalDateTime.of(2023,12,8,0,0); + var termina = LocalDateTime.of(2023,12,9,0,0); + // var even1 = new Evento("","",null,false,arranca,termina,null); + var even1 = new Evento(arranca,termina); + + + assertEquals(arranca, even1.cuandoEmpieza()); + assertEquals(termina, even1.cuandoTermina()); + arranca = LocalDateTime.of(2023,12,9,0,0); + termina = LocalDateTime.of(2023,12,10,0,0); + even1.setArranque(arranca); + even1.setTermina(termina); + assertEquals(arranca, even1.cuandoEmpieza()); + assertEquals(termina, even1.cuandoTermina()); + assertNull(even1.ultimaAlarma()); + assertEquals("", even1.getDescripcion()); + assertEquals("", even1.getTitulo()); + assertFalse(even1.esDiaEntero()); + even1.setComplete(true); + even1.setName("Nombre1"); + even1.setDescription("Descripcion1"); + assertEquals("Descripcion1", even1.getDescripcion()); + assertEquals("Nombre1", even1.getTitulo()); + assertTrue(even1.esDiaEntero()); + } + @Test + public void creacionDeEventos() { + ArrayList alarmas = new ArrayList<>(); + alarmas.add(LocalDateTime.of(2023,1,1,0,0)); + alarmas.add(LocalDateTime.of(2023,5,24,11,30)); + alarmas.add(LocalDateTime.of(2023,3,12,18,0)); + alarmas.add(LocalDateTime.of(2023,9,12,23,30)); + alarmas.add(LocalDateTime.of(2023,1,1,0,0)); + var arranca = LocalDateTime.of(2023,12,8,0,0); + var termina = LocalDateTime.of(2023,12,8,0,0); + + + // TODO: Sacar comentario de la creacio nde la version anterior + // var even1 = new Evento("Nombre1","Descripcion1",alarmas,true,arranca,termina,null); + var even1 = new Evento(arranca,termina); + even1.setName("Nombre1"); + even1.setDescription("Descripcion1"); + even1.agregarAlarmas(alarmas); + even1.setComplete(true); + + // TODO: Sacar comentario de la creacio nde la version anterior + // var even2 = new Evento("Nombre2","Descripcion2",null,false,arranca,termina,null); + var even2 = new Evento(arranca,termina); + even2.setName("Nombre2"); + even2.setDescription("Descripcion2"); + even2.setComplete(false); + + + assertEquals("Nombre1", even1.getTitulo()); + assertEquals("Descripcion1", even1.getDescripcion()); + assertTrue(even1.esDiaEntero()); + assertEquals(arranca, even1.cuandoEmpieza()); + assertEquals(termina, even1.cuandoTermina()); + assertEquals("Nombre2", even2.getTitulo()); + assertEquals("Descripcion2", even2.getDescripcion()); + assertFalse(even2.esDiaEntero()); + assertEquals(arranca, even2.cuandoEmpieza()); + assertEquals(termina, even2.cuandoTermina()); + } + @Test + public void CreacionEventosVariado() { + } + @Test + public void eventoCaeDiaPedido(){ + + /*arrange + //ArrayList alarmas = new ArrayList(); + //of(int year, int month, int dayOfMonth, int hour, int minute) + // Evento eventoDePrueba = new Evento("Evento de prueba", "Descripcion de prueba", alarmas, false, LocalDateTime.of(2023, 4, 10, 7, 45, 55), LocalDateTime.of(2024, 3, 10, 7, 45, 55)); + + //assert + // assertEquals(true, eventoDePrueba.caeElDia(LocalDateTime.of(2023, 4, 22, 7, 45, 55))); + // assertEquals(false, eventoDePrueba.caeElDia(LocalDateTime.of(2023, 4, 21, 7, 45, 55))); + // assertEquals(false, eventoDePrueba.caeElDia(LocalDateTime.of(2023, 4, 20, 7, 45, 55)));*/ + } + @Test + public void cuandoEmpiezaTest(){ + } + @Test + public void cuandoTerminaTest(){ + } + @Test + public void UltimaAlarmaYSonarUltimaAlarma(){ + var arranca = LocalDateTime.of(2023,12,8,0,0); + var termina = LocalDateTime.of(2023,12,8,0,0); + var even1 = new Evento(arranca,termina); + var even2 = new Evento(arranca,termina); + + var hascodeEven1 =even1.hashCode(); + var hascodeEven2 =even2.hashCode(); + assertNotEquals(hascodeEven1,hascodeEven2 ); + even1.setName("Distinto 1"); + assertEquals(hascodeEven1,even1.hashCode() ); + // https://stackoverflow.com/a/32450295/13683575 + } + + @Test + public void testDeCaeElDia(){ + var arranca = LocalDateTime.of(2023, 4,4,5,0); + var termina = LocalDateTime.of(2023, 4,4,12,0); + + var even1 = new Evento(arranca, termina); + + int cadaCuantosDias = 2; + var repeticionInfinita = new RepeticionInfinita(); + FrecuenciaDiaria frecuenciaDiaria = new FrecuenciaDiaria(cadaCuantosDias, repeticionInfinita); + + even1.setFrecuencia(frecuenciaDiaria); + var fechaQueCae = LocalDateTime.of(2023, 4, 12, 5, 0); + var fechaQueNoCae = LocalDateTime.of(2023, 4, 13, 5, 0); + + assertEquals(true, even1.caeElDia(fechaQueCae)); + assertEquals(false, even1.caeElDia(fechaQueNoCae)); + } + + @Test + public void testDeSetFrecuencia(){ + var arranca = LocalDateTime.of(2023, 4,4,5,0); + var termina = LocalDateTime.of(2023, 4,4,12,0); + + var even1 = new Evento(arranca, termina); + + int cadaCuantosDias = 2; + var repeticionInfinita = new RepeticionInfinita(); + FrecuenciaDiaria frecuenciaDiaria = new FrecuenciaDiaria(cadaCuantosDias, repeticionInfinita); + even1.setFrecuencia(frecuenciaDiaria); + + DayOfWeek[] diasDeLaSemana = {DayOfWeek.TUESDAY, DayOfWeek.THURSDAY}; + FrecuenciaSemanal frecuenciaSemanal = new FrecuenciaSemanal(diasDeLaSemana, repeticionInfinita); + even1.setFrecuencia(frecuenciaSemanal);//Actualizo la frecuencia + + var fechaQueCae = LocalDateTime.of(2023, 4, 11, 5, 0); + var fechaQueNoCae = LocalDateTime.of(2023, 4, 12, 5, 0); + + assertEquals(true, even1.caeElDia(fechaQueCae)); + assertEquals(false, even1.caeElDia(fechaQueNoCae)); + } + + @Test + public void testProximoEventoMasCercanoFrecuenciaDiaria(){ + int cadaCuantosdias = 2; + var arranca = LocalDateTime.of(2023, 4, 4, 0, 0, 0); + var termina = LocalDateTime.of(2023, 4, 13, 0, 0, 0); + var fechaMasCercana = LocalDateTime.of(2023, 4, 14, 0, 0, 0); + + var repeticionInfinita = new RepeticionInfinita(); + var frecuenciadiaria = new FrecuenciaDiaria(cadaCuantosdias, repeticionInfinita); + //Copiar fechas de test de frecuencia + + var even1 = new Evento(arranca, termina); + even1.setFrecuencia(frecuenciadiaria); + + assertEquals(fechaMasCercana, even1.proximoEventoMasCercanoAFechaEspecifica(termina)); + } -} \ No newline at end of file +} diff --git a/src/test/java/FrecuenciaDiariaTest.java b/src/test/java/FrecuenciaDiariaTest.java new file mode 100644 index 0000000..34baa2d --- /dev/null +++ b/src/test/java/FrecuenciaDiariaTest.java @@ -0,0 +1,108 @@ +import java.time.LocalDateTime; +import org.junit.Test; +import static org.junit.Assert.*; +/** + * FrecuenciaDiariaTest + */ +public class FrecuenciaDiariaTest { + + @Test + public void calcularProximoEventoMasCercanoAFecha(){ + int cadaCuantosDias = 2; + + LocalDateTime fechaComienzo = LocalDateTime.of(2023, 4, 4, 7, 45, 55); + LocalDateTime fechaFinal = LocalDateTime.of(2023, 4, 13, 7, 45, 55); + RepeticionInfinita repeticionInfinita = new RepeticionInfinita(); + + //Le pasamos repeticionInfinita de constructor ya que solo queremos + //testear la frecuencia + FrecuenciaDiaria frecuenciaDiaria = new FrecuenciaDiaria(cadaCuantosDias, repeticionInfinita); + // Esta fecha es la que cae si haces la cuenta manualmente + // (Sumarle 2 dias 4 veces a fechaComienzoRepeticion) + // LocalDateTime fechaFinRepeticion = LocalDateTime.of(2023, 4, 10, 7, 45, 55); + LocalDateTime fechaMasCercana = LocalDateTime.of(2023, 4, 14, 7, 45, 55); + + //assert + assertEquals(fechaMasCercana, frecuenciaDiaria.proximoEventoMasCercanoAFechaEspecifica(fechaComienzo, fechaFinal)); + } + + @Test + public void calcularProximoEventoMasCercanoAFechaMismoDia(){ + int cadaCuantosDias = 2; + + LocalDateTime fechaComienzo = LocalDateTime.of(2023, 4, 5, 7, 45, 55); + LocalDateTime fechaFinal = LocalDateTime.of(2023, 4, 13, 7, 45, 55); + RepeticionInfinita repeticionInfinita = new RepeticionInfinita(); + + //Le pasamos repeticionInfinita de constructor ya que solo queremos + //testear la frecuencia + FrecuenciaDiaria frecuenciaDiaria = new FrecuenciaDiaria(cadaCuantosDias, repeticionInfinita); + LocalDateTime fechaMasCercana = LocalDateTime.of(2023, 4, 13, 7, 45, 55); + + //assert + assertEquals(fechaMasCercana, frecuenciaDiaria.proximoEventoMasCercanoAFechaEspecifica(fechaComienzo, fechaFinal)); + } + + @Test + public void dadoComienzoCaeElDia(){ + int cadaCuantosDias = 2; + + LocalDateTime fechaComienzo = LocalDateTime.of(2023, 4, 4, 7, 45, 55); + LocalDateTime fechaATestearFalso = LocalDateTime.of(2023, 4, 13, 7, 45, 55); + LocalDateTime fechaATestearPositivo = LocalDateTime.of(2023, 4, 12, 7, 45, 55); + RepeticionInfinita repeticionInfinita = new RepeticionInfinita(); + + //Le pasamos repeticionInfinita de constructor ya que solo queremos + //testear la frecuencia + FrecuenciaDiaria frecuenciaDiaria = new FrecuenciaDiaria(cadaCuantosDias, repeticionInfinita); + assertEquals(true, frecuenciaDiaria.dadoComienzoCaeElDia(fechaComienzo, fechaATestearPositivo)); + assertEquals(false, frecuenciaDiaria.dadoComienzoCaeElDia(fechaComienzo, fechaATestearFalso)); + } + + @Test + public void testFrecuenciaMensualCaeElDia(){ + int cadaCuantosdias = 30; + var arranca = LocalDateTime.of(2023, 4, 4, 0, 0, 0); + var fechaAConfirmar = LocalDateTime.of(2023, 5, 4, 0, 0, 0); + var repeticionInfinita = new RepeticionInfinita(); + var frecuenciadiaria = new FrecuenciaDiaria(cadaCuantosdias, repeticionInfinita); + + assertEquals(true, frecuenciadiaria.dadoComienzoCaeElDia(arranca, fechaAConfirmar)); + } + + @Test + public void testFrecuenciaMensualMasCercano(){ + int cadaCuantosdias = 30; + var arranca = LocalDateTime.of(2023, 4, 4, 0, 0, 0); + var fechaObjetivo= LocalDateTime.of(2023, 5, 3, 0, 0, 0); + var fechaMasCercana= LocalDateTime.of(2023, 5, 4, 0, 0, 0); + var repeticionInfinita = new RepeticionInfinita(); + var frecuenciadiaria = new FrecuenciaDiaria(cadaCuantosdias, repeticionInfinita); + + assertEquals(fechaMasCercana, frecuenciadiaria.proximoEventoMasCercanoAFechaEspecifica(arranca, fechaObjetivo)); + } + + @Test + public void testFrecuenciaAnualCaeElDia(){ + int cadaCuantosdias = 365; + var arranca = LocalDateTime.of(2023, 4, 4, 0, 0, 0); + var fechaAConfirmar = LocalDateTime.of(2024, 4, 3, 0, 0, 0); //Si se hace la cuenta manualmente este es el dia que cae + var repeticionInfinita = new RepeticionInfinita(); + var frecuenciadiaria = new FrecuenciaDiaria(cadaCuantosdias, repeticionInfinita); + + assertEquals(true, frecuenciadiaria.dadoComienzoCaeElDia(arranca, fechaAConfirmar)); + } + + @Test + public void testFrecuenciaAnualMasCercano(){ + int cadaCuantosdias = 365; + var arranca = LocalDateTime.of(2023, 4, 4, 0, 0, 0); + var fechaObjetivo= LocalDateTime.of(2024, 4, 2, 0, 0, 0); + var fechaMasCercana= LocalDateTime.of(2024, 4, 3, 0, 0, 0); + var repeticionInfinita = new RepeticionInfinita(); + var frecuenciadiaria = new FrecuenciaDiaria(cadaCuantosdias, repeticionInfinita); + + assertEquals(fechaMasCercana, frecuenciadiaria.proximoEventoMasCercanoAFechaEspecifica(arranca, fechaObjetivo)); + } + +} diff --git a/src/test/java/FrecuenciaSemanalTest.java b/src/test/java/FrecuenciaSemanalTest.java new file mode 100644 index 0000000..e5213a6 --- /dev/null +++ b/src/test/java/FrecuenciaSemanalTest.java @@ -0,0 +1,58 @@ +import java.time.DayOfWeek; +import java.time.LocalDateTime; +import org.junit.Test; +import static org.junit.Assert.*; +/** + * FrecuenciaSemanalTest + */ +public class FrecuenciaSemanalTest { + + @Test + public void calcularProximoEventoMasCercanoAFecha(){ + DayOfWeek[] diasDeLaSemana = {DayOfWeek.MONDAY, DayOfWeek.THURSDAY}; + + LocalDateTime fechaComienzo = LocalDateTime.of(2023, 4, 3, 7, 45, 55); + LocalDateTime fechaFinal = LocalDateTime.of(2023, 4, 11, 7, 45, 55); + RepeticionInfinita repeticionInfinita = new RepeticionInfinita(); + + FrecuenciaSemanal frecuenciaSemanal = new FrecuenciaSemanal(diasDeLaSemana, repeticionInfinita); + // Esta fecha es la que cae si haces la cuenta manualmente + LocalDateTime fechaMasCercana = LocalDateTime.of(2023, 4, 13, 7, 45, 55); + + assertEquals(fechaMasCercana, frecuenciaSemanal.proximoEventoMasCercanoAFechaEspecifica(fechaComienzo, fechaFinal)); + } + + @Test + public void calcularProximoEventoMasCercanoAFechaMismoDia(){ + DayOfWeek[] diasDeLaSemana = {DayOfWeek.MONDAY, DayOfWeek.THURSDAY}; + + LocalDateTime fechaComienzo = LocalDateTime.of(2023, 4, 3, 7, 45, 55); + LocalDateTime fechaFinal = LocalDateTime.of(2023, 4, 10, 7, 45, 55); + RepeticionInfinita repeticionInfinita = new RepeticionInfinita(); + + FrecuenciaSemanal frecuenciaSemanal = new FrecuenciaSemanal(diasDeLaSemana, repeticionInfinita); + LocalDateTime fechaMasCercana = LocalDateTime.of(2023, 4, 10, 7, 45, 55); + + assertEquals(fechaMasCercana, frecuenciaSemanal.proximoEventoMasCercanoAFechaEspecifica(fechaComienzo, fechaFinal)); + } + + @Test + public void dadoComienzoCaeElDia(){ + DayOfWeek[] diasDeLaSemana = {DayOfWeek.MONDAY, DayOfWeek.THURSDAY}; + + LocalDateTime fechaComienzo = LocalDateTime.of(2023, 3, 4, 7, 45, 55); + LocalDateTime fechaATestearFalso = LocalDateTime.of(2023, 4, 11, 7, 45, 55); + LocalDateTime fechaATestearPositivo = LocalDateTime.of(2023, 4, 10, 7, 45, 55); + LocalDateTime fechaATestearFalso2 = LocalDateTime.of(2023, 4, 14, 7, 45, 55); + LocalDateTime fechaATestearPositivo2 = LocalDateTime.of(2023, 4, 13, 7, 45, 55); + RepeticionInfinita repeticionInfinita = new RepeticionInfinita(); + FrecuenciaSemanal frecuenciaSemanal = new FrecuenciaSemanal(diasDeLaSemana, repeticionInfinita); + + assertEquals(true, frecuenciaSemanal.dadoComienzoCaeElDia(fechaComienzo, fechaATestearPositivo)); + assertEquals(false, frecuenciaSemanal.dadoComienzoCaeElDia(fechaComienzo, fechaATestearFalso)); + assertEquals(true, frecuenciaSemanal.dadoComienzoCaeElDia(fechaComienzo, fechaATestearPositivo2)); + assertEquals(false, frecuenciaSemanal.dadoComienzoCaeElDia(fechaComienzo, fechaATestearFalso2)); + } + + +} diff --git a/src/test/java/MainTest.java b/src/test/java/MainTest.java deleted file mode 100644 index 06aa4cf..0000000 --- a/src/test/java/MainTest.java +++ /dev/null @@ -1,10 +0,0 @@ -import org.junit.Test; - -import static org.junit.Assert.*; - -public class MainTest { - @Test - public void aseertTrue() { - assertTrue(true); - } -} diff --git a/src/test/java/PlazoAnteriorTest.java b/src/test/java/PlazoAnteriorTest.java new file mode 100644 index 0000000..98db3e5 --- /dev/null +++ b/src/test/java/PlazoAnteriorTest.java @@ -0,0 +1,36 @@ +import org.junit.Test; + +import java.time.Duration; + +import static org.junit.Assert.*; + +public class PlazoAnteriorTest { + + @Test + public void elHorarioEstablecido() { + Duration d1 = Duration.ofDays(1L); + Duration d2 = Duration.ofHours(1L); + Duration d3 = Duration.ofMinutes(30L); + Duration d4 = Duration.ofMinutes(15L); + Duration d5 = Duration.ofMinutes(10L); + Duration d6 = Duration.ofMinutes(5L); + + assertEquals(d1,PlazoAnterior.DIAANTES.elHorarioEstablecido()); + assertEquals(d2,PlazoAnterior.HORAANTES.elHorarioEstablecido()); + assertEquals(d3,PlazoAnterior.MEDIAHORAANTES.elHorarioEstablecido()); + assertEquals(d4,PlazoAnterior.QUINCEMINUTOSANTES.elHorarioEstablecido()); + assertEquals(d5,PlazoAnterior.DIEZMINUTOSANTES.elHorarioEstablecido()); + assertEquals(d6,PlazoAnterior.CINCOMINUTOSANTES.elHorarioEstablecido()); + } + + @Test + public void compararHorariosDescriptosTest() { + assertEquals(PlazoAnterior.DIAANTES,PlazoAnterior.compararHorariosDescriptos("1 Dia Antes")); + assertEquals(PlazoAnterior.HORAANTES,PlazoAnterior.compararHorariosDescriptos("1 Hora Antes")); + assertEquals(PlazoAnterior.MEDIAHORAANTES,PlazoAnterior.compararHorariosDescriptos("30 Minutos Antes")); + assertEquals(PlazoAnterior.QUINCEMINUTOSANTES,PlazoAnterior.compararHorariosDescriptos("15 Minutos Antes")); + assertEquals(PlazoAnterior.DIEZMINUTOSANTES,PlazoAnterior.compararHorariosDescriptos("10 Minutos Antes")); + assertEquals(PlazoAnterior.CINCOMINUTOSANTES,PlazoAnterior.compararHorariosDescriptos("5 Minutos Antes")); + } + +} \ No newline at end of file diff --git a/src/test/java/RepeticionCantVecesTest.java b/src/test/java/RepeticionCantVecesTest.java new file mode 100644 index 0000000..2440088 --- /dev/null +++ b/src/test/java/RepeticionCantVecesTest.java @@ -0,0 +1,53 @@ +import java.time.LocalDateTime; +import java.time.DayOfWeek; + +import org.junit.Test; +import static org.junit.Assert.*; +/** + * RepeticionCantVecesTest + */ +public class RepeticionCantVecesTest { + + @Test + public void finDeLaRepeticionFrecuenciaDiaria(){ + LocalDateTime fechaComienzoRepeticion = LocalDateTime.of(2023, 4, 4, 7, 45, 55); + int maximaCantidadDeRepeticiones = 4; + int cadaCuantosDias = 2; + RepeticionCantVeces repeticionCantVecesDePrueba = new RepeticionCantVeces(maximaCantidadDeRepeticiones, cadaCuantosDias, fechaComienzoRepeticion); + + // Esta fecha es la que cae si haces la cuenta manualmente + // (Sumarle 2 dias 4 veces a fechaComienzoRepeticion) + LocalDateTime fechaFinRepeticion = LocalDateTime.of(2023, 4, 9, 7, 45, 55); + + assertEquals(true, repeticionCantVecesDePrueba.estaDentroDeRepeticiones(fechaFinRepeticion)); + } + + @Test + public void finDeLaRepeticionFrecuenciaDiariaMismoDia(){ + LocalDateTime fechaComienzoRepeticion = LocalDateTime.of(2023, 4, 4, 7, 45, 55); + int maximaCantidadDeRepeticiones = 4; + int cadaCuantosDias = 2; + RepeticionCantVeces repeticionCantVecesDePrueba = new RepeticionCantVeces(maximaCantidadDeRepeticiones, cadaCuantosDias, fechaComienzoRepeticion); + + // (Sumarle 2 dias 4 veces a fechaComienzoRepeticion) + LocalDateTime fechaFinRepeticion = LocalDateTime.of(2023, 4, 10, 7, 45, 55); + + //assert + assertEquals(true, repeticionCantVecesDePrueba.estaDentroDeRepeticiones(fechaFinRepeticion)); + } + + @Test + public void finDeLaRepeticionPorFechaArrayDaysOfWeek(){ + LocalDateTime fechaComienzoRepeticion = LocalDateTime.of(2023, 4, 4, 7, 45, 55); + int maximaCantidadDeRepeticiones = 4; + DayOfWeek[] diasDeLaSemana = {DayOfWeek.TUESDAY, DayOfWeek.THURSDAY}; + RepeticionCantVeces repeticionCantVecesDePrueba = new RepeticionCantVeces(maximaCantidadDeRepeticiones, fechaComienzoRepeticion, diasDeLaSemana); + + // Esta fecha es la que cae si haces la cuenta manualmente + // (Martes 4, Jueves 6, Martes 11 y Jueves 13) + LocalDateTime fechaFinRepeticion = LocalDateTime.of(2023, 4, 13, 7, 45, 55); + + assertEquals(true, repeticionCantVecesDePrueba.estaDentroDeRepeticiones(fechaFinRepeticion)); + } + +} diff --git a/src/test/java/RepeticionFechaTest.java b/src/test/java/RepeticionFechaTest.java new file mode 100644 index 0000000..82bc3be --- /dev/null +++ b/src/test/java/RepeticionFechaTest.java @@ -0,0 +1,29 @@ +import java.time.LocalDateTime; + +import org.junit.Test; +import static org.junit.Assert.*; +/** + * RepeticionFechaTest + */ +public class RepeticionFechaTest { + + @Test + public void finDeLaRepeticionPorFechaAnterior(){ + //arrange + LocalDateTime fechaFinRepeticion = LocalDateTime.of(2023, 4, 22, 7, 45, 55); + + RepeticionFecha repeticionFechaDePrueba = new RepeticionFecha(fechaFinRepeticion); + + assertEquals(true, repeticionFechaDePrueba.estaDentroDeRepeticiones(fechaFinRepeticion)); + } + + @Test + public void finDeLaRepeticionPorFechaMismoDia(){ + LocalDateTime fechaFinRepeticion = LocalDateTime.of(2023, 4, 22, 7, 45, 55); + + RepeticionFecha repeticionFechaDePrueba = new RepeticionFecha(fechaFinRepeticion); + + assertEquals(true, repeticionFechaDePrueba.estaDentroDeRepeticiones(fechaFinRepeticion)); + } + +} diff --git a/src/test/java/TareaTest.java b/src/test/java/TareaTest.java index 9e61bae..e1646f9 100644 --- a/src/test/java/TareaTest.java +++ b/src/test/java/TareaTest.java @@ -1,6 +1,5 @@ import java.time.LocalDateTime; import org.junit.Test; - import static org.junit.Assert.*; @@ -9,37 +8,73 @@ */ public class TareaTest { + @Test + public void creacionDeTareaVacia() { + //arrange + LocalDateTime termina = LocalDateTime.of(2023,4,24,23,59); + Tarea tar = new Tarea(termina); + //act + + //assert + + assertEquals(termina, tar.cuandoEmpieza()); + assertEquals(termina, tar.cuandoTermina()); + termina = LocalDateTime.of(2023,4,25,23,59); + tar.setTermina(termina); + assertEquals(termina, tar.cuandoEmpieza()); + assertEquals(termina, tar.cuandoTermina()); + assertNull(tar.ultimaAlarma()); + assertEquals("", tar.getDescripcion()); + assertEquals("", tar.getTitulo()); + assertFalse(tar.esDiaEntero()); + tar.setComplete(true); + tar.setName("Nombre1"); + tar.setDescription("Descripcion1"); + assertEquals("Descripcion1", tar.getDescripcion()); + assertEquals("Nombre1", tar.getTitulo()); + assertTrue(tar.esDiaEntero()); + } + @Test public void creacionDeTarea() { //arrange - Tarea tareaDePrueba = new Tarea("Nombre Tarea", "Descripcion Tarea", false, LocalDateTime.now()); + LocalDateTime termina = LocalDateTime.of(2023,4,24,23,59); + Tarea tar = new Tarea(termina); + tar.setName("Nombre Tarea"); + tar.setDescription("Descripcion Tarea"); //act //assert - assertEquals("Nombre Tarea", tareaDePrueba.getTitulo()); - assertEquals("Descripcion Tarea", tareaDePrueba.getDescripcion()); - assertEquals(false, tareaDePrueba.esDiaEntero()); - assertEquals(false, tareaDePrueba.estaCompleta()); //Las tareas empiezan como incompletas + assertEquals("Nombre Tarea", tar.getTitulo()); + assertEquals("Descripcion Tarea", tar.getDescripcion()); + assertFalse(tar.esDiaEntero()); + assertFalse(tar.estaCompleta()); //Las tareas empiezan como incompletas + assertEquals(termina, tar.cuandoEmpieza()); + assertEquals(termina, tar.cuandoTermina()); + assertNull(tar.ultimaAlarma()); } @Test public void marcarTareaCompleta() { //arrange - Tarea tareaDePrueba = new Tarea("Nombre Tarea", "Descripcion Tarea", false, LocalDateTime.now()); + Tarea tareaDePrueba = new Tarea(LocalDateTime.now()); + tareaDePrueba.setDescription("Descripcion Tarea"); + tareaDePrueba.setName("Nombre Tarea"); //act tareaDePrueba.marcarCompleta(); //assert - assertEquals(true, tareaDePrueba.estaCompleta()); + assertTrue(tareaDePrueba.estaCompleta()); } @Test public void marcarTareaCompletaDosVecesVuelveAIncompleta() { //arrange - Tarea tareaDePrueba = new Tarea("Nombre Tarea", "Descripcion Tarea", false, LocalDateTime.now()); + Tarea tareaDePrueba = new Tarea(LocalDateTime.now()); + tareaDePrueba.setName("Nombre Tarea"); + tareaDePrueba.setDescription("Descripcion Tarea"); //act tareaDePrueba.marcarCompleta(); tareaDePrueba.marcarCompleta(); //assert - assertEquals(false, tareaDePrueba.estaCompleta()); + assertFalse(tareaDePrueba.estaCompleta()); } - }